比如说,我有n个变量, 还有m个数值(比喻说有全是整数)
我想要做的是一个表格,自动形成的
形式如下(类似于true-false table)
a1 a2 ... a(n-1) an
1  1  ... 1      1
1  1  ... 1      2
1  1  ... 1      3
;  ;  ;   ;      ;
1  1  ... 1      n
1  1  ... 2      1
1  1  ... 2      2
依此类推,这样的问题如何实现, 谢谢

解决方案 »

  1.   

    如果用欠套的for的话,如何判断应该写几个for呢
      

  2.   

    理论上说应该是m次循环,比如当m=3时:
                for (int i = 1; i <= 3; i++)
                {
                    for (int j = 1; j <= 3; j++)
                    {
                        for (int k = 1; k <= 3; k++)
                        {
                            Console.WriteLine("{0}\t{1}\t{2}", i, j, k);
                        }
                    }
                }
                Console.ReadLine();输出如下所示:
    1       1       1
    1       1       2
    1       1       3
    1       2       1
    1       2       2
    1       2       3
    1       3       1
    1       3       2
    1       3       3
    2       1       1
    2       1       2
    2       1       3
    2       2       1
    2       2       2
    2       2       3
    2       3       1
    2       3       2
    2       3       3
    3       1       1
    3       1       2
    3       1       3
    3       2       1
    3       2       2
    3       2       3
    3       3       1
    3       3       2
    3       3       3这样太麻烦,应该还有更好的办法...
      

  3.   

    可是我不知道m的具体的值
    如何得知该写多少个for循环呢
    m的值是根据数据库的其他值而定的, 不是指定好的
      

  4.   

    两层嵌套:
    代码如下:
                int m, n;
                Console.WriteLine("Input m:");
                m =Convert .ToInt32 ( Console.ReadLine());
                Console.WriteLine("Input n:");
                n =Convert .ToInt32 ( Console.ReadLine());
                //总的行数为m的n次幂
                for (int i = 0; i < (int)System.Math.Pow(m, n); i++)
                {
                    for (int j = 0; j < n; j++)
                    {
                        int div=(int )System .Math .Pow (m ,(n-j-1));
                        Console.Write((i / div) % m + 1);
                        Console.Write("\t");
                    }
                    Console.Write("\n");
                }测试如下:
    Input m:
    4
    Input n:
    3
    1       1       1
    1       1       2
    1       1       3
    1       1       4
    1       2       1
    1       2       2
    1       2       3
    1       2       4
    1       3       1
    1       3       2
    1       3       3
    1       3       4
    1       4       1
    1       4       2
    1       4       3
    1       4       4
    2       1       1
    2       1       2
    2       1       3
    2       1       4
    2       2       1
    2       2       2
    2       2       3
    2       2       4
    2       3       1
    2       3       2
    2       3       3
    2       3       4
    2       4       1
    2       4       2
    2       4       3
    2       4       4
    3       1       1
    3       1       2
    3       1       3
    3       1       4
    3       2       1
    3       2       2
    3       2       3
    3       2       4
    3       3       1
    3       3       2
    3       3       3
    3       3       4
    3       4       1
    3       4       2
    3       4       3
    3       4       4
    4       1       1
    4       1       2
    4       1       3
    4       1       4
    4       2       1
    4       2       2
    4       2       3
    4       2       4
    4       3       1
    4       3       2
    4       3       3
    4       3       4
    4       4       1
    4       4       2
    4       4       3
    4       4       4
    请按任意键继续. . .