要是面试的时候不会 怎么办

大笑哈哈 发表于 2016-5-27 23:21
这个就是为了回答，开发这么写会被打死吧

为什么？这做法挺好的啊？

yangben 发表于 2016-6-10 23:23
为什么？这做法挺好的啊？

我觉得局限性太强了,这种判断完全可以抽取成方法

我也来深受指教啦!

1. public class Test {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 for (int i = 1; i <= 4; i++)
   
6.                         for (int j = 1; j <= 4; j++)
   
7.                                 for (int k = 1; k <= 4; k++)
   
8.                                         for (int l = 1; l <= 4; l++) {
   
9.                                                 if (i == j || j == k || k == l || i == k || i == l
   
10.                                                                 || j == l || i == 4) {
    
11.                                                         continue;
    
12.                                                 } else if ((i % 2 != 0) && (k % 2 != 0) || (j % 2 != 0)
    
13.                                                                 && (l % 2 != 0) || (i % 2 != 0) && (l % 2 != 0)) {
    
14. 
    
15.                                                         System.out.println("" + i + j + k + l);
    
16.                                                 }
    
17.                                         }
    
18.         }
    
19. }

复制代码

PS ： 题主也肯定想要一个比较满意的答案，然而，看到这个问题，从早上一直思考到现在。期间也查过一些资料，这里还是从笨的方面入了手，还是有不同的地方。
首先关于解题思路想说 2 点：
（1）可以尝试使用正则表达式来排除不满足条件的字符串，然后输出（一个思路，可以试试）。
（2）笨办法：逐条筛选

上面代码思路分析：
（1）通过 4 层循环来分别确定 4 位数字
（2）第一个 if 排除数字重复、第一位为 4 的情况
（3）第二个 if 判断 （1 和 3）或者 （2 和 4）的位置，要么是在1、3；1、4；2、4。判断这些位置同奇、同偶即可。具体分布参考下方图片



希望有所帮助，{:3_56:}

NumberIteraror.java

1. import java.util.Arrays;
   
2. import java.util.Iterator;
   
3. import java.util.NoSuchElementException;
   
4. 
   
5. /**
   
6. * 一个数字的迭代器<br>
   
7. * 可通过 next 返回一个 Integer 数组，每一个元素代表在这一位上的数字，返回值是大端序的<br>
   
8. * 此实现不是多线程安全的<br>
   
9. * 最大可描述不大于 2 ^ 32 进制、不长于 Integer.MAX_VALUE 位的所有数字
   
10. *
    
11. * @author Cat73
    
12. */
    
13. public class NumberIterator implements Iterator<Integer[]> {
    
14.     private final int min;
    
15.     private final int max;
    
16.     private final int length;
    
17.     private boolean hasNext = true;
    
18.     private final Integer[] number;
    
19. 
    
20.     /**
    
21.      * 构造一个新的数字迭代器
    
22.      *
    
23.      * @param min 每个位上的数字最小是多少？
    
24.      * @param max 每个位上的数字最大是多少？
    
25.      * @param length 这个数字有多长？
    
26.      * @throws RuntimeException 如果 min > max
    
27.      * @throws IndexOutOfBoundsException 如果长度小于 1
    
28.      */
    
29.     public NumberIterator(final int min, final int max, final int length) {
    
30.         // 输入检查
    
31.         if (min > max) {
    
32.             throw new RuntimeException("max: " + max + ", min: " + min);
    
33.         } else if (length < 1) {
    
34.             throw new IndexOutOfBoundsException(Integer.toString(length));
    
35.         }
    
36. 
    
37.         // 初始化属性
    
38.         this.min = min;
    
39.         this.max = max;
    
40.         this.length = length;
    
41.         this.number = new Integer[this.length];
    
42. 
    
43.         // 初始化值到最小值
    
44.         for (int i = 0; i < this.length; i++) {
    
45.             this.number[i] = this.min;
    
46.         }
    
47.     }
    
48. 
    
49.     @Override
    
50.     public Integer[] next() {
    
51.         // 如果没有下一个元素则抛出异常
    
52.         if (!this.hasNext) {
    
53.             throw new NoSuchElementException();
    
54.         }
    
55. 
    
56.         // 将当前数值当做结果
    
57.         final Integer[] result = Arrays.copyOf(this.number, this.length);
    
58. 
    
59.         // 将数字加 1
    
60.         this.number[0] += 1;
    
61.         for (int i = 0; i < this.length && this.number[i] > this.max; i++) {
    
62.             // 如果无法再进位则视为没有下一个元素
    
63.             if (i + 1 >= this.length) {
    
64.                 this.hasNext = false;
    
65.             } else {
    
66.                 this.number[i] = this.min;
    
67.                 this.number[i + 1] += 1;
    
68.             }
    
69.         }
    
70. 
    
71.         // 返回当前元素
    
72.         return result;
    
73.     }
    
74. 
    
75.     @Override
    
76.     public boolean hasNext() {
    
77.         return this.hasNext;
    
78.     }
    
79. }
    

复制代码

Main.java

1. import java.util.Iterator;
   
2. 
   
3. public final class Main {
   
4.     public static void main(final String args[]) throws Exception {
   
5.         // 初始化一个数字迭代器
   
6.         final Iterator<Integer[]> it = new NumberIteraror(1, 4, 4);
   
7. 
   
8.         // 循环判断每一个数字
   
9.         loop: while (it.hasNext()) {
   
10.             // 获取下一个数字
    
11.             final Integer[] num = it.next();
    
12. 
    
13.             // 4 不能做开头
    
14.             if (num[0] == 4) {
    
15.                 continue loop;
    
16.             }
    
17. 
    
18.             // 1 与 3 不能在一起
    
19.             for (int i = 0; i < num.length - 1; i++) {
    
20.                 if (num[i] == 1 && num[i + 1] == 3 || num[i] == 3 && num[i + 1] == 1) {
    
21.                     continue loop;
    
22.                 }
    
23.             }
    
24. 
    
25.             // 数字不能重复
    
26.             for (int i = 0; i < num.length; i++) {
    
27.                 for (int j = 0; j < num.length; j++) {
    
28.                     if (i != j && num[i] == num[j]) {
    
29.                         continue loop;
    
30.                     }
    
31.                 }
    
32.             }
    
33. 
    
34.             // 输出结果
    
35.             for (final int n : num) {
    
36.                 System.out.print(n);
    
37.             }
    
38.             System.out.println();
    
39.         }
    
40.     }
    
41. }
    

复制代码

输出

1. 3421
   
2. 3241
   
3. 2341
   
4. 3412
   
5. 1432
   
6. 1423
   
7. 2143
   
8. 1243
   
9. 3214
   
10. 1234
    

复制代码

看看都怎么写的