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

最新推荐文章于 2021-02-26 04:47:58 发布
最新推荐文章于 2021-02-26 04:47:58 发布
阅读量325 收藏
点赞数
文章标签： Java 2018刑侦题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShervenLee/article/details/80561287
版权

先上题目

这是网上非常火的刑侦科推理测试题，当时看到感觉很有意思。想着怎么解出来，尝试了一段时间以后发现自己完全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. }
 

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

 
 
 


                

        

        

    




    

      

        

            

              
                
                  ShervenLee
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
网红题2018刑侦科推理测试题（终于敲出来啦！！！！！！）

				
			

			

				

					weixin_41678132的博客
				

				

					03-10
					
					3万+
					
				

			

		

		

			
				
哈哈哈哈哈哈，终于把他敲出来了，附心路历程（关键下面那个特特特特特别大的循环一共循环了1048576次，次数太多了，能不能再简单点呢）心路历程：正常逻辑思考已知： 一.单选           二.9题为入口           三.两个条件：               1.1题与6题答案相同为真，X题与5题答案相同为假               2.1题与6题答案相同为假，X题与5题答案相同...

			
		

	



                

              
                



	

		

			

				
					
2018刑侦推理 java_2018年刑侦推理试题解答

				
			

			

				

					weixin_30786631的博客
				

				

					02-23
					
					252
					
				

			

		

		

			
				
2018年刑侦推理试题:此题一出，吓退了一大批原本还对刑侦专业跃跃欲试的各路英雄好汉。这组题目应该如何入手呢？还是先给答案，再来细说解题思路好了。答案解题思路以此题为例，做一个简单的python小教程。提取"第x题的答案"首先，观察到题目中经常出现的说法是：“第x题的答案”怎样怎样，那么常用的一个过程就是要提取第x题的答案。在python中可以使用的一个数据结构叫作列表list。列表是使用[ ]括...

			
		

	



                


  
              

                


	

		

			

				
					
java判断凶手_逻辑推理题:谁是凶手

				
			

			

				

					weixin_39926678的博客
				

				

					02-26
					
					383
					
				

			

		

		

			
				
public classFindMuderer {static enumJOB {DOCTOR, LAWYER}static enumSEX {MAN, WOMEN}static classPepole {String name;JOB job;SEX sex;staticPepole newPepole(String name, JOB job, SEX sex) {Pepole p= newP...

			
		

	





	

		

			

				
					
2018侦探推理题

				
			

			

				

					King8611的博客
				

				

					07-11
					
					3996
					
				

			

		

		

			
				
据说这是今年的侦探题，不过是好早的了，当时写出来没有开博客，今天发出来吧。思路就是用dfs暴力枚举每道题的答案，然后很多if判断答案是否正确，代码还是有一些赘余。是用JAVA写的。说一下复杂度问题，因为是4个选项，复杂度是4^10，2^20;大概就是1000^2=1e6；加上大量的判断，也不过是1e7。这个复杂度并不算太高，所以暴力枚举是行得通的。public class For {
static...

			
		

	



		

			
		



	

		

			

				
					
(百例编程)12.抓交通肇事犯

				
			

			

				

					流连不忘返
				

				

					05-26
					
					3137
					
				

			

		

		

			
				
题目：一辆卡车违反交通规则，撞人后逃跑。现场有三人目击事件，但都没有记住车号，只记下车号的一些特征。甲说：牌照的前两位数字是相同的；乙说：牌照的后两位数字是相同的，但与前两位不同； 丙是数学家，他说：四位的车号刚好是一个整数的平方。请根据以上线索求出车号。

#include 
using namespace std;
int main(void)
{
 int a[4];
    for (

			
		

	





	

		

			

				
					
Java实现求解一元n次多项式的方法示例

				
			

			

				

					08-28
				

			

		

		

			
				
Java 实现求解一元 n 次多项式是 Java 编程中的一种常见操作，涉及到矩阵运算和高斯消元法等技术。本文将详细介绍 Java 实现求解一元 n 次多项式的方法，并提供相应的代码示例。  什么是一元 n 次多项式？ 一元 n 次...

			
		

	





	

		

			

				
					
实数一元二次方程求解算法-java代码

				
			

			

				

					09-21
				

			

		

		

			
				
实数一元二次方程求解算法--java代码

			
		

	





	

		

			

				
					
复实数的一元二次方程求解-java代码实现

				
			

			

				

					09-21
				

			

		

		

			
				
复实数的一元二次方程求解--java代码实现

			
		

	





	

		

			

				
					
Java求解一元二次方程.zip

				
			

			

				

					09-28
				

			

		

		

			
				
本主题聚焦于使用Java解决数学问题，特别是如何利用Java来求解一元二次方程。一元二次方程是形如ax² + bx + c = 0的方程，其中a、b、c是常数，a不等于0。求解这类方程是基础数学中的重要部分，而在实际编程中，这样...

			
		

	





	

		

			

				
					
基于Java关于二元一次方程求根源码.zip

					
最新发布

				
			

			

				

					10-25
				

			

		

		

			
				
总结一下，"基于Java关于二元一次方程求根"的项目提供了用Java编程语言实现的一元二次方程求解功能。它包含一个名为`Equation`的类，其中的`quadraticSolver`方法负责计算方程的根。通过这个类和相应的测试代码，...

			
		

	





	

		

			

				
					
noip2003侦探推理详解

				
			

			

				

					Eirlys的博客
				

				

					11-12
					
					3272
					
				

			

		

		

			
				
耗费了我三个多小时才想明白，orz orz orz
这题就是个坑←_←，这数据就是个逗比→_→ 
题目要求各位自寻，我不想再看见这道题第二遍=A=（数据我就珍藏了=。=）
读入的处理完全是noip提高组的难度，这里P党感觉敲过去就好=。=
对于数据的吐槽我就不写了，因为根本吐槽不完，出数据的简直就是认（sang）真（xin）负（bing）责（kuang），
网上有一个吐槽：http://

			
		

	





	

		

			

				
					
浅谈移位运算符与&0xFF操作

				
			

			

				

					名侦探张六儿的博客
				

				

					03-20
					
					6241
					
				

			

		

		

			
				
Java中的三个移位运算符："&gt;&gt;","&lt;&lt;","&gt;&gt;&gt;"分别有其各自的意义1. "&gt;&gt;"表示将一个二进制表示的数字进行右移操作，如n&gt;&gt;2，相当于将数字n右移两位，也就是将n除以4的结果。2."&lt;&lt;"表示将一个二进制表示的数字进

			
		

	





	

		

			

				
					
使用java程序解推理试题-----2018刑侦科推理试题

				
			

			

				

					qq_39161091的博客
				

				

					03-16
					
					490
					
				

			

		

		

			
				
2018刑侦科推理试题 分析：下面是我写的简单java代码：package cn.sangol.test;

public class ABCD_Demo {
	final static String []ABCD={"*","A","B","C","D"};
	public static void main(String[] args) {
		String result="答案如下:"

			
		

	





	

		

			

				
					
java2018刑侦推理题

				
			

			

				

					u011165335的博客
				

				

					03-10
					
					1094
					
				

			

		

		

			
				
先看看原题:1.这道题的答案是:A.A  B.B  C.C  D.D2.第五题的答案是:A.C  B.D  C.A  D.B3.以下选项中哪一题的答案与其他三项不同:A第3题  B.第6题  C.第2题  D.第4题4.以下选项中那两题的答案相同:A.第1,5题  B.第2,7题  C.第1,9题  D.第6,10题5.以下选项中哪一题的答案与本题相同:A.第8题  B.第4题  C.第9题  D...

			
		

	





	

		

			

				
					
2018刑侦推理 java_2018年刑侦推理题，看见有人用python写的，想知道java怎么写，求思路...

				
			

			

				

					weixin_28807529的博客
				

				

					02-23
					
					59
					
				

			

		

		

			
				
该楼层疑似违规已被系统折叠隐藏此楼查看此楼import java.util.ArrayList;import java.util.List;public class Test {public static void main(String[] para) {int[] arr;int p0 = pow(4, 0);int p1 = pow(4, 1);int p2 = pow(4, 2);int...

			
		

	





	

		

			

				
					
侦探推理（题解）

				
			

			

				

					华天才的博客
				

				

					01-04
					
					1123
					
				

			

		

		

			
				
题目描述
明明同学最近迷上了侦探漫画《柯南》并沉醉于推理游戏之中，于是他召集了一群同学玩推理游戏。游戏的内容是这样的，明明的同学们先商量好由其中的一个人充当罪犯（在明明不知情的情况下），明明的任务就是找出这个罪犯。接着，明明逐个询问每一个同学，被询问者可能会说：

证词中出现的其他话，都不列入逻辑推理的内容。
明明所知道的是，他的同学中有NN个人始终说假话，其余的人始终说真。
现在，明明需要你帮助...

			
		

	





	

		

			

				
					
用java输入一个一元一次方程并求解

				
			

			

				

					07-15
				

			

		

		

			
				
当然，我可以帮你编写一个Java程序来输入一个一元一次方程并求解。以下是一个示例代码：

```java
import java.util.Scanner;

public class EquationSolver {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入一个一元一次方程：");
        String equation = scanner.nextLine();

        // 将方程进行整理
        String[] parts = equation.split("=");
        String leftSide = parts[0].trim();
        String rightSide = parts[1].trim();

        String[] leftTerms = leftSide.split("(?=[-+])");
        String[] rightTerms = rightSide.split("(?=[-+])");

        double coefficient = 0;
        double constantTerm = 0;

        for (String term : leftTerms) {
            if (term.contains("a")) {
                if (term.equals("a")) {
                    coefficient += 1;
                } else if (term.equals("-a")) {
                    coefficient -= 1;
                } else {
                    coefficient += Double.parseDouble(term.substring(0, term.indexOf("a")));
                }
            } else {
                constantTerm -= Double.parseDouble(term);
            }
        }

        for (String term : rightTerms) {
            if (term.contains("a")) {
                if (term.equals("a")) {
                    coefficient -= 1;
                } else if (term.equals("-a")) {
                    coefficient += 1;
                } else {
                    coefficient -= Double.parseDouble(term.substring(0, term.indexOf("a")));
                }
            } else {
                constantTerm += Double.parseDouble(term);
            }
        }

        // 解方程
        double solution = -constantTerm / coefficient;

        System.out.printf("解方程的结果是：%.3f", solution);

        scanner.close();
    }
}
```

这个程序可以接收用户输入的一个一元一次方程，并求解方程。程序会先将方程进行整理，然后解析出系数和常数项，最后计算出方程的解，并输出结果。

你可以运行这个程序并输入一个一元一次方程，例如输入"6a - 5 + 1 = 2 - 2a"，程序会输出解方程的结果。

希望这个程序能满足你的需求。如果有任何问题，请随时提问。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值