Question

我必须解决以下问题：

problem

9个值，从1到9（0和10不被接受）和所有数字需要不同。

为了解决这个问题，我为循环中的循环制作了那些可怕的东西（我又添加了两个条件来检查我是否有其中一个解决方案）
它正在工作，但我想知道如何以更好的方式在for循环中创建for循环？

此外，每个数字不能等于另一个数字。你怎么能比我做到这一点呢？（同样，可以删除2个第一个条件）

这是代码：

var a = 1, b = 1, c = 1, d = 1, e = 1, f = 1, g = 1, h = 1, i = 1;

var x = 0;

var result = [];

function calc(){

  x = a + 13 * b / c + d + 12 * e - f - 11 + g * h / i - 10;

  if(x == 66){
     result.push([a, b , c , d , e, f, g, h, i] );
  }
}

for(a = 1; a < 10; a++){
    calc();
    for(b = 1; b < 10; b++){
        calc();
        for(c = 1; c < 10; c++){
            calc();
            for(d = 1; d < 10; d++){
                calc();
                for(e = 1; e < 10; e++){
                    calc();
                    for(f = 1; f < 10; f++){
                        calc();
                        for(g = 1; g < 10; g++){
                            calc();
                            for(h = 1; h < 10; h++){
                                calc();
                                for(i = 1; i < 10; i++){
                                    calc();
                                }
                            }
                        }
                    }
                }
            }
        }
    }

}

console.log(result);

var result2 = result.filter(function(el){

    return el[0] == 5 && el[1] == 9 && el[0] != el[1] &&  el[0] != el[2] && el[0] != el[3] && el[0] != el[4] &&   el[0] != el[5] &&   el[0] != el[6] &&   el[0] != el[7] &&   el[0] != el[8] && el[1] != el[0] && el[1] != el[2] && el[1] != el[3] && el[1] != el[4] &&   el[1] != el[5] &&   el[1] != el[6] &&   el[1] != el[7] && el[1] != el[8] &&  el[2] != el[0] && el[2] != el[1] && el[2] != el[3] && el[2] != el[4] && el[2] != el[5] && el[2] != el[6] &&  el[2] != el[7] && el[2] != el[8] && el[3] != el[0] && el[3] != el[1] && el[3] != el[2] && el[3] != el[4] && el[3] != el[5] && el[3] != el[6] && el[3] != el[7] &&  el[3] != el[8] &&  el[4] != el[0] && el[4] != el[1] && el[4] != el[2] && el[4] != el[3] && el[4] != el[5] && el[4] != el[6] && el[4] != el[7] && el[4] != el[8] && el[5] != el[0] && el[5] != el[1] && el[5] != el[2] && el[5] != el[3] && el[5] != el[4] && el[5] != el[6] && el[5] != el[7] && el[5] != el[8] && el[6] != el[1] && el[6] != el[2] && el[6] != el[3] && el[6] != el[4] && el[6] != el[5] && el[6] != el[7] && el[6] != el[8] && el[7] != el[0] && el[7] != el[1] && [7] != el[2] && el[7] != el[3] && el[7] != el[4] && el[7] != el[5] && el[7] != el[6] && el[7] != el[8] && el[8] != el[0] && el[8] != el[1] && el[8] != el[2] && el[8] != el[3] && el[8] != el[4] && el[8] != el[5] && el[8] != el[6] && el[8] != el[7];

});

console.log(result2);

Answer 1

对于初学者，您可以像这样N x嵌套for循环

nested_for in C++

您可以将问题作为9位数生成

来处理

由于您的数字没有重复，您可以放弃多次迭代。如果以上述方式编码（如嵌套），你会得到类似的东西：

C ++中的广义排列（不重复）：

//---------------------------------------------------------------------------
//--- permutation class ver 0.00 --------------------------------------------
//---------------------------------------------------------------------------
#ifndef _permutation_h
#define _permutation_h
/*---------------------------------------------------------------------------
    // usage:
    permutation per;
    per.alloc(N);

    per.first();
    for (;;)
        {
        ... here per.i[0..N-1] contains actual permutation
        ... N! permutations
        if (!per.next()) break;
        }
//-------------------------------------------------------------------------*/
class permutation
    {
public:
    int  *i;    // i[N] permutation
    BYTE *a;    // a[N] item not used yet ?
    int   N;    // items
    int  ix;    // actual permutation layer
    permutation()   { N=0; i=NULL; a=NULL; ix=0; }
    permutation(permutation& b) { *this=b; }
    ~permutation()  { free(); }
    permutation* operator = (const permutation *b) { *this=*b; return this; }
    permutation* operator = (const permutation &b) { alloc(b.N); for (int j=0;j<N;j++) { i[j]=b.i[j]; a[j]=b.a[j]; } ix=b.ix; return this; }

    void alloc(int _N)
        {
        free();
        i=new  int[_N];
        if (i==NULL) return;
        a=new BYTE[_N];
        if (a==NULL) { free(); return; }
        N=_N;
        }
    void free ()
        {
        N=0; ix=0;
        if (i!=NULL) delete i; i=NULL;
        if (a!=NULL) delete a; a=NULL;
        }
    void first()                                        // init permutation
        {
        for (ix=0;ix<N;ix++)
            {
            i[ix]=ix;
            a[ix]=0;
            } ix--;
        }
    bool next()                                         // next permutation return if it is not last
        {
        int *ii=&i[ix];
        for (;;)
            {
            if (*ii>=0) a[*ii]=1;
            for ((*ii)++;*ii<N;(*ii)++) if (a[*ii]) { a[*ii]=0; break; }
            if (*ii>=N)
                {
                if (ix==  0) return false;
                *ii=-1; ix--; ii=&i[ix];
                }
            else{
                if (ix==N-1) return true;
                ix++; ii=&i[ix];
                }
            }
        }
    };
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

重要的内容是first()和next()成员，每个排列都作为索引存储在i[]数组中，因此设置为N=9，输出数字为{{ 1}}

以下列方式运作：

(per.i[0]+1),(per.i[1]+1),...,(per.i[9]+1)将排列初始化为州first()和i[9]=(0,1,2,...8)

我会这样简单地写这个：a[9]=(0,0,0,...0)其中
- i=012345678,a=000000000指向最后一位数字
- ix是实际的排列
- i标记数字未使用（1）或使用（0）（以避免a操作）
O(N^N)增加到下一个有效排列

将最后一位数字增加到下一个未使用的值。如果没有未使用的值将其设置为未使用并增加前一个数字。溢出也是如此。第一次迭代将是这样的：
```
next()
```
下一次迭代：
```
i=012345678,a=000000000 // starting iteration
i=01234567? a=000000001 // unset (no unused values)
i=01234568? a=000000010 // increment 8th digit
i=012345687 a=000000000 // set the last digit result
```
我希望它足够清楚。

粗略如果使用递归而不是迭代，代码看起来会更好但是在大多数语言中由于堆栈/堆垃圾而运行速度也会变慢

@NikolaDimitroff指出这是在 C ++ 而不是javascript所以：

忽略i=012345687 a=000000000 // starting iteration i=01234568? a=000000010 // unset (no unused values) i=0123456?? a=000000011 // unset (8->9 overflow) i=0123457?? a=000000101 // increment 7th digit i=01234576? a=000000001 // after overflow digit set to lowest free value i=012345768 a=000000000 // after overflow digit set to lowest free value

new,delete

class

设置first(),next()，数组N=9;可以是静态的，如：i,a

这里是C ++中任务的解决方案int i[9]; BYTE a[9];：

O(N!)

javascript：为for循环创建for循环

1 个答案: