Question

#include <iostream>
using namespace std;

int main()
{
    int range = 20;
    int totalCombinations = 0;

    for(int i=1; i<=range-2; i++)
    {
        if(range>i)
        {
            for(int j=1; j<=range-1; j++)
                if(j>i)
                {
                    for(int k=1; k<=range-1; k++)
                        if(k>j)
                        {
                            for(int l=1; l<=range-1; l++)
                                if(l>k)
                                {
                                    for(int m=1; m<=range-1; m++)
                                        if(m>l)
                                        {
                                            for(int f=1; f<=range; f++)
                                                if(f>m)
                                                {
                                                    cout << " " <<i<< " " <<j<< " " <<k<< " " <<l<< " " <<m<< " " <<f;
                                                    cin.get(); //pause
                                                    totalCombinations++;
                                                }
                                        }
                                }
                        }
                }
        }
    }
    cout << "TotalCombinations:" << totalCombinations;
}

Answer 1

您可以做的第一件事是using continue：

for(int i=1; i<=range-2; i++) {
{
    if(range<=i) {
       continue;
    }

    for(int j=1; j<=range-1; j++) {
        if(j<=i) {
           continue;
        }
        //etc for all inner loops
    }
}

这将大大减少嵌套和IMO提高可读性。

Answer 2

if(range>i)

~~为什么不在i开始range并避免出现问题？~~哦，我有倒退，但重点是 - 你可以很容易地重构这个for条件的一部分。无需额外的条件。

if(j>i)

为什么不在j开始i？

...（对其他两个循环重复）

摆脱了一半的筑巢。就循环本身而言，我建议在它们上使用Extract Method。

Answer 3

与重构任何东西的方式相同。你首先要弄清楚是什么代码正在做。在这种情况下，许多测试是无关紧要的，并且每个循环基本上都是一样的。你已经解决了一个问题一般问题的具体情况（非常草率）。锻炼问题的一般算法将导致更清洁，更简单解决方案，更一般的解决方案。像这样：

class Combin
{
    int m;
    int n;
    int total;
    std::vector<int> values;

    void calc();
    void dumpVector() const;
public:
    Combin( int m, int n ) : m(m), n(n), total(0) {}
    int operator()() { total = 0; values.clear(); calc(); return total; }
};

void 
Combin::calc()
{
    if ( values.size() == m ) {
        dumpVector();
        ++ total;
    } else {
        values.push_back( values.empty() ? 0 : values.back() + 1 );
        int limit = n - (m - values.size());
        while ( values.back() < limit ) {
            calc();
            ++ values.back();
        }
        values.pop_back();
    }
}

void
Combin::dumpVector() const
{
    for (std::vector<int>::const_iterator iter = values.begin(); iter != values.end(); ++ iter )
        std::cout << ' ' << *iter + 1;
    std::cout << '\n';
}

int main()
{
    Combin c( 6, 20 );
    std::cout << "TotalCombinations:" << c() << std::endl;
    return 0;
}

上面唯一真正值得评论的是计算 limit中的calc，这只是一个优化;你可以使用n并得到相同的结果（但你要再多一点）。

你会注意到你的原始版本中的结束条件循环或多或少是任意的：系统地使用range会工作，或者你可以计算我用于limit的公式（其中会导致每个循环的结束条件不同。

另外，我的代码使用半开放区间，这些区间在C和C中无处不在 C ++。我想，一旦你习惯了它们，你会发现它们很多更容易推理。

Answer 4

我的C ++生锈了，所以让我给你一个C＃的例子。任何数量的嵌套循环只能用一个替换，如下所示：

    public void ManyNestedLoopsTest()
    {
        var limits = new[] {2, 3, 4};
        var permutation = new[] {1, 1, 0};
        const int lastDigit = 2;
        var digitToChange = lastDigit;
        while(digitToChange >= 0)
        {
            if (permutation[digitToChange] < limits[digitToChange])
            {
                permutation[digitToChange]++;
                digitToChange = lastDigit;
                PrintPermutation(permutation);
                continue;
            }
            permutation[digitToChange--] = 1;
        }
    }

    private void PrintPermutation(int[] permutation)
    {
        for(int i=0;i<3;i++)
        {
            Console.Write(permutation[i]);
            Console.Write(" ");
        }
        Console.WriteLine(" ");
    }

需要帮助重构深层嵌套代码

4 个答案: