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

先上题目

记一次用Java求解2018侦探考试题_第1张图片

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


思路

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

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

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

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

  4. 大功告成

正式开始码代码了

记一次用Java求解2018侦探考试题_第2张图片

记一次用Java求解2018侦探考试题_第3张图片


 
   
  1. public class Infer {

  2.    private List<Integer[]> list;

  3.    public Infer() {

  4.        list = new ArrayList<>();

  5.    }

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

  7.        Infer obj = new Infer();

  8.        obj.initData();

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

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

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

  12.                continue;

  13.            }

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

  15.                continue;

  16.            }

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

  18.                continue;

  19.            }

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

  21.                continue;

  22.            }

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

  24.                continue;

  25.            }

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

  27.                continue;

  28.            }

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

  30.                continue;

  31.            }

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

  33.                continue;

  34.            }

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

  36.                continue;

  37.            }

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

  39.                continue;

  40.            }

  41.            obj.printArr(integers);

  42.        }

  43.    }

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

  45.        return true;

  46.    }

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

  48.        int answer2 = integers[1];

  49.        int answer5 = integers[4];

  50.        switch (answer2) {

  51.        case 0:

  52.            if (answer5 == 2) {

  53.                return true;

  54.            }

  55.            break;

  56.        case 1:

  57.            if (answer5 == 3) {

  58.                return true;

  59.            }

  60.            break;

  61.        case 2:

  62.            if (answer5 == 0) {

  63.                return true;

  64.            }

  65.            break;

  66.        case 3:

  67.            if (answer5 == 1) {

  68.                return true;

  69.            }

  70.            break;

  71.        default:

  72.            return false;

  73.        }

  74.        return false;

  75.    }

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

  77.        int answer3 = integers[2];

  78.        int answer6 = integers[5];

  79.        int answer2 = integers[1];

  80.        int answer4 = integers[3];

  81.        switch (answer3) {

  82.        case 0:

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

  84.                return false;

  85.            } else {

  86.                return true;

  87.            }

  88.        case 1:

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

  90.                return false;

  91.            } else {

  92.                return true;

  93.            }

  94.        case 2:

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

  96.                return false;

  97.            } else {

  98.                return true;

  99.            }

  100.        case 3:

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

  102.                return false;

  103.            } else {

  104.                return true;

  105.            }

  106.        default:

  107.            return false;

  108.        }

  109.    }

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

  111.        int answer4 = integers[3];

  112.        switch (answer4) {

  113.        case 0:

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

  115.                return true;

  116.            } else {

  117.                return false;

  118.            }

  119.        case 1:

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

  121.                return true;

  122.            } else {

  123.                return false;

  124.            }

  125.        case 2:

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

  127.                return true;

  128.            } else {

  129.                return false;

  130.            }

  131.        case 3:

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

  133.                return true;

  134.            } else {

  135.                return false;

  136.            }

  137.        default:

  138.            break;

  139.        }

  140.        return false;

  141.    }

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

  143.        int answer5 = integers[4];

  144.        switch (answer5) {

  145.        case 0:

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

  147.                return true;

  148.            } else {

  149.                return false;

  150.            }

  151.        case 1:

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

  153.                return true;

  154.            } else {

  155.                return false;

  156.            }

  157.        case 2:

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

  159.                return true;

  160.            } else {

  161.                return false;

  162.            }

  163.        case 3:

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

  165.                return true;

  166.            } else {

  167.                return false;

  168.            }

  169.        default:

  170.            return false;

  171.        }

  172.    }

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

  174.        int answer6 = integers[5];

  175.        int answer8 = integers[7];

  176.        switch (answer6) {

  177.        case 0:

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

  179.                return true;

  180.            } else {

  181.                return false;

  182.            }

  183.        case 1:

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

  185.                return true;

  186.            } else {

  187.                return false;

  188.            }

  189.        case 2:

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

  191.                return true;

  192.            } else {

  193.                return false;

  194.            }

  195.        case 3:

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

  197.                return true;

  198.            } else {

  199.                return false;

  200.            }

  201.        default:

  202.            return false;

  203.        }

  204.    }

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

  206.        int answer7 = integers[6];

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

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

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

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

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

  212.        if (count0 == null) {

  213.            count0 = 0;

  214.        }

  215.        if (count1 == null) {

  216.            count1 = 0;

  217.        }

  218.        if (count2 == null) {

  219.            count2 = 0;

  220.        }

  221.        if (count3 == null) {

  222.            count3 = 0;

  223.        }

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

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

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

  227.        int minno=-1;

  228.        if (count0==countmin) {

  229.            minno=0;

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

  231.            minno=1;

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

  233.            minno=2;

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

  235.            minno=3;

  236.        }

  237.        switch (answer7) {

  238.        case 0:

  239.            if (minno == 2) {

  240.                return true;

  241.            } else {

  242.                return false;

  243.            }

  244.        case 1:

  245.            if (minno == 1) {

  246.                return true;

  247.            } else {

  248.                return false;

  249.            }

  250.        case 2:

  251.            if (minno == 0) {

  252.                return true;

  253.            } else {

  254.                return false;

  255.            }

  256.        case 3:

  257.            if (minno == 3) {

  258.                return true;

  259.            } else {

  260.                return false;

  261.            }

  262.        default:

  263.            break;

  264.        }

  265.        return false;

  266.    }

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

  268.        int answer8 = integers[7];

  269.        int answer1 = integers[0];

  270.        switch (answer8) {

  271.        case 0:

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

  273.                return false;

  274.            } else {

  275.                return true;

  276.            }

  277.        case 1:

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

  279.                return false;

  280.            } else {

  281.                return true;

  282.            }

  283.        case 2:

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

  285.                return false;

  286.            } else {

  287.                return true;

  288.            }

  289.        case 3:

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

  291.                return false;

  292.            } else {

  293.                return true;

  294.            }

  295.        default:

  296.            break;

  297.        }

  298.        return false;

  299.    }

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

  301.        int answer8 = integers[8];

  302.        boolean b16=false;

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

  304.            b16=true;

  305.        }

  306.        switch (answer8) {

  307.        case 0:

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

  309.            if (b16 != b56) {

  310.                return true;

  311.            } else {

  312.                return false;

  313.            }

  314.        case 1:

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

  316.            if (b16 != b510) {

  317.                return true;

  318.            } else {

  319.                return false;

  320.            }

  321.        case 2:

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

  323.            if (b16 != b52) {

  324.                return true;

  325.            } else {

  326.                return false;

  327.            }

  328.        case 3:

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

  330.            if (b16 != b59) {

  331.                return true;

  332.            } else {

  333.                return false;

  334.            }

  335.        default:

  336.            break;

  337.        }

  338.        return false;

  339.    }

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

  341.        int answer10 = integers[9];

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

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

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

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

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

  347.        if (count0 == null) {

  348.            count0 = 0;

  349.        }

  350.        if (count1 == null) {

  351.            count1 = 0;

  352.        }

  353.        if (count2 == null) {

  354.            count2 = 0;

  355.        }

  356.        if (count3 == null) {

  357.            count3 = 0;

  358.        }

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

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

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

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

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

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

  365.        Integer maxmin = countmax - countmin;

  366.        switch (answer10) {

  367.        case 0:

  368.            if (maxmin == 3) {

  369.                return true;

  370.            } else {

  371.                return false;

  372.            }

  373.        case 1:

  374.            if (maxmin == 2) {

  375.                return true;

  376.            } else {

  377.                return false;

  378.            }

  379.        case 2:

  380.            if (maxmin == 4) {

  381.                return true;

  382.            } else {

  383.                return false;

  384.            }

  385.        case 3:

  386.            if (maxmin == 1) {

  387.                return true;

  388.            } else {

  389.                return false;

  390.            }

  391.        default:

  392.            break;

  393.        }

  394.        return false;

  395.    }

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

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

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

  399.            switch (integers[i]) {

  400.            case 0:

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

  402.                break;

  403.            case 1:

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

  405.                break;

  406.            case 2:

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

  408.                break;

  409.            case 3:

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

  411.                break;

  412.            default:

  413.                break;

  414.            }

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

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

  417.            }

  418.        }

  419.        System.out.println();

  420.    }

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

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

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

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

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

  426.            } else {

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

  428.            }

  429.        }

  430.        return map;

  431.    }

  432.    public void initData() {

  433.        int optionnub = 4;

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

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

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

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

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

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

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

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

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

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

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

  445.                                                list.add(integers);

  446.                                            }

  447.                                        }

  448.                                    }

  449.                                }

  450.                            }

  451.                        }

  452.                    }

  453.                }

  454.            }

  455.        }

  456.    }

  457. }

完全是直接写的,没做任何优化!



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

思路

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

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

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

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

  4. 大功告成

正式开始码代码了

记一次用Java求解2018侦探考试题_第4张图片

记一次用Java求解2018侦探考试题_第5张图片


 
  
  1. public class Infer {

  2.    private List<Integer[]> list;

  3.    public Infer() {

  4.        list = new ArrayList<>();

  5.    }

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

  7.        Infer obj = new Infer();

  8.        obj.initData();

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

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

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

  12.                continue;

  13.            }

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

  15.                continue;

  16.            }

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

  18.                continue;

  19.            }

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

  21.                continue;

  22.            }

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

  24.                continue;

  25.            }

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

  27.                continue;

  28.            }

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

  30.                continue;

  31.            }

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

  33.                continue;

  34.            }

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

  36.                continue;

  37.            }

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

  39.                continue;

  40.            }

  41.            obj.printArr(integers);

  42.        }

  43.    }

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

  45.        return true;

  46.    }

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

  48.        int answer2 = integers[1];

  49.        int answer5 = integers[4];

  50.        switch (answer2) {

  51.        case 0:

  52.            if (answer5 == 2) {

  53.                return true;

  54.            }

  55.            break;

  56.        case 1:

  57.            if (answer5 == 3) {

  58.                return true;

  59.            }

  60.            break;

  61.        case 2:

  62.            if (answer5 == 0) {

  63.                return true;

  64.            }

  65.            break;

  66.        case 3:

  67.            if (answer5 == 1) {

  68.                return true;

  69.            }

  70.            break;

  71.        default:

  72.            return false;

  73.        }

  74.        return false;

  75.    }

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

  77.        int answer3 = integers[2];

  78.        int answer6 = integers[5];

  79.        int answer2 = integers[1];

  80.        int answer4 = integers[3];

  81.        switch (answer3) {

  82.        case 0:

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

  84.                return false;

  85.            } else {

  86.                return true;

  87.            }

  88.        case 1:

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

  90.                return false;

  91.            } else {

  92.                return true;

  93.            }

  94.        case 2:

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

  96.                return false;

  97.            } else {

  98.                return true;

  99.            }

  100.        case 3:

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

  102.                return false;

  103.            } else {

  104.                return true;

  105.            }

  106.        default:

  107.            return false;

  108.        }

  109.    }

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

  111.        int answer4 = integers[3];

  112.        switch (answer4) {

  113.        case 0:

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

  115.                return true;

  116.            } else {

  117.                return false;

  118.            }

  119.        case 1:

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

  121.                return true;

  122.            } else {

  123.                return false;

  124.            }

  125.        case 2:

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

  127.                return true;

  128.            } else {

  129.                return false;

  130.            }

  131.        case 3:

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

  133.                return true;

  134.            } else {

  135.                return false;

  136.            }

  137.        default:

  138.            break;

  139.        }

  140.        return false;

  141.    }

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

  143.        int answer5 = integers[4];

  144.        switch (answer5) {

  145.        case 0:

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

  147.                return true;

  148.            } else {

  149.                return false;

  150.            }

  151.        case 1:

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

  153.                return true;

  154.            } else {

  155.                return false;

  156.            }

  157.        case 2:

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

  159.                return true;

  160.            } else {

  161.                return false;

  162.            }

  163.        case 3:

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

  165.                return true;

  166.            } else {

  167.                return false;

  168.            }

  169.        default:

  170.            return false;

  171.        }

  172.    }

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

  174.        int answer6 = integers[5];

  175.        int answer8 = integers[7];

  176.        switch (answer6) {

  177.        case 0:

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

  179.                return true;

  180.            } else {

  181.                return false;

  182.            }

  183.        case 1:

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

  185.                return true;

  186.            } else {

  187.                return false;

  188.            }

  189.        case 2:

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

  191.                return true;

  192.            } else {

  193.                return false;

  194.            }

  195.        case 3:

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

  197.                return true;

  198.            } else {

  199.                return false;

  200.            }

  201.        default:

  202.            return false;

  203.        }

  204.    }

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

  206.        int answer7 = integers[6];

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

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

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

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

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

  212.        if (count0 == null) {

  213.            count0 = 0;

  214.        }

  215.        if (count1 == null) {

  216.            count1 = 0;

  217.        }

  218.        if (count2 == null) {

  219.            count2 = 0;

  220.        }

  221.        if (count3 == null) {

  222.            count3 = 0;

  223.        }

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

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

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

  227.        int minno=-1;

  228.        if (count0==countmin) {

  229.            minno=0;

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

  231.            minno=1;

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

  233.            minno=2;

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

  235.            minno=3;

  236.        }

  237.        switch (answer7) {

  238.        case 0:

  239.            if (minno == 2) {

  240.                return true;

  241.            } else {

  242.                return false;

  243.            }

  244.        case 1:

  245.            if (minno == 1) {

  246.                return true;

  247.            } else {

  248.                return false;

  249.            }

  250.        case 2:

  251.            if (minno == 0) {

  252.                return true;

  253.            } else {

  254.                return false;

  255.            }

  256.        case 3:

  257.            if (minno == 3) {

  258.                return true;

  259.            } else {

  260.                return false;

  261.            }

  262.        default:

  263.            break;

  264.        }

  265.        return false;

  266.    }

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

  268.        int answer8 = integers[7];

  269.        int answer1 = integers[0];

  270.        switch (answer8) {

  271.        case 0:

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

  273.                return false;

  274.            } else {

  275.                return true;

  276.            }

  277.        case 1:

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

  279.                return false;

  280.            } else {

  281.                return true;

  282.            }

  283.        case 2:

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

  285.                return false;

  286.            } else {

  287.                return true;

  288.            }

  289.        case 3:

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

  291.                return false;

  292.            } else {

  293.                return true;

  294.            }

  295.        default:

  296.            break;

  297.        }

  298.        return false;

  299.    }

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

  301.        int answer8 = integers[8];

  302.        boolean b16=false;

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

  304.            b16=true;

  305.        }

  306.        switch (answer8) {

  307.        case 0:

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

  309.            if (b16 != b56) {

  310.                return true;

  311.            } else {

  312.                return false;

  313.            }

  314.        case 1:

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

  316.            if (b16 != b510) {

  317.                return true;

  318.            } else {

  319.                return false;

  320.            }

  321.        case 2:

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

  323.            if (b16 != b52) {

  324.                return true;

  325.            } else {

  326.                return false;

  327.            }

  328.        case 3:

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

  330.            if (b16 != b59) {

  331.                return true;

  332.            } else {

  333.                return false;

  334.            }

  335.        default:

  336.            break;

  337.        }

  338.        return false;

  339.    }

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

  341.        int answer10 = integers[9];

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

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

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

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

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

  347.        if (count0 == null) {

  348.            count0 = 0;

  349.        }

  350.        if (count1 == null) {

  351.            count1 = 0;

  352.        }

  353.        if (count2 == null) {

  354.            count2 = 0;

  355.        }

  356.        if (count3 == null) {

  357.            count3 = 0;

  358.        }

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

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

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

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

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

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

  365.        Integer maxmin = countmax - countmin;

  366.        switch (answer10) {

  367.        case 0:

  368.            if (maxmin == 3) {

  369.                return true;

  370.            } else {

  371.                return false;

  372.            }

  373.        case 1:

  374.            if (maxmin == 2) {

  375.                return true;

  376.            } else {

  377.                return false;

  378.            }

  379.        case 2:

  380.            if (maxmin == 4) {

  381.                return true;

  382.            } else {

  383.                return false;

  384.            }

  385.        case 3:

  386.            if (maxmin == 1) {

  387.                return true;

  388.            } else {

  389.                return false;

  390.            }

  391.        default:

  392.            break;

  393.        }

  394.        return false;

  395.    }

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

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

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

  399.            switch (integers[i]) {

  400.            case 0:

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

  402.                break;

  403.            case 1:

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

  405.                break;

  406.            case 2:

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

  408.                break;

  409.            case 3:

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

  411.                break;

  412.            default:

  413.                break;

  414.            }

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

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

  417.            }

  418.        }

  419.        System.out.println();

  420.    }

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

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

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

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

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

  426.            } else {

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

  428.            }

  429.        }

  430.        return map;

  431.    }

  432.    public void initData() {

  433.        int optionnub = 4;

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

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

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

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

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

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

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

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

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

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

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

  445.                                                list.add(integers);

  446.                                            }

  447.                                        }

  448.                                    }

  449.                                }

  450.                            }

  451.                        }

  452.                    }

  453.                }

  454.            }

  455.        }

  456.    }

  457. }

完全是直接写的,没做任何优化!


你可能感兴趣的:(记一次用Java求解2018侦探考试题)