코딩테스트 준비 - 모의고사

다시푸는 코딩 테스트 준비 일지

• 응시 사이트 : Programmers

• 문제 : 모의고사

• 사용언어 : C#

• 난이도 : 하

• 풀이시간 : 27m 17s

• 유형 : 배열, 완전탐색

문제 설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 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하는 값을 오름차순 정렬해주세요.

입출력 예

answers return
[1,2,3,4,5] [1]
[1,3,2,4,2] [1,2,3]

입출력 예 설명

입출력 예 #1

• 수포자 1은 모든 문제를 맞혔습니다.

• 수포자 2는 모든 문제를 틀렸습니다.

• 수포자 3은 모든 문제를 틀렸습니다.

따라서 가장 문제를 많이 맞힌 사람은 수포자 1입니다.

입출력 예 #2

• 모든 사람이 2문제씩을 맞췄습니다.

문제 풀이 접근

이 문제는, 각 사람마다의 패턴을 배열로 저장해서, 인덱스가 넘어가게되면 각자의 배열 인덱스를 0으로 돌려서 차례로 순회하면서 정답인지 오답인지 판단해서 갯수를 정하는 문제다.

맞은 갯수가 여럿인 경우, 인덱스 기준으로 정렬해서 반환한다.

이 문제의 플로우는,
1. 각 사람의 패턴을 배열에 저장한다.
2. 각 사람의 인덱스를 배열로 따로 저장한다.
3. 맞은 갯수를 클래스를 작성해서 Key Value 형식으로 만들어서 저장한다.
4. 맞은 갯수를 기준으로 오름차순으로 정렬한다.
5. 복수 최고 득점자가 있을때는 인덱스를 기준으로 정렬한다.

정답 작성 코드 (C#)

using System;

    public class point
    {
        public int index;
        public int score;

        public point(int index, int score)
        {
            this.index = index;
            this.score = score;
        }
    }

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

            int[] fst = new int[5] { 1, 2, 3, 4, 5 };
            int[] snd = new int[8] { 2, 1, 2, 3, 2, 4, 2, 5 };
            int[] thd = new int[10] { 3, 3, 1, 1, 2, 2, 4, 4, 5, 5 };

            point[] passCount = new point[3];
            passCount[0] = new point(1,0);
            passCount[1] = new point(2,0);
            passCount[2] = new point(3,0);

            int[] idx = new int[3] { 0, 0, 0 };

            for (int i = 0; i < answers.Length; ++i)
            {
                if (fst[idx[0]] == answers[i])
                    ++passCount[0].score;

                if (snd[idx[1]] == answers[i])
                    ++passCount[1].score;

                if (thd[idx[2]] == answers[i])
                    ++passCount[2].score;

                for (int j = 0; j < idx.Length; ++j)
                {
                    ++idx[j];

                    if (j == 0 && fst.Length <= idx[j])
                    {
                        idx[j] = 0;
                    }

                    if (j == 1 && snd.Length <= idx[j])
                    {
                        idx[j] = 0;
                    }

                    if (j == 2 && thd.Length <= idx[j])
                    {
                        idx[j] = 0;
                    }
                }
            }

            Array.Sort(passCount, (point a, point b) => { return a.score.CompareTo(b.score); });

            int retScore = passCount[passCount.Length-1].score;
            point[] retPt = Array.FindAll(passCount, rhs => rhs.score == retScore);
            
            Array.Sort(retPt, (point a, point b) => { return a.index.CompareTo(b.index); });

            answer = new int[retPt.Length];
            for (int i = 0; i < retPt.Length; ++i)
            {
                answer[i] = retPt[i].index;
            }

            return answer;
        }
    }

코드 결과