프로그래머스 인사고과

순열, 조합, 중복순열 공부해서 써먹어보려고 했더니 안됨 ㅋㅋㅋ

• 실패 + 시간 초과의 혼합... 머리가 멈춤 ㅋ
• 다른 걸 써야되나? 더 속도 빠른건 없나? 찾아봄.
• https://juhee-maeng.tistory.com/91

• 아무것도 안먹어서 머리가 멍한걸까? 미세먼지 때문일까?
• 탈락자 배열 만들어서 점수끼리 비교하고, 탈락자에 총점 넣어서 비교했는데 시간 초과도 나오면서 정답도 아닌 걸로 나온다. 일단 시간 초과부터 없애볼까?

from itertools import combinations

def solution(scores):
    석차 = len(scores)
    탈락자 = [-99 for i in range(석차)]
    print(탈락자)
    
    for 점수 in combinations(range(len(scores)), 2): #탈락한 동료 -1점
        if 탈락자[점수[0]] != -1 and 탈락자[점수[1]] != -1:
            근무태도1, 동료점수1 = scores[점수[0]][0], scores[점수[0]][1]
            근무태도2, 동료점수2 = scores[점수[1]][0], scores[점수[1]][1]
            if 근무태도1 < 근무태도2 and 동료점수1 < 동료점수2:
                탈락자[점수[0]] = -1
                break
            else:
                탈락자[점수[0]] = 근무태도1 + 동료점수1
    
    for i in range(석차):
        if 탈락자[i] == -99:
            탈락자[i] = scores[i][0] + scores[i][1]
    
    print(탈락자)
    완호의총점 = 탈락자.pop(0)
    if 완호의총점 == -1:
        return 완호의총점
    
    석차 = 0
    for 총점 in 탈락자:
        if 완호의총점 < 총점:
            석차 += 1
        print(탈락자, 완호의총점, ">", 총점, 석차)
        
    return 석차 + 1
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.4MB)
테스트 2 〉	통과 (0.01ms, 10.5MB)
테스트 3 〉	통과 (0.01ms, 10.5MB)
테스트 4 〉	통과 (0.01ms, 10.5MB)
테스트 5 〉	통과 (0.02ms, 10.3MB)
테스트 6 〉	통과 (0.01ms, 10.4MB)
테스트 7 〉	통과 (0.02ms, 10.4MB)
테스트 8 〉	실패 (0.04ms, 10.6MB)
테스트 9 〉	통과 (0.04ms, 10.6MB)
테스트 10 〉	실패 (0.09ms, 10.4MB)
테스트 11 〉	실패 (0.28ms, 10.5MB)
테스트 12 〉	통과 (0.32ms, 10.4MB)
테스트 13 〉	통과 (0.43ms, 10.4MB)
테스트 14 〉	실패 (0.59ms, 10.6MB)
테스트 15 〉	통과 (1.77ms, 11.1MB)
테스트 16 〉	실패 (3.06ms, 11MB)
테스트 17 〉	통과 (5.96ms, 12MB)
테스트 18 〉	통과 (6.04ms, 12MB)
테스트 19 〉	통과 (12.82ms, 19.8MB)
테스트 20 〉	통과 (15.75ms, 19.7MB)
테스트 21 〉	실패 (시간 초과)
테스트 22 〉	실패 (61.33ms, 29.3MB)
테스트 23 〉	통과 (52.49ms, 29.5MB)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	실패 (시간 초과)

• 열심히 짱돌을 굴려보니, 어차피 총점이 높은 애들만 구하면되니까 총점이 낮은 애들이 탈락인지 아닌지 계산할 필요가 없었다. 총점이 높은 애들만 소팅해서 다시 해보자구...
• 통과는 되는데 시간 초과에서 걸리는구나... 한글 변수로 해서 그런가 ㅋ

from itertools import combinations

def solution(scores):
    완호의태도점수, 완호의평가점수 = scores.pop(0)
    완호의총점 = 완호의태도점수 + 완호의평가점수
    
    scores.sort(key=lambda x:x[0]+x[1]) #총점 순 정렬
    scores = [x for x in scores if x[0]+x[1] > 완호의총점] #완호의 총점보다 낮은 점수 제거
    len_scores = len(scores)
    answer = len_scores + 1
    
    #print(answer)
    for i in range(len_scores):
        태도점수1, 평가점수1 = scores[i][0], scores[i][1]
        #print("완호의태도점수, 완호의평가점수k, 태도점수1, 평가점수1:", 완호의태도점수, 완호의평가점수, 태도점수1, 평가점수1)
        if 완호의태도점수 < 태도점수1 and 완호의평가점수 < 평가점수1:
            return -1
        
        for j in range(i,len_scores):
            태도점수2, 평가점수2 = scores[j][0], scores[j][1]
            #print("태도점수1, 평가점수1, 태도점수2, 평가점수2:", 태도점수1, 평가점수1, 태도점수2, 평가점수2)
            if 태도점수1 < 태도점수2 and 평가점수1 < 평가점수2:
                #print("등수 오름")
                answer -= 1
                break
        
    return answer
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.3MB)
테스트 2 〉	통과 (0.01ms, 10.3MB)
테스트 3 〉	통과 (0.01ms, 10.3MB)
테스트 4 〉	통과 (0.01ms, 10.4MB)
테스트 5 〉	통과 (0.01ms, 10.3MB)
테스트 6 〉	통과 (0.01ms, 10.4MB)
테스트 7 〉	통과 (0.01ms, 10.3MB)
테스트 8 〉	통과 (0.02ms, 10.4MB)
테스트 9 〉	통과 (0.05ms, 10.6MB)
테스트 10 〉	통과 (0.04ms, 10.3MB)
테스트 11 〉	통과 (1.78ms, 10.3MB)
테스트 12 〉	통과 (0.25ms, 10.4MB)
테스트 13 〉	통과 (0.37ms, 10.3MB)
테스트 14 〉	통과 (0.51ms, 10.4MB)
테스트 15 〉	통과 (1.77ms, 10.8MB)
테스트 16 〉	통과 (5.97ms, 11MB)
테스트 17 〉	통과 (5.47ms, 11.8MB)
테스트 18 〉	통과 (3.59ms, 12.1MB)
테스트 19 〉	통과 (33.63ms, 19.7MB)
테스트 20 〉	통과 (22.31ms, 19.6MB)
테스트 21 〉	통과 (31.54ms, 19.3MB)
테스트 22 〉	통과 (527.02ms, 29.7MB)
테스트 23 〉	통과 (418.40ms, 29.4MB)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	실패 (시간 초과)

• 큰 값부터 거꾸로 비교하면 좀 더 빨라지지 않을까?
• 아니네.. 어떤 위치에 뭐가 있을지 모르니까 안되나?

from itertools import combinations

def solution(scores):
    완호의태도점수, 완호의평가점수 = scores.pop(0)
    완호의총점 = 완호의태도점수 + 완호의평가점수
    
    scores.sort(key=lambda x:x[0]+x[1]) #총점 순 정렬
    scores = [x for x in scores if x[0]+x[1] > 완호의총점] #완호의 총점보다 낮은 점수 제거
    len_scores = len(scores)
    answer = len_scores + 1
    
    #print(answer)
    for i in range(len_scores):
        태도점수1, 평가점수1 = scores[i][0], scores[i][1]
        #print("완호의태도점수, 완호의평가점수k, 태도점수1, 평가점수1:", 완호의태도점수, 완호의평가점수, 태도점수1, 평가점수1)
        if 완호의태도점수 < 태도점수1 and 완호의평가점수 < 평가점수1:
            return -1
        
        for j in reversed(range(i,len_scores)):
            태도점수2, 평가점수2 = scores[j][0], scores[j][1]
            #print("태도점수1, 평가점수1, 태도점수2, 평가점수2:", 태도점수1, 평가점수1, 태도점수2, 평가점수2)
            if 태도점수1 < 태도점수2 and 평가점수1 < 평가점수2:
                #print("등수 오름")
                answer -= 1
                break
        
    return answer
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.3MB)
테스트 2 〉	통과 (0.01ms, 10.4MB)
테스트 3 〉	통과 (0.02ms, 10.4MB)
테스트 4 〉	통과 (0.01ms, 10.3MB)
테스트 5 〉	통과 (0.01ms, 10.3MB)
테스트 6 〉	통과 (0.02ms, 10.3MB)
테스트 7 〉	통과 (0.02ms, 10.6MB)
테스트 8 〉	통과 (0.02ms, 10.4MB)
테스트 9 〉	통과 (0.06ms, 10.5MB)
테스트 10 〉	통과 (0.06ms, 10.4MB)
테스트 11 〉	통과 (0.60ms, 10.4MB)
테스트 12 〉	통과 (0.25ms, 10.6MB)
테스트 13 〉	통과 (0.25ms, 10.4MB)
테스트 14 〉	통과 (0.36ms, 10.4MB)
테스트 15 〉	통과 (1.59ms, 10.9MB)
테스트 16 〉	통과 (2.45ms, 11.3MB)
테스트 17 〉	통과 (5.93ms, 11.8MB)
테스트 18 〉	통과 (4.31ms, 12MB)
테스트 19 〉	통과 (30.54ms, 19.8MB)
테스트 20 〉	통과 (32.83ms, 19.7MB)
테스트 21 〉	통과 (20.23ms, 19.2MB)
테스트 22 〉	통과 (170.26ms, 29.8MB)
테스트 23 〉	통과 (96.49ms, 29.2MB)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	실패 (시간 초과)

• 함정 찾았네? 완호만 들어있는 배열을 주는구나?
• 근데 그러면 동료 평가 점수를 어떻게 받냐? 동료가 없는데? 쓰레기 함정이네 ㅋㅋㅋ
• 하지만 통과 못함...?

from itertools import combinations

def solution(scores):
    완호의태도점수, 완호의평가점수 = scores.pop(0)
    완호의총점 = 완호의태도점수 + 완호의평가점수
    
    scores = [x for x in scores if x[0]+x[1] > 완호의총점] #완호의 총점보다 낮은 점수 제거
    scores.sort(key=lambda x:x[0]+x[1], reverse=True) #큰 값부터
    
    if len(scores) == 0: #함정이 이거였어? ㅡ.ㅡ;
        return 1
    
    for i in range(len(scores)):
        태도점수1, 평가점수1 = scores[i][0], scores[i][1]
        if 완호의태도점수 < 태도점수1 and 완호의평가점수 < 평가점수1:
            return -1
    
    i = 0
    while i < len(scores)-1:
        for j in reversed(range(len(scores))):
            태도점수1, 평가점수1 = scores[i][0], scores[i][1]
            태도점수2, 평가점수2 = scores[j][0], scores[j][1]
            총점1 = 태도점수1 + 평가점수1
            총점2 = 태도점수2 + 평가점수2
            #print(총점1, 태도점수1, 평가점수1, 총점2, 태도점수2, 평가점수2)
            if 총점1 > 총점2 + 1:
                if 태도점수1 > 태도점수2 and 평가점수1 > 평가점수2:
                    scores.pop(j)
            #print(scores)
        i += 1
    
    return len(scores) + 1
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.4MB)
테스트 2 〉	통과 (0.00ms, 10.4MB)
테스트 3 〉	통과 (0.02ms, 10.4MB)
테스트 4 〉	통과 (0.02ms, 10.5MB)
테스트 5 〉	통과 (0.00ms, 10.6MB)
테스트 6 〉	통과 (0.01ms, 10.6MB)
테스트 7 〉	통과 (0.01ms, 10.4MB)
테스트 8 〉	통과 (0.01ms, 10.4MB)
테스트 9 〉	통과 (0.02ms, 10.4MB)
테스트 10 〉	통과 (0.02ms, 10.4MB)
테스트 11 〉	통과 (0.34ms, 10.4MB)
테스트 12 〉	통과 (0.07ms, 10.3MB)
테스트 13 〉	통과 (0.08ms, 10.2MB)
테스트 14 〉	통과 (0.31ms, 10.5MB)
테스트 15 〉	통과 (0.36ms, 10.8MB)
테스트 16 〉	통과 (1.08ms, 10.7MB)
테스트 17 〉	통과 (0.69ms, 11.7MB)
테스트 18 〉	통과 (1.39ms, 11.4MB)
테스트 19 〉	통과 (3.71ms, 17.5MB)
테스트 20 〉	통과 (3.48ms, 17.8MB)
테스트 21 〉	통과 (5.89ms, 18.8MB)
테스트 22 〉	통과 (22.79ms, 25.7MB)
테스트 23 〉	통과 (12.27ms, 25.7MB)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	실패 (시간 초과)

• 이제 남은 건 더 빠른 데이터 구조로 바꿔보는 거? heapq였나... 그것도 앞뒤로만 뺄 수 있고...
• 자료 구조 바꿔도 소용이 없다. 그러면 뭐다? 수학 숙제다. 수학 ㅡ.ㅡ;

def solution(scores):
    완호의태도점수, 완호의평가점수 = scores.pop(0)
    완호의총점 = 완호의태도점수 + 완호의평가점수
    
    scores = [x for x in scores if sum(x) > 완호의총점] #완호의 총점보다 낮은 점수 제거
    scores.sort(key=lambda x:sum(x), reverse=True) #큰 값부터
    
    if len(scores) == 0: #함정이 이거였어? ㅡ.ㅡ;
        return 1
    
    for i in scores:
        if 완호의태도점수 < i[0] and 완호의평가점수 < i[1]:
            return -1
        
    i = 0
    while i < len(scores)-1:
        태도점수1, 평가점수1 = scores[i][0], scores[i][1]
        j = i + 1
        while j < len(scores):
            태도점수2, 평가점수2 = scores[j][0], scores[j][1]
            if 태도점수1 > 태도점수2 and 평가점수1 > 평가점수2:
                scores.pop(j)
            else:
                j += 1
        i += 1
    
    return len(scores) + 1
    
정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.2MB)
테스트 2 〉	통과 (0.01ms, 10.5MB)
테스트 3 〉	통과 (0.01ms, 10.6MB)
테스트 4 〉	통과 (0.02ms, 10.4MB)
테스트 5 〉	통과 (0.01ms, 10.4MB)
테스트 6 〉	통과 (0.01ms, 10.5MB)
테스트 7 〉	통과 (0.01ms, 10.5MB)
테스트 8 〉	통과 (0.02ms, 10.4MB)
테스트 9 〉	통과 (0.02ms, 10.2MB)
테스트 10 〉	통과 (0.02ms, 10.5MB)
테스트 11 〉	통과 (0.22ms, 10.4MB)
테스트 12 〉	통과 (0.10ms, 10.4MB)
테스트 13 〉	통과 (0.11ms, 10.5MB)
테스트 14 〉	통과 (0.18ms, 10.4MB)
테스트 15 〉	통과 (0.49ms, 10.9MB)
테스트 16 〉	통과 (1.03ms, 10.7MB)
테스트 17 〉	통과 (2.11ms, 11.6MB)
테스트 18 〉	통과 (2.10ms, 11.7MB)
테스트 19 〉	통과 (5.11ms, 17.7MB)
테스트 20 〉	통과 (4.98ms, 17.9MB)
테스트 21 〉	통과 (8.67ms, 18.9MB)
테스트 22 〉	통과 (47.53ms, 25.8MB)
테스트 23 〉	통과 (19.08ms, 25.7MB)
테스트 24 〉	실패 (시간 초과)
테스트 25 〉	실패 (시간 초과)

• 암튼 그래서 두 점수 A,B로 (A+B, A-B) 좌료로 점을 찍어보니까 이런 규칙이 나온다.
• (A-B)한 값에서 (A+B)한 최대값을 넣고, 이거보다 작으면 탈락 시켜서 인센티브를 안주면 된다.
• (A-B)키로 딕셔너리를 만들어서 (A+B)를 값으로 쓰면 된다. 큰거부터 할거니까 갱신할 필요도 없고...
• 아니야. 대각선으로도 체크해야되고, 결국 다 뒤져야 한다.

• 뭔가 다른 방법 없나?
  • 예를 들면 태도 점수가 서로 같으면... 탈락이 아니니까 넘어가면 된다.
  • 하나라도 서로 같으면 탈락이 아님.
  • 점수를 잘 정렬하면 될 것 같은데...

a = [[9,0],[9,1],[9,2],[8,1],[8,2],[8,3],[8,10],[7,1],[7,2],[7,3],[6,6],[5,5],[3,1],[3,2]]

a.sort(key=lambda x:(-sum(x))) #큰 값부터
print(a)

#output
#[[8,10],[6,6],[9,2],[8,3],[9,1],[8,2],[7,3],[5,5],[9,0],[8,1],[7,2],[7,1],[3,2],[3,1]]

a.sort(key=lambda x:(-x[0],x[1])) #큰 값부터
print(a)

#output
#[[9,0],[9,1],[9,2],[8,1],[8,2],[8,3],[8,10],[7,1],[7,2],[7,3],[6,6],[5,5],[3,1],[3,2]]

a.sort(key=lambda x:(x[0],-x[1])) #큰 값부터
print(a)

#output
#[[3,2],[3,1],[5,5],[6,6],[7,3],[7,2],[7,1],[8,10],[8,3],[8,2],[8,1],[9,2],[9,1],[9,0]]

a.sort(key=lambda x:(-x[0],-x[1])) #큰 값부터
print(a)

#output
#[[9,2],[9,1],[9,0],[8,10],[8,3],[8,2],[8,1],[7,3],[7,2],[7,1],[6,6],[5,5],[3,2],[3,1]]

• [9,2]를 넣고, [9,1], [9,0]은 같은 9니까 넘어가고,
• 앞자리가 8로 바뀌면, [9,2]랑 [8,10]이랑 체크해서 둘 다 작으면 탈락,
• 둘 다 작지 않으면 [8,10]을 추가하고, [8,3],[8,2],[8,1]을 비교
• [9,2],[8,10]이랑 비교하면 [8,1] 탈락.
• [7,3]으로 넘어가서, [9,2],[8,10]이랑 비교하면 7,3도 탈락. 그 밑으로 다 탈락,
• [6,6]으로 넘어가서, [9,2],[8,10]이랑 비교하면 [6,6]도 탈락,
• [5,5]로 넘어가서 탈락...
• 이렇게 하면 좀 적게 비교하려나?

def solution(scores):
    완호의태도점수, 완호의평가점수 = scores.pop(0)
    완호의총점 = 완호의태도점수 + 완호의평가점수
    
    scores = [x for x in scores if sum(x) > 완호의총점] #완호의 총점보다 낮거나 같은 점수 제거
    
    answer = len(scores) + 1
    if len(scores) == 0: #함정이 이거였어? ㅡ.ㅡ;
        return answer
    
    scores.sort(key=lambda x:(-x[0],-x[1])) #큰 값부터
    
    for 점수 in scores:
        if 완호의태도점수 < 점수[0] and 완호의평가점수 < 점수[1]:
            return -1
    
    높은점수 = []
    높은점수.append(scores.pop(0))
    
    for 점수 in scores:
        #print(scores, answer, "높점", 높은점수, "지금체크하는 점수", 점수)
        for 높점 in 높은점수:
            #print(높점, 점수, end="  ")
            if 높점[0] > 점수[0]:
                if 높점[1] > 점수[1]: #이 점수 밑으로 다 탈락
                    #print("탈락")
                    answer -= 1
                    break
                else:
                    #print("점수등록")
                    높은점수.append(점수)
            #print(" ")
    return answer
    
정확성  테스트
테스트 1 〉	통과 (0.00ms, 10.4MB)
테스트 2 〉	통과 (0.00ms, 10.3MB)
테스트 3 〉	통과 (0.01ms, 10.4MB)
테스트 4 〉	통과 (0.01ms, 10.2MB)
테스트 5 〉	통과 (0.01ms, 10.3MB)
테스트 6 〉	통과 (0.01ms, 10.3MB)
테스트 7 〉	통과 (0.01ms, 10.3MB)
테스트 8 〉	통과 (0.01ms, 10.3MB)
테스트 9 〉	통과 (0.03ms, 10.5MB)
테스트 10 〉	통과 (0.04ms, 10.3MB)
테스트 11 〉	통과 (1.81ms, 10.3MB)
테스트 12 〉	통과 (0.10ms, 10.4MB)
테스트 13 〉	통과 (0.13ms, 10.3MB)
테스트 14 〉	통과 (0.27ms, 10.4MB)
테스트 15 〉	통과 (0.52ms, 10.7MB)
테스트 16 〉	통과 (157.25ms, 16.8MB)
테스트 17 〉	통과 (1.82ms, 11.5MB)
테스트 18 〉	통과 (1.25ms, 11.4MB)
테스트 19 〉	통과 (7.50ms, 17.4MB)
테스트 20 〉	통과 (5.29ms, 17.9MB)
테스트 21 〉	통과 (8.75ms, 18.6MB)
테스트 22 〉	통과 (2588.67ms, 122MB)
테스트 23 〉	통과 (33.99ms, 27.4MB)
테스트 24 〉	통과 (97.93ms, 29.2MB)
테스트 25 〉	실패 (시간 초과)

• 마지막거 너무했다. ㅡ.ㅡ;
• 어떻게 풀어 ㅠ.ㅠ
• 근데 잠만... 점수[0]은 비교 안해도 되지 않나?
• 점수[0]으로 정렬되어 있고, 점점 작아지니까... 점수[1]만 비교하면 될 것 같다. 안되네? ㅋㅋㅋ

도저히 안되겠다. 컨닝 좀 하자.ㅋㅋㅋ

아... 이렇게 해야되는구나...
#output
#[[9,0],[9,1],[9,2],[8,1],[8,2],[8,3],[8,10],[7,1],[7,2],[7,3],[6,6],[5,5],[3,1],[3,2]]

• 점수[0]이 같을 때는 그냥 넘어가고, 점수[0]이 달라지면 점수 갱신.
• 그러면 시작해보면
• [9,0]이 초기값
  • [9,1],[9,2] 는 9가 같으니까 높은점수를 갱신하면서 넘어감. 마지막[9,2]
• [8,1]부터 점수[0]이 달라짐. 마지막[9,2]랑 비교하면
  • [8,1] 탈락
  • [8,2],[8,3],[8,10]안탈락, 점수 갱신. 마지막 [8,10]

아... 이렇게 하는거였구나. ㅠ.ㅠ

def solution(scores):
    완호의태도점수, 완호의평가점수 = scores.pop(0)
    완호의총점 = 완호의태도점수 + 완호의평가점수
    
    scores = [x for x in scores if sum(x) > 완호의총점] #완호의 총점보다 낮거나 같은 점수 제거
    
    answer = len(scores) + 1
    if len(scores) == 0: #함정이 이거였어? ㅡ.ㅡ;
        return answer
    
    scores.sort(key=lambda x:(-x[0],x[1])) #큰 값부터
    
    for 점수 in scores:
        if 완호의태도점수 < 점수[0] and 완호의평가점수 < 점수[1]:
            return -1
    
    높은점수 = []
    높은점수 = scores.pop(0)
    
    for 점수 in scores:
        if 높은점수[0] == 점수[0]:
            높은점수[1] = 점수[1]
        else:
            if 높은점수[1] > 점수[1]:
                answer -= 1
            else:
                높은점수 = 점수
        
    return answer
    
정확성  테스트
테스트 1 〉	통과 (0.00ms, 10.4MB)
테스트 2 〉	통과 (0.00ms, 10.2MB)
테스트 3 〉	통과 (0.01ms, 10.3MB)
테스트 4 〉	통과 (0.01ms, 10.5MB)
테스트 5 〉	통과 (0.00ms, 10.2MB)
테스트 6 〉	통과 (0.01ms, 10.3MB)
테스트 7 〉	통과 (0.01ms, 10.4MB)
테스트 8 〉	통과 (0.01ms, 10.3MB)
테스트 9 〉	통과 (0.02ms, 10.3MB)
테스트 10 〉	통과 (0.02ms, 10.2MB)
테스트 11 〉	통과 (0.35ms, 10.4MB)
테스트 12 〉	통과 (0.11ms, 10.4MB)
테스트 13 〉	통과 (0.23ms, 10.4MB)
테스트 14 〉	통과 (0.18ms, 10.3MB)
테스트 15 〉	통과 (1.11ms, 10.7MB)
테스트 16 〉	통과 (2.35ms, 10.9MB)
테스트 17 〉	통과 (0.96ms, 11.4MB)
테스트 18 〉	통과 (0.98ms, 11.4MB)
테스트 19 〉	통과 (7.07ms, 17.6MB)
테스트 20 〉	통과 (9.47ms, 17.8MB)
테스트 21 〉	통과 (9.73ms, 18.8MB)
테스트 22 〉	통과 (36.20ms, 26.7MB)
테스트 23 〉	통과 (25.55ms, 26.6MB)
테스트 24 〉	통과 (56.88ms, 28.1MB)
테스트 25 〉	통과 (20.80ms, 26.2MB)

• 정렬을 어떻게 하는가가 가장 중요한 문제였다.
• 엉뚱하게 정렬해놓고, 그 구조로 풀려고 머리를 아무리 굴려도 되질 않아 고민했다.
• 다음부터 2수를 비교하는 문제가 나오면 무조건 저 람다 함수로 정렬해서 푸는 걸로...
• 하지만 나중에 비슷한 문제가 나오면 까먹고 또 삽질하겠지. ㅋㅋㅋ

고생한 만큼 점수가 커서 기분이 좋다. +5점 짜리 문제 였다니!