如何解决这个奇怪的多循环场景（Java或C#）？

我有一个可能很小的循环/组合问题，类似于二进制组合。我不知道如何有效地处理它。考虑这个场景，我需要一个唯一的循环来通过序列中的所有这些组合：

Round  ABC

01.    000 <- values of A=0, B=0, C=0
02.    001
03.    010
04.    011
05.    100
06.    101
07.    110
08.    111

09.    002
10.    012
11.    102
12.    112
13.    020
14.    021
15.    120
16.    121 <- values of A=1, B=2, C=1
17.    022
18.    122
19.    220
20.    221
21.    222

现在字母（A，B，C…）对应于许多可能的纸币或硬币价值（$1，$5，$100）。而底部对应于该纸币/硬币的多个部分（例如$5001/$5000=1个最大值）。

伪C#/Java的草图：

将A-L映射到索引0-11

const int[] maxvalues = { define max values for each var }
int[] counters = { initialize with 0s }

while (true)
{
  for(i in 11..0)
  {
    counters[i]++;
    if (counters[i] < maxvalues[i])
      break;   // for
    counters[i] = 0;
  }

  if (counters[0] == maxvalues[0])
    break;     // while

  print(counters.ToDisplayString());
}

const int[]maxvalues={为每个变量定义最大值}
int[]计数器={用0s初始化}
while（true）
{
for（i在11..0中）
{
计数器[i]++；
if（计数器[i]

---

（请注意，第二个序列与OP中的第一个序列不匹配。如果OP是正确的，我想我没有“获取”序列）

您描述的数字序列可以通过从0开始向上计数来进行枚举，其基数表示为比创建单个序列所用的“字母”数量高1

一种简单的方法是使用从基数10开始的函数，它将作用于一个变量，该变量在一个循环中从0递增到您希望实现的最大组合数

下面是一个实现：

void Main()
{
    for(int i=0; i< 50; i++){
     Console.Write(convert(5,i));
     Console.Write("\n");
    }
}

string convert(int N, int M){
    Stack<int> stack = new Stack<int>();

    while (M >= N){
     stack.Push(M %N);
     M = M / N;
    }
    string str = M.ToString();
    while(stack.Count() > 0)
      str = str + stack.Pop().ToString();
    return str;
}

void Main（）
{
对于（int i=0；i<50；i++）{
Console.Write（转换（5，i））；
控制台。写入（“\n”）；
}
}
字符串转换（整数N，整数M）{
堆栈=新堆栈（）；
而（M>=N）{
堆栈推送（M%N）；
M=M/N；
}
string str=M.ToString（）；
while（stack.Count（）>0）
str=str+stack.Pop（）.ToString（）；
返回str；
}

开始输出：

0 1. 2. 3. 4. 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 40 41 42 43 44 100 101 102 103

---

104

如果我猜对了序列，那么递归生成序列就更容易了

这里是Java中的一种方法，它应该生成一个与您的场景相匹配的序列。 我希望它能帮助你（也许我以后会补充更多的解释）：

publicstaticvoidinit（）{
//定义常数
最终整数长度=3；
最终字符最大值='3'；
//定义缓冲区
final char[]array=new char[length]；java.util.array.fill（数组“0”）；
final boolean[]alreadySet=new boolean[length]；java.util.array.fill（alreadySet，false）；
//填充第一个数字，然后让递归发生
对于（字符c='1'；c=0；i--）{
//设定值
数组[i]=c；
alreadySet[i]=真；
//打印值
System.out.println（新字符串（数组））；
//调用递归
递归（数组、c、i、alreadySet、长度）；
//未设定值
alreadySet[i]=假；
数组[i]=“0”；
}
}
}
公共静态void recursive（char[]数组、char lastValue、int lastIndex、boolean[]alreadySet、int leftoset）{
//如果我们没有设置所有数字
如果（leftToSet>0）{
//从最低数字迭代到最高数字
对于（int i=array.length-1；i>=0；i--）{
//缺少已设置的所有数字
如果（！alreadySet[i]）{
//从1到lastValue-1计数
for（char c='1'；clastIndex；i--）{
//缺少已设置的所有数字
如果（！alreadySet[i]）{
//设定值
数组[i]=c；
alreadySet[i]=真；
//打印值
System.out.println（新字符串（数组））；
//调用递归
递归（数组、c、i、alreadySet、leftToSet-1）；
//未设定值
alreadySet[i]=假；
数组[i]=“0”；
}
}
}
}

有趣的序列-为什么第二组（值9到16）在第一个位置从来没有“2”？是的，它继续说：022、122、220、221、222，…您可能想解释序列，我发现不太可能有人能用你迄今为止给出的结果来确定确切的序列。我想只要你能用简单的英语表达出你需要的序列类型，你也会有你正在寻找的算法。+这本身就是一个挑战，甚至要理解序列级数的确切规则。就像智商测试一样。if（counters[0]=maxvalues[0]）应该是if（counters[0]==maxvalues[0]）嗨，谢谢，我无法用肉眼判断它是否做了它应该做的事情。给我一点时间试试。：）@SmartK8：它不能匹配，因为没有正式的方法来描述这个序列。这就相当于每个字母有一个for循环。所以，如果C的最大值是1000，它首先变为0-1000，B增加1，C再次变为0-1000。不好。然后我如何解码哪个字母的多少个片段（数字）？这不会产生OP的序列。请注意，她的序列在第12个和第15个元素之间改变了方向（如果以n为基数观察）。@Groo，OP的序列（没有完全解释）似乎是我提供的序列的一个微小变化。我只是不知道如何将例如13解码回a=1（1个），B=2（2个），C=1（1个）？你能告诉我埃拉吗

void Main()
{
    for(int i=0; i< 50; i++){
     Console.Write(convert(5,i));
     Console.Write("\n");
    }
}

string convert(int N, int M){
    Stack<int> stack = new Stack<int>();

    while (M >= N){
     stack.Push(M %N);
     M = M / N;
    }
    string str = M.ToString();
    while(stack.Count() > 0)
      str = str + stack.Pop().ToString();
    return str;
}

public static void init() {
    // define constants
    final int length = 3;
    final char maxValue = '3';

    // define buffer
    final char[] array = new char[length]; java.util.Arrays.fill(array, '0');
    final boolean[] alreadySet = new boolean[length]; java.util.Arrays.fill(alreadySet, false);

    // fill first digit, then let the recursion take place
    for(char c = '1'; c <= (char)(maxValue); c++) {
        // iterate from lowest to highest digit
        for(int i = array.length-1; i >= 0; i--) {
            // set value
            array[i] = c;
            alreadySet[i] = true;
            // print value
            System.out.println(new String(array));
            // call recursion
            recursive(array, c, i, alreadySet, length);
            // unset value
            alreadySet[i] = false;
            array[i] = '0';
        }
    }
}

public static void recursive(char[] array, char lastValue, int lastIndex, boolean[] alreadySet, int leftToSet) {
    // if we didn't set all digits
    if(leftToSet > 0) {
        // iterate from lowest to highest digit
        for(int i = array.length-1; i >= 0; i--) {
            // missing all digits already set
            if(!alreadySet[i]) {
                // count from 1 to lastValue-1
                for(char c = '1'; c < lastValue; c++) {
                    // set value
                    array[i] = c;
                    alreadySet[i] = true;
                    // print value
                    System.out.println(new String(array));
                    // call recursion
                    recursive(array, c, i, alreadySet, leftToSet-1);
                    // unset value
                    alreadySet[i] = false;
                    array[i] = '0';
                }
            }
        }

        char c = lastValue;
        // iterate from lowest to highest digit
        for(int i = array.length-1; i > lastIndex; i--) {
            // missing all digits already set
            if(!alreadySet[i]) {
                // set value
                array[i] = c;
                alreadySet[i] = true;
                // print value
                System.out.println(new String(array));
                // call recursion
                recursive(array, c, i, alreadySet, leftToSet-1);
                // unset value
                alreadySet[i] = false;
                array[i] = '0';
            }
        }
    }
}