记一次用Java求解2018侦探考试题

先上题目

这是网上非常火的刑侦科推理测试题，当时看到感觉很有意思。想着怎么解出来，尝试了一段时间以后发现自己完全hold不住呐！刹那间，灵关一现，用程序实现应该很快哦！说干就干（程序算出来以后去网上搜答案，才发现已经有人用编程搞定了）

思路

首先想到的当然是穷举法；

1. 先利用数组存储其中一种可能的排列，再把排列放到List之类的里面。

2. 利用每道题的条件进行过滤各种组合，不符合的就从List中去除。（虽然标答只有一种，可以换成满足条件直接输出）

3. 根据每道题的条件写过滤函数

4. 大功告成

正式开始码代码了

1. public class Infer {

2.    private List<Integer[]> list;

4.    public Infer() {

5.        list = new ArrayList<>();

6.    }

8.    public static void main(String[] args) {

9.        Infer obj = new Infer();

10.        obj.initData();

11.        System.out.println("数据初始化完成，共" + obj.list.size() + "种情况");

12.        for (Integer[] integers : obj.list) {

13.            if (!obj.Filter1(integers)) {

14.                continue;

15.            }

16.            if (!obj.Filter2(integers)) {

17.                continue;

18.            }

19.            if (!obj.Filter3(integers)) {

20.                continue;

21.            }

22.            if (!obj.Filter4(integers)) {

23.                continue;

24.            }

25.            if (!obj.Filter5(integers)) {

26.                continue;

27.            }

28.            if (!obj.Filter6(integers)) {

29.                continue;

30.            }

31.            if (!obj.Filter7(integers)) {

32.                continue;

33.            }

34.            if (!obj.Filter8(integers)) {

35.                continue;

36.            }

37.            if (!obj.Filter9(integers)) {

38.                continue;

39.            }

40.            if (!obj.Filter10(integers)) {

41.                continue;

42.            }

43.            obj.printArr(integers);

44.        }

45.    }

47.    public boolean Filter1(Integer[] integers) {

48.        return true;

49.    }

51.    public boolean Filter2(Integer[] integers) {

52.        int answer2 = integers[1];

53.        int answer5 = integers[4];

55.        switch (answer2) {

56.        case 0:

57.            if (answer5 == 2) {

58.                return true;

59.            }

60.            break;

61.        case 1:

62.            if (answer5 == 3) {

63.                return true;

64.            }

65.            break;

66.        case 2:

67.            if (answer5 == 0) {

68.                return true;

69.            }

70.            break;

71.        case 3:

72.            if (answer5 == 1) {

73.                return true;

74.            }

75.            break;

76.        default:

77.            return false;

78.        }

79.        return false;

80.    }

82.    public boolean Filter3(Integer[] integers) {

83.        int answer3 = integers[2];

84.        int answer6 = integers[5];

85.        int answer2 = integers[1];

86.        int answer4 = integers[3];

88.        switch (answer3) {

89.        case 0:

90.            if (answer3 == answer6 || answer3 == answer2 || answer3 == answer4) {

91.                return false;

92.            } else {

93.                return true;

94.            }

95.        case 1:

96.            if (answer6 == answer3 || answer6 == answer2 || answer6 == answer4) {

97.                return false;

98.            } else {

99.                return true;

100.            }

101.        case 2:

102.            if (answer2 == answer3 || answer2 == answer6 || answer2 == answer4) {

103.                return false;

104.            } else {

105.                return true;

106.            }

107.        case 3:

108.            if (answer4 == answer3 || answer4 == answer6 || answer4 == answer2) {

109.                return false;

110.            } else {

111.                return true;

112.            }

113.        default:

114.            return false;

115.        }

116.    }

118.    public boolean Filter4(Integer[] integers) {

119.        int answer4 = integers[3];

120.        switch (answer4) {

121.        case 0:

122.            if (integers[0] == integers[4]) {

123.                return true;

124.            } else {

125.                return false;

126.            }

127.        case 1:

129.            if (integers[1] == integers[6]) {

130.                return true;

131.            } else {

132.                return false;

133.            }

134.        case 2:

136.            if (integers[0] == integers[8]) {

137.                return true;

138.            } else {

139.                return false;

140.            }

141.        case 3:

143.            if (integers[5] == integers[9]) {

144.                return true;

145.            } else {

146.                return false;

147.            }

148.        default:

149.            break;

150.        }

151.        return false;

152.    }

154.    public boolean Filter5(Integer[] integers) {

155.        int answer5 = integers[4];

156.        switch (answer5) {

157.        case 0:

158.            if (answer5 == integers[7]) {

159.                return true;

160.            } else {

161.                return false;

162.            }

163.        case 1:

164.            if (answer5 == integers[3]) {

165.                return true;

166.            } else {

167.                return false;

168.            }

169.        case 2:

171.            if (answer5 == integers[8]) {

172.                return true;

173.            } else {

174.                return false;

175.            }

176.        case 3:

178.            if (answer5 == integers[6]) {

179.                return true;

180.            } else {

181.                return false;

182.            }

183.        default:

184.            return false;

185.        }

186.    }

188.    public boolean Filter6(Integer[] integers) {

190.        int answer6 = integers[5];

191.        int answer8 = integers[7];

192.        switch (answer6) {

193.        case 0:

194.            if (answer8 == integers[1] && answer8 == integers[3]) {

195.                return true;

196.            } else {

197.                return false;

198.            }

199.        case 1:

200.            if (answer8 == integers[0] && answer8 == integers[5]) {

201.                return true;

202.            } else {

203.                return false;

204.            }

205.        case 2:

206.            if (answer8 == integers[2] && answer8 == integers[9]) {

207.                return true;

208.            } else {

209.                return false;

210.            }

211.        case 3:

213.            if (answer8 == integers[4] && answer8 == integers[8]) {

214.                return true;

215.            } else {

216.                return false;

217.            }

218.        default:

219.            return false;

220.        }

221.    }

223.    public boolean Filter7(Integer[] integers) {

224.        int answer7 = integers[6];

225.        Map<Integer, Integer> count = count(integers);

226.        Integer count0 = count.get(0);

227.        Integer count1 = count.get(1);

228.        Integer count2 = count.get(2);

229.        Integer count3 = count.get(3);

230.        if (count0 == null) {

231.            count0 = 0;

232.        }

233.        if (count1 == null) {

234.            count1 = 0;

235.        }

236.        if (count2 == null) {

237.            count2 = 0;

238.        }

239.        if (count3 == null) {

240.            count3 = 0;

241.        }

244.        Integer countmin = Math.min(count0, count1);

245.        countmin = Math.min(countmin, count2);

246.        countmin = Math.min(countmin, count3);

247.        int minno=-1;

248.        if (count0==countmin) {

249.            minno=0;

250.        }else if (count1==countmin) {

251.            minno=1;

252.        }else if (count2==countmin) {

253.            minno=2;

254.        }else if (count3==countmin) {

255.            minno=3;

256.        }

260.        switch (answer7) {

261.        case 0:

262.            if (minno == 2) {

263.                return true;

264.            } else {

265.                return false;

266.            }

267.        case 1:

268.            if (minno == 1) {

269.                return true;

270.            } else {

271.                return false;

272.            }

273.        case 2:

274.            if (minno == 0) {

275.                return true;

276.            } else {

277.                return false;

278.            }

279.        case 3:

280.            if (minno == 3) {

281.                return true;

282.            } else {

283.                return false;

284.            }

285.        default:

286.            break;

287.        }

288.        return false;

289.    }

291.    public boolean Filter8(Integer[] integers) {

292.        int answer8 = integers[7];

293.        int answer1 = integers[0];

294.        switch (answer8) {

295.        case 0:

296.            if (answer1 + 1 == integers[6] || answer1 - 1 == integers[6]) {

297.                return false;

298.            } else {

299.                return true;

300.            }

301.        case 1:

302.            if (answer1 + 1 == integers[4] || answer1 - 1 == integers[4]) {

303.                return false;

304.            } else {

305.                return true;

306.            }

307.        case 2:

308.            if (answer1 + 1 == integers[1] || answer1 - 1 == integers[1]) {

309.                return false;

310.            } else {

311.                return true;

312.            }

313.        case 3:

314.            if (answer1 + 1 == integers[9] || answer1 - 1 == integers[9]) {

315.                return false;

316.            } else {

317.                return true;

318.            }

319.        default:

320.            break;

321.        }

322.        return false;

323.    }

325.    public boolean Filter9(Integer[] integers) {

326.        int answer8 = integers[8];

327.        boolean b16=false;

328.        if (integers[0] == integers[5]) {

329.            b16=true;

330.        }

331.        switch (answer8) {

332.        case 0:

333.            boolean b56 = integers[4] == integers[5] ? true : false;

334.            if (b16 != b56) {

335.                return true;

336.            } else {

337.                return false;

338.            }

339.        case 1:

340.            boolean b510 = integers[4] == integers[9] ? true : false;

341.            if (b16 != b510) {

342.                return true;

343.            } else {

344.                return false;

345.            }

346.        case 2:

347.            boolean b52 = integers[4] == integers[1] ? true : false;

348.            if (b16 != b52) {

349.                return true;

350.            } else {

351.                return false;

352.            }

353.        case 3:

354.            boolean b59 = integers[4] == integers[8] ? true : false;

355.            if (b16 != b59) {

356.                return true;

357.            } else {

358.                return false;

359.            }

360.        default:

361.            break;

362.        }

363.        return false;

364.    }

366.    public boolean Filter10(Integer[] integers) {

367.        int answer10 = integers[9];

368.        Map<Integer, Integer> count = count(integers);

369.        Integer count0 = count.get(0);

370.        Integer count1 = count.get(1);

371.        Integer count2 = count.get(2);

372.        Integer count3 = count.get(3);

373.        if (count0 == null) {

374.            count0 = 0;

375.        }

376.        if (count1 == null) {

377.            count1 = 0;

378.        }

379.        if (count2 == null) {

380.            count2 = 0;

381.        }

382.        if (count3 == null) {

383.            count3 = 0;

384.        }

386.        Integer countmin = Math.min(count0, count1);

387.        countmin = Math.min(countmin, count2);

388.        countmin = Math.min(countmin, count3);

390.        Integer countmax = Math.max(count0, count1);

391.        countmax = Math.max(countmax, count2);

392.        countmax = Math.max(countmax, count3);

394.        Integer maxmin = countmax - countmin;

395.        switch (answer10) {

396.        case 0:

397.            if (maxmin == 3) {

398.                return true;

399.            } else {

400.                return false;

401.            }

402.        case 1:

403.            if (maxmin == 2) {

404.                return true;

405.            } else {

406.                return false;

407.            }

408.        case 2:

409.            if (maxmin == 4) {

410.                return true;

411.            } else {

412.                return false;

413.            }

414.        case 3:

415.            if (maxmin == 1) {

416.                return true;

417.            } else {

418.                return false;

419.            }

420.        default:

421.            break;

422.        }

424.        return false;

425.    }

427.    public void printArr(Integer[] integers) {

428.        System.out.print("解:");

429.        for (int i = 0; i < integers.length; i++) {

430.            switch (integers[i]) {

431.            case 0:

432.                System.out.print("A");

433.                break;

434.            case 1:

435.                System.out.print("B");

436.                break;

437.            case 2:

438.                System.out.print("C");

439.                break;

440.            case 3:

441.                System.out.print("D");

442.                break;

443.            default:

444.                break;

445.            }

446.            if (i!=integers.length-1) {

447.                System.out.print(",");

448.            }

449.        }

450.        System.out.println();

451.    }

453.    public static Map<Integer, Integer> count(Integer[] integers) {

454.        Map<Integer, Integer> map = new HashMap<>();

455.        for (int i = 0; i < integers.length; i++) {

456.            if (!map.containsKey(integers[i])) {

457.                map.put(integers[i], 1);

458.            } else {

459.                map.put(integers[i], map.get(integers[i]) + 1);

460.            }

461.        }

462.        return map;

463.    }

465.    public void initData() {

466.        int optionnub = 4;

467.        for (int a = 0; a < optionnub; a++) {

468.            for (int b = 0; b < optionnub; b++) {

469.                for (int c = 0; c < optionnub; c++) {

470.                    for (int d = 0; d < optionnub; d++) {

471.                        for (int e = 0; e < optionnub; e++) {

472.                            for (int f = 0; f < optionnub; f++) {

473.                                for (int g = 0; g < optionnub; g++) {

474.                                    for (int h = 0; h < optionnub; h++) {

475.                                        for (int i = 0; i < optionnub; i++) {

476.                                            for (int j = 0; j < optionnub; j++) {

477.                                                Integer[] integers = { a, b, c, d, e, f, g, h, i, j };

478.                                                list.add(integers);

479.                                            }

480.                                        }

481.                                    }

482.                                }

483.                            }

484.                        }

485.                    }

486.                }

487.            }

488.        }

489.    }

490. }

完全是直接写的，没做任何优化！

这是网上非常火的刑侦科推理测试题，当时看到感觉很有意思。想着怎么解出来，尝试了一段时间以后发现自己完全hold不住呐！刹那间，灵关一现，用程序实现应该很快哦！说干就干（程序算出来以后去网上搜答案，才发现已经有人用编程搞定了）

思路

首先想到的当然是穷举法；

1. 先利用数组存储其中一种可能的排列，再把排列放到List之类的里面。

2. 利用每道题的条件进行过滤各种组合，不符合的就从List中去除。（虽然标答只有一种，可以换成满足条件直接输出）

3. 根据每道题的条件写过滤函数

4. 大功告成

正式开始码代码了

1. public class Infer {

2.    private List<Integer[]> list;

4.    public Infer() {

5.        list = new ArrayList<>();

6.    }

8.    public static void main(String[] args) {

9.        Infer obj = new Infer();

10.        obj.initData();

11.        System.out.println("数据初始化完成，共" + obj.list.size() + "种情况");

12.        for (Integer[] integers : obj.list) {

13.            if (!obj.Filter1(integers)) {

14.                continue;

15.            }

16.            if (!obj.Filter2(integers)) {

17.                continue;

18.            }

19.            if (!obj.Filter3(integers)) {

20.                continue;

21.            }

22.            if (!obj.Filter4(integers)) {

23.                continue;

24.            }

25.            if (!obj.Filter5(integers)) {

26.                continue;

27.            }

28.            if (!obj.Filter6(integers)) {

29.                continue;

30.            }

31.            if (!obj.Filter7(integers)) {

32.                continue;

33.            }

34.            if (!obj.Filter8(integers)) {

35.                continue;

36.            }

37.            if (!obj.Filter9(integers)) {

38.                continue;

39.            }

40.            if (!obj.Filter10(integers)) {

41.                continue;

42.            }

43.            obj.printArr(integers);

44.        }

45.    }

47.    public boolean Filter1(Integer[] integers) {

48.        return true;

49.    }

51.    public boolean Filter2(Integer[] integers) {

52.        int answer2 = integers[1];

53.        int answer5 = integers[4];

55.        switch (answer2) {

56.        case 0:

57.            if (answer5 == 2) {

58.                return true;

59.            }

60.            break;

61.        case 1:

62.            if (answer5 == 3) {

63.                return true;

64.            }

65.            break;

66.        case 2:

67.            if (answer5 == 0) {

68.                return true;

69.            }

70.            break;

71.        case 3:

72.            if (answer5 == 1) {

73.                return true;

74.            }

75.            break;

76.        default:

77.            return false;

78.        }

79.        return false;

80.    }

82.    public boolean Filter3(Integer[] integers) {

83.        int answer3 = integers[2];

84.        int answer6 = integers[5];

85.        int answer2 = integers[1];

86.        int answer4 = integers[3];

88.        switch (answer3) {

89.        case 0:

90.            if (answer3 == answer6 || answer3 == answer2 || answer3 == answer4) {

91.                return false;

92.            } else {

93.                return true;

94.            }

95.        case 1:

96.            if (answer6 == answer3 || answer6 == answer2 || answer6 == answer4) {

97.                return false;

98.            } else {

99.                return true;

100.            }

101.        case 2:

102.            if (answer2 == answer3 || answer2 == answer6 || answer2 == answer4) {

103.                return false;

104.            } else {

105.                return true;

106.            }

107.        case 3:

108.            if (answer4 == answer3 || answer4 == answer6 || answer4 == answer2) {

109.                return false;

110.            } else {

111.                return true;

112.            }

113.        default:

114.            return false;

115.        }

116.    }

118.    public boolean Filter4(Integer[] integers) {

119.        int answer4 = integers[3];

120.        switch (answer4) {

121.        case 0:

122.            if (integers[0] == integers[4]) {

123.                return true;

124.            } else {

125.                return false;

126.            }

127.        case 1:

129.            if (integers[1] == integers[6]) {

130.                return true;

131.            } else {

132.                return false;

133.            }

134.        case 2:

136.            if (integers[0] == integers[8]) {

137.                return true;

138.            } else {

139.                return false;

140.            }

141.        case 3:

143.            if (integers[5] == integers[9]) {

144.                return true;

145.            } else {

146.                return false;

147.            }

148.        default:

149.            break;

150.        }

151.        return false;

152.    }

154.    public boolean Filter5(Integer[] integers) {

155.        int answer5 = integers[4];

156.        switch (answer5) {

157.        case 0:

158.            if (answer5 == integers[7]) {

159.                return true;

160.            } else {

161.                return false;

162.            }

163.        case 1:

164.            if (answer5 == integers[3]) {

165.                return true;

166.            } else {

167.                return false;

168.            }

169.        case 2:

171.            if (answer5 == integers[8]) {

172.                return true;

173.            } else {

174.                return false;

175.            }

176.        case 3:

178.            if (answer5 == integers[6]) {

179.                return true;

180.            } else {

181.                return false;

182.            }

183.        default:

184.            return false;

185.        }

186.    }

188.    public boolean Filter6(Integer[] integers) {

190.        int answer6 = integers[5];

191.        int answer8 = integers[7];

192.        switch (answer6) {

193.        case 0:

194.            if (answer8 == integers[1] && answer8 == integers[3]) {

195.                return true;

196.            } else {

197.                return false;

198.            }

199.        case 1:

200.            if (answer8 == integers[0] && answer8 == integers[5]) {

201.                return true;

202.            } else {

203.                return false;

204.            }

205.        case 2:

206.            if (answer8 == integers[2] && answer8 == integers[9]) {

207.                return true;

208.            } else {

209.                return false;

210.            }

211.        case 3:

213.            if (answer8 == integers[4] && answer8 == integers[8]) {

214.                return true;

215.            } else {

216.                return false;

217.            }

218.        default:

219.            return false;

220.        }

221.    }

223.    public boolean Filter7(Integer[] integers) {

224.        int answer7 = integers[6];

225.        Map<Integer, Integer> count = count(integers);

226.        Integer count0 = count.get(0);

227.        Integer count1 = count.get(1);

228.        Integer count2 = count.get(2);

229.        Integer count3 = count.get(3);

230.        if (count0 == null) {

231.            count0 = 0;

232.        }

233.        if (count1 == null) {

234.            count1 = 0;

235.        }

236.        if (count2 == null) {

237.            count2 = 0;

238.        }

239.        if (count3 == null) {

240.            count3 = 0;

241.        }

244.        Integer countmin = Math.min(count0, count1);

245.        countmin = Math.min(countmin, count2);

246.        countmin = Math.min(countmin, count3);

247.        int minno=-1;

248.        if (count0==countmin) {

249.            minno=0;

250.        }else if (count1==countmin) {

251.            minno=1;

252.        }else if (count2==countmin) {

253.            minno=2;

254.        }else if (count3==countmin) {

255.            minno=3;

256.        }

260.        switch (answer7) {

261.        case 0:

262.            if (minno == 2) {

263.                return true;

264.            } else {

265.                return false;

266.            }

267.        case 1:

268.            if (minno == 1) {

269.                return true;

270.            } else {

271.                return false;

272.            }

273.        case 2:

274.            if (minno == 0) {

275.                return true;

276.            } else {

277.                return false;

278.            }

279.        case 3:

280.            if (minno == 3) {

281.                return true;

282.            } else {

283.                return false;

284.            }

285.        default:

286.            break;

287.        }

288.        return false;

289.    }

291.    public boolean Filter8(Integer[] integers) {

292.        int answer8 = integers[7];

293.        int answer1 = integers[0];

294.        switch (answer8) {

295.        case 0:

296.            if (answer1 + 1 == integers[6] || answer1 - 1 == integers[6]) {

297.                return false;

298.            } else {

299.                return true;

300.            }

301.        case 1:

302.            if (answer1 + 1 == integers[4] || answer1 - 1 == integers[4]) {

303.                return false;

304.            } else {

305.                return true;

306.            }

307.        case 2:

308.            if (answer1 + 1 == integers[1] || answer1 - 1 == integers[1]) {

309.                return false;

310.            } else {

311.                return true;

312.            }

313.        case 3:

314.            if (answer1 + 1 == integers[9] || answer1 - 1 == integers[9]) {

315.                return false;

316.            } else {

317.                return true;

318.            }

319.        default:

320.            break;

321.        }

322.        return false;

323.    }

325.    public boolean Filter9(Integer[] integers) {

326.        int answer8 = integers[8];

327.        boolean b16=false;

328.        if (integers[0] == integers[5]) {

329.            b16=true;

330.        }

331.        switch (answer8) {

332.        case 0:

333.            boolean b56 = integers[4] == integers[5] ? true : false;

334.            if (b16 != b56) {

335.                return true;

336.            } else {

337.                return false;

338.            }

339.        case 1:

340.            boolean b510 = integers[4] == integers[9] ? true : false;

341.            if (b16 != b510) {

342.                return true;

343.            } else {

344.                return false;

345.            }

346.        case 2:

347.            boolean b52 = integers[4] == integers[1] ? true : false;

348.            if (b16 != b52) {

349.                return true;

350.            } else {

351.                return false;

352.            }

353.        case 3:

354.            boolean b59 = integers[4] == integers[8] ? true : false;

355.            if (b16 != b59) {

356.                return true;

357.            } else {

358.                return false;

359.            }

360.        default:

361.            break;

362.        }

363.        return false;

364.    }

366.    public boolean Filter10(Integer[] integers) {

367.        int answer10 = integers[9];

368.        Map<Integer, Integer> count = count(integers);

369.        Integer count0 = count.get(0);

370.        Integer count1 = count.get(1);

371.        Integer count2 = count.get(2);

372.        Integer count3 = count.get(3);

373.        if (count0 == null) {

374.            count0 = 0;

375.        }

376.        if (count1 == null) {

377.            count1 = 0;

378.        }

379.        if (count2 == null) {

380.            count2 = 0;

381.        }

382.        if (count3 == null) {

383.            count3 = 0;

384.        }

386.        Integer countmin = Math.min(count0, count1);

387.        countmin = Math.min(countmin, count2);

388.        countmin = Math.min(countmin, count3);

390.        Integer countmax = Math.max(count0, count1);

391.        countmax = Math.max(countmax, count2);

392.        countmax = Math.max(countmax, count3);

394.        Integer maxmin = countmax - countmin;

395.        switch (answer10) {

396.        case 0:

397.            if (maxmin == 3) {

398.                return true;

399.            } else {

400.                return false;

401.            }

402.        case 1:

403.            if (maxmin == 2) {

404.                return true;

405.            } else {

406.                return false;

407.            }

408.        case 2:

409.            if (maxmin == 4) {

410.                return true;

411.            } else {

412.                return false;

413.            }

414.        case 3:

415.            if (maxmin == 1) {

416.                return true;

417.            } else {

418.                return false;

419.            }

420.        default:

421.            break;

422.        }

424.        return false;

425.    }

427.    public void printArr(Integer[] integers) {

428.        System.out.print("解:");

429.        for (int i = 0; i < integers.length; i++) {

430.            switch (integers[i]) {

431.            case 0:

432.                System.out.print("A");

433.                break;

434.            case 1:

435.                System.out.print("B");

436.                break;

437.            case 2:

438.                System.out.print("C");

439.                break;

440.            case 3:

441.                System.out.print("D");

442.                break;

443.            default:

444.                break;

445.            }

446.            if (i!=integers.length-1) {

447.                System.out.print(",");

448.            }

449.        }

450.        System.out.println();

451.    }

453.    public static Map<Integer, Integer> count(Integer[] integers) {

454.        Map<Integer, Integer> map = new HashMap<>();

455.        for (int i = 0; i < integers.length; i++) {

456.            if (!map.containsKey(integers[i])) {

457.                map.put(integers[i], 1);

458.            } else {

459.                map.put(integers[i], map.get(integers[i]) + 1);

460.            }

461.        }

462.        return map;

463.    }

465.    public void initData() {

466.        int optionnub = 4;

467.        for (int a = 0; a < optionnub; a++) {

468.            for (int b = 0; b < optionnub; b++) {

469.                for (int c = 0; c < optionnub; c++) {

470.                    for (int d = 0; d < optionnub; d++) {

471.                        for (int e = 0; e < optionnub; e++) {

472.                            for (int f = 0; f < optionnub; f++) {

473.                                for (int g = 0; g < optionnub; g++) {

474.                                    for (int h = 0; h < optionnub; h++) {

475.                                        for (int i = 0; i < optionnub; i++) {

476.                                            for (int j = 0; j < optionnub; j++) {

477.                                                Integer[] integers = { a, b, c, d, e, f, g, h, i, j };

478.                                                list.add(integers);

479.                                            }

480.                                        }

481.                                    }

482.                                }

483.                            }

484.                        }

485.                    }

486.                }

487.            }

488.        }

489.    }

490. }

完全是直接写的，没做任何优化！