动态嵌套循环（C+；+；） 你好，我在寻找一种方法来编写这个C++代码的一般方式，所以如果想要一个20列，我就不必为循环写20： for(int i=1; i<6; i++) { for(int j=i; j<6; j++) { for(int k=j; k<6; k++) { for(int m=k; m<6; m++) { std::cout << i << j << k << m << std::endl; } } } } for（int i=1；i

此函数对我有效，但如果希望它完成，请不要使用20调用它

#include <list>
#include <iostream>

std::list<std::list<int>> fun (std::list<std::list<int>> inputlist, int counter)
{
    if(counter == 0)
    {
        return inputlist;
    }
    else
    {
        std::list<std::list<int>> outputlist;
        for(std::list<int> oldlist : inputlist)
        {
            for(int i = 1; i<6; i++)
            {
                std::list<int> newlist = oldlist;
                newlist.push_back(i);
                outputlist.push_back(newlist);
            }
        }
        return fun(outputlist, counter - 1);
    }
}

int main()
{
    std::list<int> somelist;
    std::list<std::list<int>> listlist;
    listlist.push_back(somelist);
    std::list<std::list<int>> manynumbers = fun (listlist,5);
    for (std::list<int> somenumbers : manynumbers)
    {
        for(int k : somenumbers)
        {
            std::cout<<k;
        }
        std::cout<<std::endl;
    }
    return 0;
}

#包括
#包括
std:：list fun（std:：list inputlist，int计数器）
{
如果（计数器==0）
{
返回输入列表；
}
其他的
{
std：：列表输出列表；
用于（标准：：列表旧列表：输入列表）
{
对于（int i=1；i，此递归函数应能工作：

#include <iostream>

bool inc( int *indexes, int limit, int n )
{
    if( ++indexes[n] < limit )
        return true;
    if( n == 0 ) return false;
    if( inc( indexes, limit, n-1 ) ) {
        indexes[n] = indexes[n-1];
        return true;
    }
    return false;

}

int main()
{
    const size_t N=3;
    int indexes[N];
    for( size_t i = 0; i < N; ++i ) indexes[i] = 1;

    do {
        for( size_t i = 0; i < N; ++i ) std::cout << indexes[i] << ' ';
        std::cout << std::endl;
    } while( inc( indexes, 6, N-1 ) );
    return 0;
}

#包括
布尔公司（整数*索引，整数限制，整数n）
{
如果（++索引[n]<限制）
返回true；
如果（n==0）返回false；
if（inc（索引，限制，n-1））{
索引[n]=索引[n-1]；
返回true；
}
返回false；
}
int main（）
{
常数大小N=3；
int索引[N]；
对于（size_t i=0；i
void loopFunction（int targetLevel、int actualLevel、int min、int max、字符串前缀）{
/*
targetLevel是通缉级别（在您的情况下为20）
实际级别从1开始
分钟从1开始
max是显示的最大数字（在您的情况下为6）
前缀从空开始
参见下面的用法（在设置功能中）
*/
对于（int m=min；m来说，这里的设计很简单。我们采用一个
std:：vector
每个包含维度计数，一个
std:：vector
每个维度包含一个当前索引

advance
按
amt
推进当前维度索引束（默认值1）


不需要递归

上面的缺点是它生成6^20个元素，然后进行过滤。我们不想生成那么多元素

void advance( std::vector<size_t>& indexes, std::vector<size_t> const& counts, size_t amt=1 ) {
  if (indexes.size() < counts.size())
    indexes.resize(counts.size());
  for (size_t i = 0; i < counts.size(); ++i ) {
    indexes[i]+=amt;
    if (indexes[i] < counts[i])
    {
      size_t min = indexes[i];
      // enforce <= ordering:
      for (size_t j = i+i; j < counts.size(); ++j) {
        if (indexes[j]<min)
          indexes[j]=min;
        else
          break; // other elements already follow <= transitively
      }
      assert(vector_ascending(indexes));
      return;
    }
    assert(counts[i]!=0);
    amt = indexes[i]/counts[i];
    indexes[i] = indexes[i]%counts[i];
  }
  // past the end, don't advance:
  indexes = counts;
}

void advance（标准：：向量和索引，标准：：向量常量和计数，大小\u t amt=1）{
if（index.size（）//执行嗯，我不是写答案最快的人……当我开始写的时候，没有其他答案。无论如何，这是我的版本：

#include <iostream>
#include <vector>
using namespace std;

class Multiindex {
    public:
        typedef std::vector<int> Index;
        Multiindex(int dims,int size) : 
             dims(dims),size(size),index(Index(dims,0)){}
        void next(){
            int j=dims-1;
            while (nextAt(j) && j >= 0){j--;}
        }
        Index index;
        bool hasNext(){return !(index[0]==size-1);}
    private:
        bool nextAt(int j){
            index[j] = index[j]+1;
            bool overflow = (index[j]==size);
            if (!overflow && j < dims-1){std::fill(index.begin() + j + 1,index.end(),index[j]);}
            return overflow;
        }
    int dims;
    int size;
};

int main() {
   Multiindex m(4,6);
   while (m.hasNext()){
       cout << m.index[0] << m.index[1] << m.index[2] << m.index[3] << endl;
       m.next();
   }
   cout << m.index[0] << m.index[1] << m.index[2] << m.index[3] << endl;
   return 0;
}

#包括
#包括
使用名称空间std；
类多索引{
公众：
向量索引；
多索引（整数dims，整数大小）：
dims（dims），大小（size），索引（索引（dims，0））{
作废下一页（）{
int j=dims-1；
而（nextAt（j）&&j>=0）{j--；}
}
指数；
bool hasNext（）{return！（索引[0]==size-1）；}
私人：
布尔下一站（国际j）{
指数[j]=指数[j]+1；
bool溢出=（索引[j]==大小）；
如果（！overflow&&j你试过什么吗？std:：slice？有实际用途吗？或者只是好奇？6^20是一个相当大的数字。@Yakk实际用途是我的数字代表索引，我需要以这样的方式列出它们，以便使用它们。此外，我只是使用数字20作为一个极端的例子。因为我想遵循a>=顺序m的顺序y数应该是177100（=二项式（25,6））@cdrjohn这一点很好。改进了我的答案，这样它就不会执行6^20步来查找那些177100元素了。（你的进步没有考虑到他的“>=”requirement@tobi303是的。现在修好了。你也不考虑他的“>=” requirement@tobi303啊，错过了。如果follow a>=order意味着先打印小的数字，我的函数会这样做。非常感谢您的代码。我尝试了它，它成功了。我不会用20列运行它，我只是用这个数字来表示我希望有列数变量。我很高兴我能帮上忙。如果您在性能可能成为问题的任何情况下都需要该函数（或者你实际上想用20来称呼它），但其他一些解决方案更好。（例如，Slava的函数在我的电脑上与N=20一起工作）谢谢你的代码Slava。这将是我将要使用的选项。我曾想过自己的递归，但我的尝试真的令人震惊。
bool vector_ascending( std::vector<size_t> const& v ) {
  for (size_t i = 1; (i < v.size()); ++i) {
    if (v[i-1] < v[i]) {
      return false;
    }
  }
  return true;
}

void print_a_lot( std::vector<size_t> counts ) {
  for( std::vector<size_t> v(counts.size()); v < counts; advance(v,counts)) {
    // check validity
    if (!vector_ascending(v))
      continue;
    for (size_t x : v)
      std::cout << (x+1);
    std::cout << std::endl;
  }
}

void advance( std::vector<size_t>& indexes, std::vector<size_t> const& counts, size_t amt=1 ) {
  if (indexes.size() < counts.size())
    indexes.resize(counts.size());
  for (size_t i = 0; i < counts.size(); ++i ) {
    indexes[i]+=amt;
    if (indexes[i] < counts[i])
    {
      size_t min = indexes[i];
      // enforce <= ordering:
      for (size_t j = i+i; j < counts.size(); ++j) {
        if (indexes[j]<min)
          indexes[j]=min;
        else
          break; // other elements already follow <= transitively
      }
      assert(vector_ascending(indexes));
      return;
    }
    assert(counts[i]!=0);
    amt = indexes[i]/counts[i];
    indexes[i] = indexes[i]%counts[i];
  }
  // past the end, don't advance:
  indexes = counts;
}

#include <iostream>
#include <vector>
using namespace std;

class Multiindex {
    public:
        typedef std::vector<int> Index;
        Multiindex(int dims,int size) : 
             dims(dims),size(size),index(Index(dims,0)){}
        void next(){
            int j=dims-1;
            while (nextAt(j) && j >= 0){j--;}
        }
        Index index;
        bool hasNext(){return !(index[0]==size-1);}
    private:
        bool nextAt(int j){
            index[j] = index[j]+1;
            bool overflow = (index[j]==size);
            if (!overflow && j < dims-1){std::fill(index.begin() + j + 1,index.end(),index[j]);}
            return overflow;
        }
    int dims;
    int size;
};

int main() {
   Multiindex m(4,6);
   while (m.hasNext()){
       cout << m.index[0] << m.index[1] << m.index[2] << m.index[3] << endl;
       m.next();
   }
   cout << m.index[0] << m.index[1] << m.index[2] << m.index[3] << endl;
   return 0;
}