[Programmers] trial examination.py (complete search)

#. Problem

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

* The copyright in this matter is in Programmers

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 

수포자는 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 함수를 작성해주세요.

#. Resolution Process

  1. Read and understand problem

  2. Redefine the problem + abstract

    - 수포자 1번 : 1, 2, 3, 4, 5 ...

    - 수포자 2번 : 2, 1, 2, 3, 2, 3, 2, 5 ...

    - 수포자 3번 : 3, 3, 1, 1, 2, 2, 4 ,4 ,5, 5 ,...

    - 가장 많은 문제를 맞힌 사람을 return,

      여럿일 경우, return하는 값을 오름차순으로 정렬

  3. Create solution plan (select Algorithm, Data structure)

  4. Prove the plan (check performance time and usage memory)

  5. Carry out the plan

  6. Look back on the plan and find a way to improve it

#. Solve

  1. lambda 함수를 사용한 리스트 비교를 통해 각 수포자가 몇 문제를 맞췄는지 result list에 저장 

  2. resut list와 index를 list에 담은 후 value 기준으로 정렬.

     정렬한 list를 pop으로 하나씩 빼면서 가장 많이 맞춘 수포자를 answer에 추가

     단, 여러명일 수 있으니 pop한 value를 저장하여 다음으로 많이 맞춘 수포자가 있는지 확인

  3. 여러명일 경우, answer을 오름차순으로 정렬하여 return

  1. answers의 요소를 하나씩 수포자들의 답과 확인하고 정답이면 +=

#. Code

def solution(answers):
    student = [[1,2,3,4,5],
               [2,1,2,3,2,3,2,5],
               [3,3,1,1,2,2,4,4,5,5]]
    correct_answers = []
    asw = []
    for std in student:
        if len(answers) > len(std):
            std = std*(len(answers)//len(std))
        res = list(map(lambda x, y: x == y, std, answers))
        correct_answers.append(res.count(True))
    student_data = list(zip(range(1,len(student)+1), correct_answers))
    student_data_sort = sorted(student_data, key=lambda a: a[1])
    max = student_data_sort[-1][1]
    while student_data_sort:
        temp = student_data_sort.pop()
        if max == temp[1]:
            asw.append(temp[0])
    return sorted(asw)

  - 순환하면서 답을 확인하면 되는데 궂이 반복문을 적게 사용하려고,

    한번에 다 확인하려다보니까 비효율적이고 부정확하고 더 복잡하게 꼬인 코드가 되어버렸다..

#. Others code

def solution(answers):
    pattern1 = [1,2,3,4,5]
    pattern2 = [2,1,2,3,2,4,2,5]
    pattern3 = [3,3,1,1,2,2,4,4,5,5]
    score = [0, 0, 0]
    result = []
 
    for idx, answer in enumerate(answers):
        if answer == pattern1[idx%len(pattern1)]:
            score[0] += 1
        if answer == pattern2[idx%len(pattern2)]:
            score[1] += 1
        if answer == pattern3[idx%len(pattern3)]:
            score[2] += 1
 
    for idx, s in enumerate(score):
        if s == max(score):
            result.append(idx+1)
 
    return result

  - 이렇게 단순하게 순환하면서 했어도 무관했는데.. 

    (8~14) answers 요소를 pattern들과 하나씩 확인하면서 일치할 경우 += 

             idx%len(pattern)을 해준 이유는 answers가 pattern보다 길 경우 pattern의 요소를 순환하기 위함임

    (16~18) score를 하나씩 확인하면서 max score와 같은 학생의 index를 저장

def solution(answers):
    p = [[1, 2, 3, 4, 5],
         [2, 1, 2, 3, 2, 4, 2, 5],
         [3, 3, 1, 1, 2, 2, 4, 4, 5, 5]]
    s = [0] * len(p)
 
    for q, a in enumerate(answers):
        for i, v in enumerate(p):
            if a == v[q % len(v)]:
                s[i] += 1
    return [i + 1 for i, v in enumerate(s) if v == max(s)]

   -  2중 반복문이 사용되었지만 위 코드보다 더 간결한 방법