프로그래머스 Lv.1 (2)

21.12.16

모의고사

초기 코드

class Solution {
    public int[] solution(int[] answers) {
        int[] answer = {};
    	return answer;
    }
}

헤맸던 지점

1. 각 수포자의 점수를 어떻게 매치해서 1,2,3으로 표시할지 (--> 혼자 다시 풀어봐야할 지점)
2. 동일한 값에 대한 오름차순 처리는 어떻게 하지?
3. 수포자 3명의 답안지를 for문 3개로 일일이 뽑아보는 게 맞을까?

내가 작성한 코드

class Solution {
    public int[] solution(int[] answers) {
        int[] answer = {};
        /*#answers.length가 곧 비교횟수
        #각 수포자의 반복 패턴을 정리, 그 패턴과 정답 배열의 아이템을 순서대로 비교
        #각 수포자의 정답개수를 카운트하는 변수 필요
        #세 개의 변수 중 가장 큰 값을 리턴-Math.max 뭐 그런 거 있었는데 
        #동일하면 수포자 번호를 오름차순으로 표시*/
        int[] first, second, third;
        first = second = third = new int[answers.length];
        int sc1, sc2, sc3;
        sc1 = sc2 = sc3 = 0;
        /*수포자1 답안지*/
        for (int i = 0; i < answers.length; i++) {
            if ( (i+1) % 5 == 0 ) {
                first[i] =  5;
            }
            else {
                first[i] = (i+1) % 5;
            }
        }
        /*수포자 2 답안지*/
        for (int j = 0; j < answers.length; j++) {
            if ((j+1) % 2 == 1) {
                second[j] = 2;
            }
            else {
                second[j] = j % 5;
            } // 심지어 답안지 패턴 틀렸음ㅎㅎ
        }
        /*수포자 3 답안지*/
        for (int k = 0; k < answers.length; k++) {
            if ((k % 10 == 0) || (k % 10 == 1)) {
                third[k] = 3;
            }
            if ((k % 10 == 2) || (k % 10 == 3)) {
                third[k] = 1;
            }
            if ((k % 10 == 4) || (k % 10 == 5)) {
                third[k] = 2;
            }
            if ((k % 10 == 6) || (k % 10 == 7)) {
                third[k] = 4;
            }
            if ((k % 10 == 8) || (k % 10 == 9)) {
                third[k] = 5;
            }
        }
        /*정답이랑 세 명 답안지랑 비교*/
        for (int v = 0; v < answers.length; v++) {
            if (answers[v] == first[v]) {
                sc1++;
            }
            if (answers[v] == second[v]) {
                sc2++;
            }
            if (answers[v] == third[v]) {
                sc3++;
            }
        }
        int[] temp = {sc1, sc2, sc3};
        temp = Arrays.sort(temp);
        // 여기 해결해야함//
        return answer;    
        
    }
}

정답 코드1

import java.util.ArrayList;
class Solution {
    public int[] solution(int[] answers) {
        int[] answer = {};
        // 기존의 패턴이 일정 주기마다 반복되는 점을 활용하면 코드 양을줄일수 있었음
        int[] first= {1, 2, 3, 4, 5};
        int[] second = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] third = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        
        int[] score = {0,0,0};
        
        for (int i = 0; i < answers.length; i++){
            if (answers[i] == first[i % first.length] ) {
                score[0]++;
            }
            if (answers[i] == second[i % second.length]) {
                score[1]++;
            }
            if (answers[i] == third[i % third.length]) {
                score[2]++;
            }
        }
        //최댓값은 이렇게 단순하게 찾아가도 됨. 
        //Math.max 함수는 두 인자만 넣을수 있으니 이중으로 사용하는 방법도 있음!
        int max = 0;
        for (int i = 0; i < 3; i++) {
            if (score[i] > max) {
                max = score[i];
            }
        }
        // 값을 차곡차곡 넣는 add를 쓸 수 있는 ArrayList를 활용.
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < 3; i++) {
            if (score[i] == max ) {
                list.add(i+1);
            }
            
        }
        answer = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            answer[i] = list.get(i);
        }
        
        return answer;
    }
}

멋지다고 생각했던 정답코드2

import java.util.*;

class Solution {
    public static int[] solution(int[] answers) {
        //2차원 배열을 쓸 생각은 안 해봤는데 이런 방법도 있더라.
        int[][] patterns = {
                {1, 2, 3, 4, 5},
                {2, 1, 2, 3, 2, 4, 2, 5},
                {3, 3, 1, 1, 2, 2, 4, 4, 5, 5}
        };

        int[] hit = new int[3];
        for(int i = 0; i < hit.length; i++) {
            for(int j = 0; j < answers.length; j++) {
                if(patterns[i][j % patterns[i].length] == answers[j]) hit[i]++;
            }
        }

        // Math.max를 이중으로 사용해서 최댓값을 구했음.
        int max = Math.max(hit[0], Math.max(hit[1], hit[2]));
        
        List<Integer> list = new ArrayList<>();
        for(int i = 0; i < hit.length; i++)
            if(max == hit[i]) list.add(i + 1);

        int[] answer = new int[list.size()];
        int cnt = 0;
        for(int num : list)
            answer[cnt++] = num;
        return answer;
    }
}

ArrayList 생성해서 사용하는 법은 거의 잊고 있어서 각 수포자의 점수를 각 번호에 맞게 매치하는 데 더 어려움을 겪었던 것 같다. 그리고 무작정 sort를 써서 최대값을 찾으려고 했던 게 맹점이었던 듯. 차라리 if문으로 비교해서 최대값을 단순하게 찾아볼 생각은 못해서 아쉽다.
그리고 비교해봐야할 패턴이 딱 3개 뿐이었으니, 정답코드처럼 아예 배열에 넣어두고 규칙보다는 '반복주기'를 보려고 했으면 더 효율적으로 짤 수 있었을 텐데!