Question

例如，您将获得一个整数n（在编译时）。你的任务是创建具有不同循环控制变量（array [0]，array [1] .i，j，k ...）的嵌套循环，并且在所有循环的范围内，执行如下语句：cout<<"Hello, World"<<endl并且可以使用所有循环控制变量（这样可以设计使用循环控制变量的逻辑）。与n一起，其他信息如初始值和第i（0到n）循环控制变量的条件可以是我们的目标应该是使流程灵活和通用。是可能用C或C ++或Java或....（流行编程语言）？

n = 3的C ++代码可以是：

for(int i = 0; i<n; i++)
{
    for(int j = 0; j<n; j++)
    {
        for(int k = 0; k<i+j; k++)
        {
            cout<<i*j+k<<endl;
        }
    }
}

对于n = 4，它可能是

for(int i = 0; i<n; i++)
{
    for(int j = 0; j<n; j++)
    {
        for(int k = 0; k<i+j; k++)
        {
            for(int l = 0; l<k+3; l++)
            {
                cout<<i*j+k-l<<endl;
            }

        }
    }
}

Answer 1

可以类似于里程表实现可变嵌套循环。如果所有计数器的结束值不相同，则您有一个计数器数组和一个结束值数组。对于每个循环，最低有效计数器递增，并且当它达到其结束值时，它被重置为开始计数，并且下一个最低有效计数器递增，检查它是否到达它＆＃39; s结束值等。

Answer 2

这样的事情怎么样？不是最漂亮的，但应该做的是创建n层循环，其中n可以在运行时定义。（c ++，但是如果你替换了std :: vector，你可以使用所有语言）

void func(const std::vector<int*>& controlVars, int remainingLayers) {

    int i = 0;
    controlVars.push_back(&i);
    for (; i < n; ++i) {

        if (remainingLayers == 0) {
            // Read control var vector and do something
        }
        else {
            func(controlVars, remainingLayers - 1);
        }
    }
    controlVars.pop_back();
}

Answer 3

这是递归的用例：

void loop(int n, int count = -1) {
    if (count == -1) //Could be helper function too
        count = n;
    else if (count == 1) { //Last loop contains logic
        for (int i = 0; i < n; ++i)
            std::cout << "Hello World!\n"; //To have access to the loop variables,
                                           //make a std::vector
        return; //Stop
    }

    for (int i = 0; i < n; ++i)
        loops(n, count - 1);
}

然后您可以使用以下方式调用它：

loop(3); //3 Nested for loops
loop(4); //4 Nested for loops

您还可以通过将函数指针传递给必须执行的函数来使loop更通用。

Answer 4

对于固定边界，您可以

bool increase(const std::vector<std::size_t>& v, std::vector<std::size_t>& it)
{
    for (std::size_t i = 0, size = it.size(); i != size; ++i) {
        const std::size_t index = size - 1 - i;
        ++it[index];
        if (it[index] > v[index]) {
            it[index] = 0;
        } else {
            return true;
        }
    }
    return false;
}

void iterate(const std::vector<std::size_t>& v)
{
    std::vector<std::size_t> it(v.size(), 0);

    do {
        do_job(it);
    } while (increase(v, it));
}

Demo

对于依赖范围，您可以将其改编为：

bool increase(const std::vector<std::function<std::size_t()>>& v,
              std::vector<std::size_t>& it)
{
    for (std::size_t i = 0, size = it.size(); i != size; ++i) {
        const std::size_t index = size - 1 - i;
        ++it[index];
        if (it[index] > v[index]()) {
            it[index] = 0;
        } else {
            return true;
        }
    }
    return false;
}

void iterate(std::vector<std::size_t>& it,
             const std::vector<std::function<std::size_t()>>& v)
{
    do {
        do_job(it);
    } while (increase(v, it));
}

使用类似于：

std::vector<std::size_t> its(3, 0);
std::vector<std::function<std::size_t()>> bounds = {
    []{ return 2; },
    []{ return 3; },
    [&its]{ return its[0] + its[1]; },
};

iterate(its, bounds);

Demo

Answer 5

c ++ +11每个循环都有界限（如果你打算使用上面提到的数组循环）

#include <iostream>
int main()
{
    int fibonacci[] = { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };
    for (int number : fibonacci) // iterate over array fibonacci
       std::cout << number << ' '; // we access the array element for this iteration through variable number

    return 0;
}

Answer 6

一种方法是使用一个函数模板来获取一个函数（最里面的循环体）和一些边界：

// Single loop, end of recursion
template<class Function>
void nested_loop( Function && f, std::size_t k)
{
    for ( std::size_t i = 0; i < k; ++i )
        f(i);
}

// General case, Bounds is expected to be convertible to std::size_t.
template<class Function, class ... Bounds>
void nested_loop( Function && f, std::size_t k, Bounds && ... bounds)
{
    for ( std::size_t i = 0;i < k; ++i )
    {
        // The lambda expression here binds 'i' to the first argument
        // of f.
        nested_loop( 
            [f = std::forward<Function>(f), i](auto && ... args)
            {
                return f(i, args ...);
            },
            bounds ... );
    }
}

可以这样使用：

nested_loop(
    [](int i, int j) { cout << i << ", " << j << endl; },
    2,4 );

这可以简单地扩展为支持依赖于外部循环的迭代变量的循环边界。为此，您需要Bounds作为可调用对象，并在每一步将迭代变量绑定到其第一个参数。

是否可以执行n个嵌套＆＃34;循环（任意）＆＃34;（具有不同的循环控制变量），其中给出n？

6 个答案: