需要重构深度嵌套代码的帮助

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

if(range>i)

为什么不直接在 range 处启动 i 来避免这个问题呢？哦，我的想法是倒退的，但重点是——你可以轻松地重构这是 for 条件的一部分。不需要额外的条件。

if(j>i)

为什么不直接在 i 处启动 j 呢？

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

这消除了一半的嵌套。就循环本身而言，我建议对其使用提取方法。

Answer 2

您可以做的第一件事是使用继续：

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
    }
}

这将大大减少嵌套，并且在我看来提高可读性。

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;
}

上面唯一真正值得评论的是计算
calc 中的 limit，这实际上只是一种优化；你可以
使用 n 并获得相同的结果（但您会更多地递归）。

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

另外，我的代码使用了 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(" ");
    }