18. 모의고사

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

 

파이썬

def solution(answers):
    
    a1 = (1, 2, 3, 4, 5)  # 리스트보다 튜플이 더 좋다. 큰 의미는 없지만
    a2 = (2, 1, 2, 3, 2, 4, 2, 5)
    a3 = (3, 3, 1, 1, 2, 2, 4, 4, 5, 5)
    
    scores = [0, 0, 0]
    
    for i, v in enumerate(answers):
        if v == a1[i % 5]:
            scores[0] += 1
        if v == a2[i % 8]:
            scores[1] += 1
        if v == a3[i % 10]:
            scores[2] += 1
    
    mx = max(scores)
    
    return [i + 1 for i in range(3) if scores[i] == mx]
    
"""
정확성  테스트
테스트 1 〉	통과 (0.05ms, 10.7MB)
테스트 2 〉	통과 (0.04ms, 10.7MB)
테스트 3 〉	통과 (0.04ms, 10.8MB)
테스트 4 〉	통과 (0.04ms, 10.7MB)
테스트 5 〉	통과 (0.06ms, 10.8MB)
테스트 6 〉	통과 (0.06ms, 10.7MB)
테스트 7 〉	통과 (1.19ms, 11.2MB)
테스트 8 〉	통과 (0.41ms, 10.8MB)
테스트 9 〉	통과 (2.13ms, 13.7MB)
테스트 10 〉	통과 (1.05ms, 11.2MB)
테스트 11 〉	통과 (2.29ms, 14MB)
테스트 12 〉	통과 (2.06ms, 13.3MB)
테스트 13 〉	통과 (0.16ms, 10.8MB)
테스트 14 〉	통과 (2.28ms, 14.4MB)
"""

물론 더 줄일 수도 있지만, (% len2 부분의 반복 때문일까요?) 속도가 최대 2배 이상 느려집니다. 

def solution(answers):
    ans = ((1, 2, 3, 4, 5), (2, 1, 2, 3, 2, 4, 2, 5), (3, 3, 1, 1, 2, 2, 4, 4, 5, 5))
    scores = [0, 0, 0]
    for i, v1 in enumerate(answers):
        for j, v2 in enumerate(ans):
            if v1 == v2[i % len(v2)]:
                scores[j] += 1
    mx = max(scores)
    return [i + 1 for i in range(3) if scores[i] == mx]


"""
정확성  테스트
테스트 1 〉	통과 (0.05ms, 10.7MB)
테스트 2 〉	통과 (0.04ms, 10.8MB)
테스트 3 〉	통과 (0.05ms, 10.8MB)
테스트 4 〉	통과 (0.04ms, 10.7MB)
테스트 5 〉	통과 (0.07ms, 10.7MB)
테스트 6 〉	통과 (0.08ms, 10.9MB)
테스트 7 〉	통과 (2.74ms, 11.1MB)
테스트 8 〉	통과 (0.95ms, 10.9MB)
테스트 9 〉	통과 (5.09ms, 13.7MB)
테스트 10 〉	통과 (2.38ms, 11MB)
테스트 11 〉	통과 (5.34ms, 14MB)
테스트 12 〉	통과 (4.66ms, 13.3MB)
테스트 13 〉	통과 (0.34ms, 10.8MB)
테스트 14 〉	통과 (5.54ms, 14.4MB)
"""

itertools.cycle 을 이용하면
위 코드의 지저분한 부분들이 정리됩니다만, 
속도 향상은 크지 않습니다. 

def solution(answers):
    from itertools import cycle
    ans = (cycle((1, 2, 3, 4, 5)), cycle((2, 1, 2, 3, 2, 4, 2, 5)), cycle((3, 3, 1, 1, 2, 2, 4, 4, 5, 5)))
    scores = [0, 0, 0]
    for v1 in answers:
        for i, v2 in enumerate(ans):
            if v1 == next(v2):
                scores[i] += 1
    mx = max(scores)
    return [i + 1 for i in range(3) if scores[i] == mx]

테스트 1 〉	통과 (0.05ms, 10.7MB)
테스트 2 〉	통과 (0.04ms, 10.8MB)
테스트 3 〉	통과 (0.04ms, 10.8MB)
테스트 4 〉	통과 (0.04ms, 10.7MB)
테스트 5 〉	통과 (0.07ms, 10.7MB)
테스트 6 〉	통과 (0.07ms, 10.7MB)
테스트 7 〉	통과 (2.23ms, 11.1MB)
테스트 8 〉	통과 (0.75ms, 10.9MB)
테스트 9 〉	통과 (4.11ms, 13.7MB)
테스트 10 〉	통과 (1.83ms, 11MB)
테스트 11 〉	통과 (4.24ms, 14.1MB)
테스트 12 〉	통과 (3.71ms, 13.3MB)
테스트 13 〉	통과 (0.28ms, 10.8MB)
테스트 14 〉	통과 (4.25ms, 14.4MB)

생각난 김에...

def solution(answers):
    from itertools import cycle
    a1 = cycle((1, 2, 3, 4, 5))
    a2 = cycle((2, 1, 2, 3, 2, 4, 2, 5))
    a3 = cycle((3, 3, 1, 1, 2, 2, 4, 4, 5, 5))

    scores = [0, 0, 0]

    for i, v in enumerate(answers):
        if v == next(a1):
            scores[0] += 1
        if v == next(a2):
            scores[1] += 1
        if v == next(a3):
            scores[2] += 1

    mx = max(scores)

    return [i + 1 for i in range(3) if scores[i] == mx]

테스트 1 〉	통과 (0.05ms, 10.8MB)
테스트 2 〉	통과 (0.04ms, 10.9MB)
테스트 3 〉	통과 (0.04ms, 10.8MB)
테스트 4 〉	통과 (0.04ms, 10.8MB)
테스트 5 〉	통과 (0.06ms, 10.8MB)
테스트 6 〉	통과 (0.06ms, 10.8MB)
테스트 7 〉	통과 (1.28ms, 11MB)
테스트 8 〉	통과 (0.44ms, 11MB)
테스트 9 〉	통과 (2.44ms, 13.7MB)
테스트 10 〉	통과 (1.17ms, 11MB)
테스트 11 〉	통과 (2.39ms, 14MB)
테스트 12 〉	통과 (2.20ms, 13.3MB)
테스트 13 〉	통과 (0.18ms, 10.8MB)
테스트 14 〉	통과 (2.58ms, 14.5MB)

이 상황에선 % 연산이 cycle 보다 빠르군요. 조금 의외...

자바스크립트

function solution(answers) {
    
    const a1 = [1, 2, 3, 4, 5]
    const a2 = [2, 1, 2, 3, 2, 4, 2, 5]
    const a3 = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]
    
    let scores = [0, 0, 0]
    
    for (var i = 0; i < answers.length; i++) {
        if (answers[i] == a1[i % a1.length]) scores[0]++;
        if (answers[i] == a2[i % a2.length]) scores[1]++;
        if (answers[i] == a3[i % a3.length]) scores[2]++;
    }
    
    let max = Math.max(...scores);
    
    let answer = []
    
    for (let i=0; i<scores.length; i++) {
        if (scores[i] == max) answer.push(i+1);
	}
    
    return answer
}

자바

import java.util.*;

class Solution {
    public int[] solution(int[] answers) {
        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[] scores = new int[3];
        
        for (int i = 0; i < answers.length; i++) {
            if (answers[i] == first[i % 5]) scores[0]++;
            if (answers[i] == second[i % 8]) scores[1]++;
            if (answers[i] == third[i % 10]) scores[2]++;
        }
        
        int max = Math.max(scores[0], Math.max(scores[1], scores[2]));
        
        ArrayList<Integer> answer = new ArrayList<>();
        
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] == max) answer.add(i + 1);
        }
        
        return answer.stream().mapToInt(i -> i).toArray();
    }
}

고

func solution(answers []int) (ret []int) {
    pattern1 := []int{1, 2, 3, 4, 5}
    pattern2 := []int{2, 1, 2, 3, 2, 4, 2, 5}
    pattern3 := []int{3, 3, 1, 1, 2, 2, 4, 4, 5, 5}
    scores := [3]int{0, 0, 0}
    for i := 0; i < len(answers); i++ {
        if answers[i] == pattern1[i%5] {
            scores[0]++
        }
        if answers[i] == pattern2[i%8] {
            scores[1]++
        }
        if answers[i] == pattern3[i%10] {
            scores[2]++
        }
    }
    max := 0
    for _, v := range scores {
        if v > max {
            max = v
        }
    }
    for i, v := range scores {
        if v == max {
            ret = append(ret, i+1)
        }
    }
    return
}

코틀린

class Solution {
    fun solution(answers: IntArray): IntArray {
        val answer1 = intArrayOf(1, 2, 3, 4, 5)
        val answer2 = intArrayOf(2, 1, 2, 3, 2, 4, 2, 5)
        val answer3 = intArrayOf(3, 3, 1, 1, 2, 2, 4, 4, 5, 5)
        var check = intArrayOf(0, 0, 0)
        for (i in answers.indices) {
            if (answers[i] == answer1[i % 5]) check[0]++
            if (answers[i] == answer2[i % 8]) check[1]++
            if (answers[i] == answer3[i % 10]) check[2]++
        }
        val maxNum = maxOf(check[0], check[1], check[2])
        var lists = mutableListOf<Int>()
        for (i in check.indices) {
            if (check[i] == maxNum) lists.add(i + 1)
        }
        return lists.toIntArray()
    }
}

C#

using System.Collections.Generic;
using System.Linq;

public class Solution
{
    public int[] solution(int[] answers)
    {
        int[] answer = new int[3];
        int[] sp1 = { 1, 2, 3, 4, 5 };
        int[] sp2 = { 2, 1, 2, 3, 2, 4, 2, 5 };
        int[] sp3 = { 3, 3, 1, 1, 2, 2, 4, 4, 5, 5 };
        for (int i = 0; i < answers.Length; i++)
        {
            if (answers[i] == sp1[i % sp1.Length])
                answer[0]++;
            if (answers[i] == sp2[i % sp2.Length])
                answer[1]++;
            if (answers[i] == sp3[i % sp3.Length])
                answer[2]++;
        }
        int mx = answer.Max();
        List<int> result = new List<int> { };
        for (int i = 0; i < answer.Length; i++)
            if (answer[i] == mx)
                result.Add(i + 1);
        return result.ToArray();
    }
}