JAVA逻辑推理题2-2018刑侦科推理试题

最新推荐文章于 2021-02-15 23:57:59 发布

林与夕

最新推荐文章于 2021-02-15 23:57:59 发布

阅读量312

点赞数 1

分类专栏： java 文章标签：逻辑推理

本文链接：https://blog.csdn.net/qq_33436466/article/details/97373074

版权

java 专栏收录该内容

47 篇文章 0 订阅

订阅专栏

package demo;

import java.util.*;
import java.util.stream.Collectors;

public class Lj2 {

    private static final Map<Integer, String> INDEX_MAP_ANSWER = new HashMap<>();//用数字代替答案选项
    static {
        INDEX_MAP_ANSWER.put(1, "A");
        INDEX_MAP_ANSWER.put(2, "B");
        INDEX_MAP_ANSWER.put(3, "C");
        INDEX_MAP_ANSWER.put(4, "D");
    }

    private static final int N = 10; //10道题

    private static int[] answers = new int[N]; //10道题的答案

    public static void main(String[] args) {
        violenceEnumeration(0);
    }

    //递归代替N次for循环 
    //暴力枚举，每道题有A B C D四种可能，则10道题共有4的十次方种可能
    private static void violenceEnumeration(int problemIndex) {
        problemIndex++;
        for (int answer = 0; answer < INDEX_MAP_ANSWER.size(); answer++) {
            answers[problemIndex - 1] = answer + 1;  //设置答案
            if (problemIndex != N) {  //10道题
                violenceEnumeration(problemIndex);
            } else {
                if (valid(answers))  //开始验证答案是否正确，可能不止唯一解
                    print(answers);
            }
        }
    }

    private static boolean valid(int... x) {
        int A = x[0], B = x[1], C = x[2], D = x[3], E = x[4], F = x[5], G = x[6], H = x[7], I = x[8], J = x[9];
    //    boolean a = A == 1 || A == 2 || A == 3 || A == 4;
    //    if (!a) return false;
        boolean b = (B == 1 && E == 3) || (B == 2 && E == 4) || (B == 3 && E == 1) || (B == 4 && E == 2);
        if (!b) return false;
        boolean c = (C == 1 && (F != C && B != C && D != C)) || (C == 2 && (C != F && B != F && D != F)) || (C == 3 && (F != B && C != B && D != B)) || (C == 4 && (F != D && B != D && C != D));
        if (!c) return false;
        boolean d = (D == 1 && (A == E)) || (D == 2 && (B == G)) || (D == 3 && (A == I)) || (D == 4 && (F == J));
        if (!d) return false;
        boolean e = (E == 1 && E == H) || (E == 2 && E == D) || (E == 3 && E == I) || (E == 4 && E == G);
        if (!e) return false;
        boolean f = (F == 1 && (B == H && H == D)) || (F == 2 && (A == H && H == F)) || (F == 3 && (C == H && H == J)) || (F == 4 && (E == H && H == I));
        if (!f) return false;
        boolean h = (H == 1 && Math.abs(A - G) != 1) || (H == 2 && Math.abs(A - E) != 1) || (H == 3 && Math.abs(A - B) != 1) || (H == 4 && Math.abs(A - J) != 1);
        if (!h) return false;
        boolean i = A == F ? ((I == 1 && F != E) || (I == 2 && J != E) || (I == 3 && B != E) || (I == 4 && I != E)) : ((I == 1 && F == E) || (I == 2 && J == E) || (I == 3 && B == E) || (I == 4 && I == E));
        if (!i) return false;
        int max_min = max_min(x);
        boolean j = (J == 1 && max_min == 3) || (J == 2 && max_min == 2) || (J == 3 && max_min == 4) || (J == 4 && max_min == 1);
        if (!j) return false;
        Set<Integer> minAnswer = minAnswer(x);
        boolean g = (G == 1 && minAnswer.contains(3)) || (G == 2 && minAnswer.contains(2)) || (G == 3 && minAnswer.contains(1)) || (G == 4 && minAnswer.contains(4));
        if (!g) return false;
        return true;
    }

    private static void print(int... x) {
        Arrays.stream(x).mapToObj(an -> INDEX_MAP_ANSWER.get(an)).forEach(System.out::println);
    }

    private static int max_min(int... answers) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int answer : answers)
            map.put(answer, map.getOrDefault(answer, 0) + 1);
        Collection<Integer> values = map.values();
        Integer max = values.stream().max(Comparator.naturalOrder()).get();
        Integer min = map.keySet().size() != 4 ? 0 : values.stream().max(Comparator.reverseOrder()).get();
    //    Supplier<Stream<Object>> supplier = () -> Stream.of(map.values().toArray());
    //    Integer max = supplier.get().map(x ->(int)x).max(Comparator.naturalOrder()).get();
    //    Integer min = supplier.get().map(x ->(int)x).max(Comparator.reverseOrder()).get();
        return max - min;
    }

    private static Set<Integer> minAnswer(int... x) {
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer answer : x)
            map.put(answer, map.getOrDefault(answer, 0) + 1);
        Collection<Integer> values = map.values();
        Integer min = map.keySet().size() != 4 ? 0 : values.stream().max(Comparator.reverseOrder()).get();
        if (!values.contains(min)) {
            return INDEX_MAP_ANSWER.keySet().stream().filter(k -> !map.keySet().contains(k)).collect(Collectors.toSet());
        }
        return map.entrySet().stream().filter(e -> e.getValue() == min).map(e -> e.getKey()).collect(Collectors.toSet());
    }

}