为循环嵌套的C++压缩

C++ Condensing nested for loops

本文关键字：C++ 压缩 嵌套 循环      更新时间：2023-10-16

我有这些循环。

// output all possible combinations
for ( int i1 = 0; i1 <= 2; i1++ )
     {
         for ( int i2 = 0; i2 <= 2; i2++ )
             {
                 for ( int i3 = 0; i3 <= 2; i3++ )
                     {
                         for ( int i4 = 0; i4 <= 2; i4++ )
                             {
                                 for ( int i5 = 0; i5 <= 2; i5++ )
                                     {
                                         for ( int i6 = 0; i6 <= 2; i6++ )
                                             {
                                                 for ( int i7 = 0; i7 <= 2; i7++ )
                                                     {
                                                         //output created words to outFile
                                                         outFile
                                                         << phoneLetters[n[0]][i1]<< phoneLetters[n[1]][i2]
                                                         << phoneLetters[n[2]][i3]<< phoneLetters[n[3]][i4]
                                                         << phoneLetters[n[4]][i5]<< phoneLetters[n[5]][i6]
                                                         << phoneLetters[n[6]][i7]
                                                         << " ";
                                                         if ( ++count % 9 == 0 ) // form rows
                                                             outFile << std::endl;
                                                         }
                                                 }
                                         }
                                 }
                         }
                 }
         }

这看起来很糟糕，但我太新手了，不知道从哪里开始浓缩它们。

有人能给我一两个指针吗？这样我就可以把代码写得更整洁一些？

您在七个级别上索引0、1和2。这可能不是很有效，但这个怎么样：

int i1, i2, i3, i4, i5, i6, i7;
int j;
for (int i = 0; i < 2187; i++)
{
    // 0 through 2186 represent all of the ternary numbers from
    //    0000000 (base 3) to 2222222 (base 3).  The following
    //    pulls out the ternary digits and places them into i1
    //    through i7.
    j = i;
    i1 = j / 729;
    j = j - (i1 * 729);
    i2 = j / 243;
    j = j - (i2 * 243);
    i3 = j / 81;
    j = j - (i3 * 81);
    i4 = j / 27;
    j = j - (i4 * 27);
    i5 = j / 9;
    j = j - (i5 * 9);
    i6 = j / 3;
    j = j - (i6 * 3);
    i7 = j;
    // print your stuff
}

或者，根据用户315052在评论中的建议：

int d[7];
for (int i = 0; i < 2187; i++)
{
    int num = i;
    for (int j = 6; j >= 0; j--)
    {
        d[j] = num % 3;
        num = num / 3;
    }
    // print your stuff using d[0] ... d[6]]
}

在一般情况下，您可以使用递归：

template <typename Stream, typename Iterator>
void generateNumbers(Stream& stream, Iterator begin, Iterator end) {
  if (end - begin == 7) {
    for (Iterator p = begin; p < end; p++) {
      stream << phoneLetters[n[*p]][*p];
    }
    stream << " ";
  } else {
    for (*end = 0; *end <= 2; ++*end)
      generateNumbers(stream,begin,end+1);
    if (end - begin == 6)
      stream << std::endl;
  }
}

您可以使用缓冲区向量或普通的旧C数组（两者都有足够的大小）来调用它。

例如：

std::vector<int> buf(7,0);
generateNumbers(std::cout,buf.begin(),buf.begin());
// or
int buf2[7];
generateNumbers(std::cout,buf2,buf2);

但如果你的值是二进制的，PBrando的答案会更好。

我看到James McNellis已经对这个解决方案发表了评论，但现在是：

void phone_combo(int n[], int i[], int d, ostream &ofile, int &count) {
    if (d == 7) {
        //output created words to outFile
        ofile
        << phoneLetters[n[0]][i[0]]<< phoneLetters[n[1]][i[1]]
        << phoneLetters[n[2]][i[2]]<< phoneLetters[n[3]][i[3]]
        << phoneLetters[n[4]][i[4]]<< phoneLetters[n[5]][i[5]]
        << phoneLetters[n[6]][i[6]]
        << " ";
        if ( ++count % 9 == 0 ) // form rows
            ofile << std::endl;
        }
        return;
    }
    for (i[d] = 0; i[d] <= 2; i[d]++) {
        phone_combo(n, i, d+1, ofile, count);
    }
}
int i[7];
phone_combo(n, i, 0, outFile, count);

之前发布的一个响应将其简化为单个for循环，但由于某种原因被删除。

for( int i(0); i!= 2187; ++i )
{
    outFile
    << phoneLetters[n[0]][(i >> 6) & 0x01]<< phoneLetters[n[1]][(i >> 5) & 0x01]
    << phoneLetters[n[2]][(i >> 4) & 0x01]<< phoneLetters[n[3]][(i >> 3) & 0x01]
    << phoneLetters[n[4]][(i >> 2) & 0x01]<< phoneLetters[n[5]][(i >> 1) & 0x01]
    << phoneLetters[n[6]][i & 0x01]
    << ' ';
    if ( ++count % 9 == 0 ) // form rows
        outFile << 'n';
}

只有当你知道计算每个可能的排列所需的确切迭代次数时，这才有效。

相关文章：