프로그래머스 - 모의고사(Java)

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

프로그래머스

 

문제의 요구사항만 잘 파악한다면 어려운 문제는 아니다.

 

하지만 내가 푼 방식은 너무 원시적이라서 정답을 받고 다른 사람 코드도 분석해 봤다.

 

나는 문제에서 정답의 패턴을 분석했고 입력 배열의 인덱스에 따라서 그 자리에 와야하는 값과 비교하였다.

 

이러한 비교 함수를 각각의 답안지에 맞게 3개 만들어서 단순비교 후 결과를 반환 하였다.

 

<나의 정답 코드>

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
        int[] answer = {};
        int a1=answer1(answers);
        int a2=answer2(answers);
        int a3=answer3(answers);
        if(a1>a2 && a1>a3){
            answer = new int[1];
            answer[0]=1;
            return answer;
        }
        else if(a2>a1 && a2>a3){
            answer = new int[1];
            answer[0]=2;
            return answer;
        }
        else if(a3>a1 && a3>a2){
            answer = new int[1];
            answer[0]=3;
            return answer;
        }
        else if(a1==a2 && a1>a3){
            answer = new int[2];
            answer[0]=1;
            answer[1]=2;
            return answer;
        }
        else if(a2==a3 && a2>a1){
            answer = new int[2];
            answer[0]=2;
            answer[1]=3;
            return answer;
        }
        else if(a1==a3 && a1>a2){
            answer = new int[2];
            answer[0]=1;
            answer[1]=3;
            return answer;
        }
        else if(a1==a2 &&a2==a3){
            answer = new int[3];
            answer[0]=1;
            answer[1]=2;
            answer[2]=3;
            return answer;
        }
        return answer;
    }
    public int answer1(int[] answer){
        int size = answer.length;
        int count=0;
        int num=1;
        for(int i=0; i<size; i++){
            if(num==answer[i]){
                count++;
            }
            if(num==5){
                num=0;
            }
            num++;
        }
        return count;
    }
    public int answer2(int[] answer){
        int size=answer.length;
        int count=0;
        int num=1;
        for(int i=0; i<size; i++){
            if(i%2==0){
                if(answer[i]==2){
                    count++;
                }
            }
            else{
                if(num==2){
                    num+=1;
                }
                if(answer[i]==num){
                    count++;
                }
                if(num==5){
                    num=0;
                }
                num++;
            }
             
        }
        return count;
    }
    public int answer3(int[] answer){
        int size=answer.length;
        int num=0;
        int count=0;
        for(int i=0; i<size; i++){
            if(num==0 || num==1){
                if(answer[i]==3){
                    count++;
                }
                num++;
            }
            else if(num==2 || num==3){
                if(answer[i]==1){
                    count++;
                }
                num++;
            }
            else if(num==4 || num==5){
                if(answer[i]==2){
                    count++;
                }
                num++;
            }
              else if(num==6 || num==7){
                if(answer[i]==4){
                    count++;
                }
                num++;
            }
             else if(num==8 || num==9){
                if(answer[i]==5){
                    count++;
                }
                num++;
                 if(num==10){
                     num=0;
                 }
            }
        }
        return count;
    }
}

 

 

<다른사람 코드>

import java.util.ArrayList;
class Solution {
    public int[] solution(int[] answer) {
        int[] a = {1, 2, 3, 4, 5};
        int[] b = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] c = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        int[] score = new int[3];
        for(int i=0; i<answer.length; i++) {
            if(answer[i] == a[i%a.length]) {score[0]++;}
            if(answer[i] == b[i%b.length]) {score[1]++;}
            if(answer[i] == c[i%c.length]) {score[2]++;}
        }
        int maxScore = Math.max(score[0], Math.max(score[1], score[2]));
        ArrayList<Integer> list = new ArrayList<>();
        if(maxScore == score[0]) {list.add(1);}
        if(maxScore == score[1]) {list.add(2);}
        if(maxScore == score[2]) {list.add(3);}
        return list.stream().mapToInt(i->i.intValue()).toArray();
    }
}

 

이 코드는 답안지 패턴을 미리 배열로 선언해놔서 코드도 훨씬 간결하고, 알고리즘도 훨씬 간단하다.

 

또한 주어진 패턴의 크기보다 큰 answer배열을 받을때는

a[i%a.length]

이러한 방식으로 인덱스가 넘어갈때를 처리 할 수 있다는 것도 새롭게 알게 되었다.

 

그리고 정답 출력도 ArrayList를 이용하면 배열 크기에 맞게 다시 answer배열을 선언할 필요도 없어서 이러한 방법을 나중에 나도 사용해야 겠다고 생각했다.

 int maxScore = Math.max(score[0], Math.max(score[1], score[2]));
        ArrayList<Integer> list = new ArrayList<>();
        if(maxScore == score[0]) {list.add(1);}
        if(maxScore == score[1]) {list.add(2);}
        if(maxScore == score[2]) {list.add(3);}

 

 

---

 

2025년 03월 18일 풀이

 

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
        int[] x = {1,2,3,4,5};
        int[] y = {2,1,2,3,2,4,2,5};
        int[] z = {3,3,1,1,2,2,4,4,5,5};
        
        int x_answer = 0;
        int y_answer = 0;
        int z_answer = 0;
        
        int position_x=0;
        int posx=0;
        while(true){
            if(answers[position_x]==x[posx]){
                x_answer++;
            }
            position_x+=1;
            posx+=1;
            
            if(position_x==answers.length){
                break;
            }
            if(posx==x.length){
                posx=0;
            }          
        }
        
        int position_y=0;
        int posy=0;
        while(true){
            if(answers[position_y]==y[posy]){
                y_answer++;
            }
            position_y+=1;
            posy+=1;
            
            if(position_y==answers.length){
                break;
            }
            if(posy==y.length){
                posy=0;
            }          
        }
        
        int position_z=0;
        int posz=0;
        while(true){
            if(answers[position_z]==z[posz]){
                z_answer++;
            }
            position_z+=1;
            posz+=1;
            
            if(position_z==answers.length){
                break;
            }
            if(posz==z.length){
                posz=0;
            }          
        }
        
        int max = Math.max(x_answer,Math.max(y_answer,z_answer));
        
        Queue<Integer> queue = new LinkedList<>();
        
        if(max==x_answer){
            queue.add(1);
        }
        if(max==y_answer){
            queue.add(2);
        }
        if(max==z_answer){
            queue.add(3);
        }
        
        int[] answer = new int[queue.size()];
        int n=0;
        while(!queue.isEmpty()){
           answer[n]=queue.poll();
            n++;
        }
        return answer;
    }
}

 

 

처음 풀었을때 보단 코드가 많이 간결해진 것 같다.