.题目：有1、2、3三个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？???
需要把这三个数 转为数组 遍历 再用字符串拼接吗?

int[] arr = {1,2,3};
                for (int i = 0; i < arr.length; i++) {
                        for (int j = 0; j < arr.length ; j++) {
                                for (int j2 = 0; j2 < arr.length; j2++) {
                                        System.out.println(arr + "" + arr[j] + "" + arr[j2] + "");
                                }
                        }
                }

三个循环就可以搞定，不用数组
由排列组合可知三个数组成一个各不相同的数有6个
int n；
int a=0；
for（int i =1；i《=3；i++）｛
    for（int j =1；j《=3；；j++） ｛
         for（int k =1；k 《=3；k++） ｛
                    if （i！=j&&i！=k&&j！=k） ｛
                           n=i*100+j*10+k；
                            a++；
｝
｝
｝
｝
System.out.print（n+“  ”）；
System.out.println（）；
System.out.println（a）；
                        

aslwq2012 发表于 2016-7-6 17:35
三个循环就可以搞定，不用数组
由排列组合可知三个数组成一个各不相同的数有6个
int n；

其实你这个做法扩展性并不好，如果我换一个要求：
A-Z 总共 26 个字母，可以组成无重复字母的组合有多少种？
你就要做 26 层循环嵌套。。。。

cat73 发表于 2016-7-6 17:40
其实你这个做法扩展性并不好，如果我换一个要求：
A-Z 总共 26 个字母，可以组成无重复字母的组合有多少 ...

是的，毕竟用循环的话局限性太大，小数据的话，循环好理解，0.0

如果只要数量的话，其实可以直接用数学计算求解的。。。
代码随便写写的，效率很低，还很有优化空间。。。

1.     public static void main(final String args[]) throws Exception {
   
2.         new Main()._main(args);
   
3.     }
   
4. 
   
5.     private void _main(final String args[]) throws Exception {
   
6.         int count = this.calc(System.out, new char[] { '1', '2', '3', '4' });
   
7.         System.out.println("一共有 " + count + " 种组合.");
   
8.     }
   
9. 
   
10.     /**
    
11.      * @param out 输出每一种可能的组合的流，如不需要输出请设置为 null
    
12.      * @param chs 每一个可能的值
    
13.      */
    
14.     public int calc(final PrintStream out, final char[] chs) {
    
15.         // 准备一个数组保存每一位的状态
    
16.         final int[] array = new int[chs.length];
    
17.         for (int i = 0; i < chs.length; i++) {
    
18.             array[i] = 0;
    
19.         }
    
20. 
    
21.         // 组合数量
    
22.         int result = 0;
    
23. 
    
24.         // 循环求解
    
25.         while (true) {
    
26.             // 当前数是否符合规则：每一位上的数字均不同
    
27.             boolean ok = true;
    
28.             for (int i = 0; i < array.length; i++) {
    
29.                 for (int j = 0; j < array.length; j++) {
    
30.                     if (i != j && array[i] == array[j]) {
    
31.                         ok = false;
    
32.                         break;
    
33.                     }
    
34.                 }
    
35.                 if (!ok) {
    
36.                     break;
    
37.                 }
    
38.             }
    
39.             // 如果符合规则则将计数器加 1，并输出结果
    
40.             if (ok) {
    
41.                 result += 1;
    
42. 
    
43.                 if (out != null) {
    
44.                     final StringBuilder sb = new StringBuilder(array.length);
    
45.                     for (final int element : array) {
    
46.                         sb.append(chs[element]);
    
47.                     }
    
48.                     out.println(sb.toString());
    
49.                 }
    
50.             }
    
51. 
    
52.             // 将第一位加 1，如果第一位已经超过了最大值，则进行进位，如已经没有下一个位用于进位，则返回结果
    
53.             array[0] += 1;
    
54.             for (int i = 0; i < array.length && array[i] == chs.length; i++) {
    
55.                 array[i] = 0;
    
56.                 if (i + 1 < array.length) {
    
57.                     array[i + 1] += 1;
    
58.                 } else {
    
59.                     return result;
    
60.                 }
    
61.             }
    
62.         }
    
63.     }

复制代码

输出结果：

1. 4321
   
2. 3421
   
3. 4231
   
4. 2431
   
5. 3241
   
6. 2341
   
7. 4312
   
8. 3412
   
9. 4132
   
10. 1432
    
11. 3142
    
12. 1342
    
13. 4213
    
14. 2413
    
15. 4123
    
16. 1423
    
17. 2143
    
18. 1243
    
19. 3214
    
20. 2314
    
21. 3124
    
22. 1324
    
23. 2134
    
24. 1234
    
25. 一共有 24 种组合.
    

复制代码

cat73 发表于 2016-7-6 18:12
如果只要数量的话，其实可以直接用数学计算求解的。。。
代码随便写写的，效率很低，还很有优化空间。。。
...

非常感谢`` 长知识咯