프로그래머스 - 모의고사 <Lavel 1> 완전 탐색(java)

문제 설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ... 2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ... 3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

 

제한 조건

• 시험은 최대 10,000 문제로 구성되어있습니다.
• 문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
• 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

 

문제 해석

1번 = 1, 2, 3, 4, 5

2번 = 2, 1, 2, 3, 2, 4, 2, 5

3번 = 3, 3, 1, 1, 2, 2, 4, 4, 5, 5

의 순서로 정답을 찾는다.

answers에 들어온 값<정답>과 수포자가 찍는 룰에 따라 몇 개 맞았는지 확인하고

정렬 후 배열에 수포자의 index를 담아 return 한다.

 

첫 코드

public int[] solution(int[] answers) { 
	int[][] spj = {{1,2,3,4,5}, {2,1,2,3,2,4,2,5}, 		{3,3,1,1,2,2,4,4,5,5}};

    Map<String, Integer> list = new HashMap<>();
    list.put("1", 0);
    list.put("2", 0);
    list.put("3", 0);

    int i = 0;
    int j = 0;

    while (i < answers.length){
        for (int answer1 : answers) {
            if(answer1 == spj[0][j]) {
                list.put("1", list.get("1")+1);
                if(j >= spj[0].length ) {
                    j = 0;
                }
            }

            if(answer1 == spj[0][j]) {
                list.put("2", list.get("1")+1);
                if(j >= spj[1].length ) {
                    j = 0;
                }
            }

            if(answer1 == spj[0][j]) {
                list.put("3", list.get("1")+1);
                if(j >= spj[2].length ) {
                    j = 0;
                }
            }
            i++;
        }
    }

    Integer[] test = {list.get("1"), list.get("2"), list.get("3")};

    Arrays.sort(test, Collections.reverseOrder());
    int[] answer = {3};
    for (int k = 1; k <= list.size(); k++) {
        i = 0;
        j = 1;

        if(list.get(String.valueOf(k)) == test[0]) {
            answer[i] = j;
        }
        i++;
        j++;
    }

    for (int i1 : answer) {
        System.out.println(i1);
    }

    return answer;
}

 

참고한 답

https://developerdk.tistory.com/29

        int[] arr1 = {1,2,3,4,5};
        int[] arr2 = {2,1,2,3,2,4,2,5};
        int[] arr3 = {3,3,1,1,2,2,4,4,5,5};

        HashMap<Integer, Integer> hm = new HashMap<>();
        hm.put(1, 0);
        hm.put(2, 0);
        hm.put(3, 0);

        //정답 개수 Count
        //나랑 다른 점 i와 j라는 변수 대신 배열의 사이즈를 나눠서 찾음.
        for (int i = 0; i < answers.length; i++) {
            int num = answers[i];
            if(arr1[i%5] == num) {
                hm.replace(1, hm.get(1)+1);
            }

            if(arr2[i%8] == num) {
                hm.replace(2, hm.get(2)+1);
            }

            if(arr3[i%10] == num) {
                hm.replace(3, hm.get(3)+1);
            }
        }

        //최댓값 구하기
        //나랑 다른 점
        //sort를 사용했는데 그러지 않고 하나씩 값을 비교
        //하나하나 하다 보면 결국 제일 큰 값이 남음.
        int max = hm.get(1);
        for (Integer value : hm.values()) {
            if(value > max) {
                max = value;
            }
        }

        //정답 리스트 형성
        //이 부분에서 다른 점은 나는 배열에 넣으려 한 점
        ArrayList<Integer> answerList = new ArrayList<>();
        for (Integer key : hm.keySet()) {
            if(hm.get(key) == max) {
                answerList.add(key);
            }
        }

        //정렬 및 배열로 변환
        int[] answer = new int[answerList.size()];
        Collections.sort(answerList);

        for (int i = 0; i < answer.length; i++) {
            answer[i] = answerList.get(i);
        }
        return answer;

 

복습 코드

    public int[] solution(int[] answers) {
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] arr3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};

        Map<Integer, Integer> maxList = new HashMap<>();

        maxList.put(0,0);
        maxList.put(1,0);
        maxList.put(2,0);

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

            if(answers[i] == arr1[i % arr1.length]) {
                maxList.replace(0, maxList.get(0)+1);
            }

            if(answers[i] == arr2[i % arr2.length]) {
                maxList.replace(1, maxList.get(1)+1);
            }

            if(answers[i] == arr3[i % arr3.length]) {
                maxList.replace(2, maxList.get(2)+1);
            }

        }

        for (Integer value : maxList.values()) {
            System.out.println(value);
        }

        int max = maxList.get(0);

        if(maxList.get(1) < maxList.get(2)) {

            if(max < maxList.get(2)) {
                max = maxList.get(2);
            }
        } else {
            if(max < maxList.get(1)) {
                max = maxList.get(1);
            }
        }

        List<Integer> answer = new ArrayList<>();
        for (int i = 0; i < maxList.size(); i++) {
            if(max == maxList.get(i)) {
                answer.add(i+1);
            }
        }
        return answer.stream().filter(i -> i != null).mapToInt(i -> i).toArray();
    }

 

회고

숫자에 약한 내가 제일 고민했던 부분은 정답의 index와 수포자의 index의 값이 동시에 올라가야 하는 부분이었다.

이 부분에서 복습 당시 10분 정도의 시간이 추가로 더 들었다.

더 질질 끌어서 득 될 것 없다는 생각이 들어 앞에 참고했던 코드를 통해 %로 찾아내는 것을 확인했고, 종이에 계산하며 익힌 결과를 통해 이해할 수 있었다.

살면서 숫자와 담쌓고 살았던 만큼 알고리즘이 쉽게 다가오지 않지만 호눅스께서 1,000문제 이상 풀어보고 재능 없다는 말씀을 하신 것처럼 꾸준히 풀어 경험에 의한 문제 풀이를 할 수 있을 정도로 열심히 해야겠다.

https://programmers.co.kr/learn/courses/30/lessons/42840