프로그래머스 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 함수를 작성해 주세요.

 

answers : 

1. 입력 : 1,2,3,4,5

2. 입력 : 1,3,2,4,2

 

문제를 전체를 읽어봤는데 진짜 어떻게 풀어야 되지?라고 생각을 했다.

일단 찍는 방식에 대해 알아야겠다고 판단했다.

가만히 숫자를 보고 있으니까 패턴이 보이기 시작했다.

 

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의 답과 비교를 해서

많이 맞춘 수포자를 리턴해주면 된다고 나와있다.

 

읽어보고 생각한 게 수포자들이 맞힌 갯수를 받고 그 갯수들을 비교해서 정답을 많이 맞춘 

수포자가 1명 있으면 그 1명을 리턴해주고 2명이면 2명 3명이면 3명을 리턴해주면 된다고 생각했다.

 

그래서 맨 처음 코드를 작성한 게 int타입의 변수를 3개를 만들고 거기에 각각 수포자들의 맞춘 개수를 넣어줬다.

그랬더니 코드가 굉장히 길어졌고, 입력이 많아지면 변수도 많아져서 효율적이지 않다고 생각했다.

배열을 쓰면 코드도 짧아지고, 변수도 따로 만들어주지 않아도 된다.

 

맞춘 갯수를 배열로 만들어서 각각 자리에 수포자들의 맞춘 갯수를 넣어준다.

반복문을 통해서 answers의 [0] 자리와 a의 [ i % a.length] (각자 배열의 길이로 나머지로 인덱스로 쓴 이유는 저렇게 안 쓰고 i만을 써서 실행을 시켜보니 배열의 인덱스를 벗어났다는 오류를 발생해서 i % 수포자. length; 를 사용했다

// 0~4까지 나온다 ) 자리를 비교해서 같으면 cnt 배열의 각 자리에 1씩 추가한다. 

// 블로그를 쓰다가 중간에 더 짧게 할 수 있지 않을까라는 생각이 들어 코드를 2차 배열을 사용하여 다시 작성했다 

// 반복문도 똑같이 생각이 들어 2중 반복문으로 고쳤다.

// 고치기 전에 코드는 주석을 달아놨다.

 

수포자 2, 3을 없애고 수포자 1을 2차 배열로 생성하고 거기에 2,3의 값을 넣어줬다.

이중 반복문을 사용하여 answer [0]을 a [0~2][0]을 비교해서 같으면 cnt [0] 자리에 1씩 더 해준다.

이걸 a.length 만큼 반복한다.

 

인덱스를 나머지로 사용한 이유는 런타임 에러가 뜨기 때문이다. 

왜 런타임 에러가 뜨는지 몰라서 이건 AI에게 물어보았다 그랬더니 이렇게 답을 해왔다.

사용자의 코드에서 문제가 되는 부분은 각 수포자가 답안을 순환하며 맞추는 방식을 처리할 때 발생합니다. 각 수포자의 답안 패턴을 순환시키려면 `a [j][i]` 대신 `a[j][i % a [j]. length]`를 사용해야 합니다. 이는 각 수히자의 답안 길이에 따라 인덱스를 모듈러 연산하여 순환시키는 로직입니다. 기존 코드에서는 답안 길이를 고려하지 않고 단순히 `i`만 사용했기 때문에, 답안 배열의 길이를 초과했을 때 올바른 비교를 할 수 없었습니다. 따라서 각 수포자가 찍는 방식을 올바르게 순환시키기 위해서는 모듈러 연산을 적절히 활용해야 합니다. 이렇게 하면 주어진 답안 배열에 대해 모든 수포자의 패턴을 정확하게 순환시켜 가며 맞춘 문제의 수를 카운트할 수 있습니다.

 

맞춘 개수를 구한 뒤 거기서 제일 많이 맞춘 갯수를 구한다. 

최고 갯수를 구하려고 처음엔 반복문을 사용해서 값을 구했는데. 이것 또한 코드가 길어져서 반복문을 안 쓰고 

구하는 방법이 없을까 생각해서 구글링을 해본 결과 Math.max라는 게 있다는 걸 알았다. 

이것이 무엇이냐면 Math.max(num1, num2) 이렇게 사용을 하는데 num1과 num2를 비교해서 둘 중 큰 값을 반환한다.

이것을 사용해서 먼저 cnt [1]와 cnt [2]를 비교해서 큰 값을 구하고 거기서 나온 값을

cnt [0]과 비교해서 큰 값을 max에 저장한다.

 

배열을 사용하다 보니 일반 배열을 사용하는 것보다  ArrayList, List를 사용하는 것이 더 낫다고 생각했다.

왜 그렇게 생각을 했냐고 물어본다면 배열은 길이를 지정을 해줘야 하는데 ArrayList, List는 안 써줘도 되고

그 상태 그대로 배열로 바꾸어 사용할 수 있기 때문에 사용을 하였다.

이걸 사용해서 arr이라는 List 변수를 만들어주었고 반복문을 사용해서 max랑 cnt [i]가 같으면

arr.add로 cnt 각 자리에 i + 1을 추가해 준다.

 

이제 마지막 리턴이 남았다. 리턴은 arr에 들어간 값을 배열로 만들어 리턴을 해줬다.

arr.stream() 이건 arr을 stream으로 바꾸어주고 ( Java의 Stream을 이용하면 일련의 데이터를 함수형 연산을 통해 표준화된 방법으로 쉽게 가공, 처리할 수 있다. stream을 사용하게 되면 그 뒤에 람다식을 사용을 할 수 있게 되어 코드가 간결해진다. )

mapToInt(i -> i) 

 람다식을 사용한다 ( i 이거 매개변수 -> i 이거는 반환할 값, 즉 arr의 값을 그대로 사용) 

toArray를 통해 배열로 만들어 리턴한다.

import java.util.ArrayList;
import java.util.List;

class Solution {
    public int[] solution(int[] answers) {
        int[][] a = {{1,2,3,4,5,},
                     {2,1,2,3,2,4,2,5},
                     {3,3,1,1,2,2,4,4,5,5}
                    };
                    
                    
      // 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[] cnt = new int[3];
        
        
        for(int i = 0; i < answers.length; i++){
            for(int j = 0; j < cnt.length; j++){
                if(answers[i] == a[j][i % a[j].length]){
                    cnt[j]++;
                }
            }
        }
                                                                            
        
        // for(int i = 0; i < answers.length; i++){
        //     if(answers[i] == a[i % a.length]){
        //         cnt[0]++;
        //     }
        //     if(answers[i] == b[i % b.length]){
        //         cnt[1]++;
        //     }
        //     if(answers[i] == c[i % c.length]){
        //         cnt[2]++;
        //     }
        // }
        int max = Math.max(cnt[0], (Math.max(cnt[1], cnt[2])));
        
        List<Integer> arr = new ArrayList<>();
        
        for(int i = 0; i < cnt.length; i++){
            if(max == cnt[i]){
                arr.add(i + 1);
            }
        }
        
//         if(max == cnt[0]){
//             arr.add(1);
//         }
        
//         if(max == cnt[1]){
//             arr.add(2);
//         }
        
//         if(max == cnt[2]){
//             arr.add(3);
//         }
    
        return arr.stream().mapToInt(i->i).toArray();
    }
}