프로그래머스 양궁대회 (포기)

문제 설명

카카오배 양궁대회가 열렸습니다.
라이언은 저번 카카오배 양궁대회 우승자이고 이번 대회에도 결승전까지 올라왔습니다. 결승전 상대는 어피치입니다.
카카오배 양궁대회 운영위원회는 한 선수의 연속 우승보다는 다양한 선수들이 양궁대회에서 우승하기를 원합니다. 따라서, 양궁대회 운영위원회는 결승전 규칙을 전 대회 우승자인 라이언에게 불리하게 다음과 같이 정했습니다.

1. 어피치가 화살 n발을 다 쏜 후에 라이언이 화살 n발을 쏩니다.
2. 점수를 계산합니다.
   1. 과녁판은 아래 사진처럼 생겼으며 가장 작은 원의 과녁 점수는 10점이고 가장 큰 원의 바깥쪽은 과녁 점수가 0점입니다. 

      

   2. 만약, k(k는 1~10사이의 자연수)점을 어피치가 a발을 맞혔고 라이언이 b발을 맞혔을 경우 더 많은 화살을 k점에 맞힌 선수가 k 점을 가져갑니다. 단, a = b일 경우는 어피치가 k점을 가져갑니다. k점을 여러 발 맞혀도 k점 보다 많은 점수를 가져가는 게 아니고 k점만 가져가는 것을 유의하세요. 또한 a = b = 0 인 경우, 즉, 라이언과 어피치 모두 k점에 단 하나의 화살도 맞히지 못한 경우는 어느 누구도 k점을 가져가지 않습니다.
      • 예를 들어, 어피치가 10점을 2발 맞혔고 라이언도 10점을 2발 맞혔을 경우 어피치가 10점을 가져갑니다.
      • 다른 예로, 어피치가 10점을 0발 맞혔고 라이언이 10점을 2발 맞혔을 경우 라이언이 10점을 가져갑니다.
   3. 모든 과녁 점수에 대하여 각 선수의 최종 점수를 계산합니다.
3. 최종 점수가 더 높은 선수를 우승자로 결정합니다. 단, 최종 점수가 같을 경우 어피치를 우승자로 결정합니다.

현재 상황은 어피치가 화살 n발을 다 쏜 후이고 라이언이 화살을 쏠 차례입니다.
라이언은 어피치를 가장 큰 점수 차이로 이기기 위해서 n발의 화살을 어떤 과녁 점수에 맞혀야 하는지를 구하려고 합니다.

화살의 개수를 담은 자연수 n, 어피치가 맞힌 과녁 점수의 개수를 10점부터 0점까지 순서대로 담은 정수 배열 info가 매개변수로 주어집니다. 이때, 라이언이 가장 큰 점수 차이로 우승하기 위해 n발의 화살을 어떤 과녁 점수에 맞혀야 하는지를 10점부터 0점까지 순서대로 정수 배열에 담아 return 하도록 solution 함수를 완성해 주세요. 만약, 라이언이 우승할 수 없는 경우(무조건 지거나 비기는 경우)는 [-1]을 return 해주세요.

제한 사항

• 1 ≤ n ≤ 10
• info의 길이 = 11
  • 0 ≤ info의 원소 ≤ n
  • info의 원소 총합 = n
  • info의 i번째 원소는 과녁의 10 - i 점을 맞힌 화살 개수입니다. ( i는 0~10 사이의 정수입니다.)
• 라이언이 우승할 방법이 있는 경우, return 할 정수 배열의 길이는 11입니다.
  • 0 ≤ return할 정수 배열의 원소 ≤ n
  • return할 정수 배열의 원소 총합 = n (꼭 n발을 다 쏴야 합니다.)
  • return할 정수 배열의 i번째 원소는 과녁의 10 - i 점을 맞힌 화살 개수입니다. ( i는 0~10 사이의 정수입니다.)
  • 라이언이 가장 큰 점수 차이로 우승할 수 있는 방법이 여러 가지 일 경우, 가장 낮은 점수를 더 많이 맞힌 경우를 return 해주세요.
    • 가장 낮은 점수를 맞힌 개수가 같을 경우 계속해서 그다음으로 낮은 점수를 더 많이 맞힌 경우를 return 해주세요.
    • 예를 들어, [2,3,1,0,0,0,0,1,3,0,0]과 [2,1,0,2,0,0,0,2,3,0,0]를 비교하면 [2,1,0,2,0,0,0,2,3,0,0]를 return 해야 합니다.
    • 다른 예로, [0,0,2,3,4,1,0,0,0,0,0]과 [9,0,0,0,0,0,0,0,1,0,0]를 비교하면[9,0,0,0,0,0,0,0,1,0,0]를 return 해야 합니다.
• 라이언이 우승할 방법이 없는 경우, return 할 정수 배열의 길이는 1입니다.
  • 라이언이 어떻게 화살을 쏘든 라이언의 점수가 어피치의 점수보다 낮거나 같으면 [-1]을 return 해야 합니다.
• 제한시간 안내
  • 정확성 테스트 : 10초

입출력 예

n	info	result
5	[2,1,1,1,0,0,0,0,0,0,0]	[0,2,2,0,1,0,0,0,0,0,0]
1	[1,0,0,0,0,0,0,0,0,0,0]	[-1]
9	[0,0,1,2,0,1,1,1,1,1,1]	[1,1,2,0,1,2,2,0,0,0,0]
10	[0,0,0,0,0,0,0,0,3,4,3]	[1,1,1,1,1,1,1,1,0,0,2]

입출력 예 설명

입출력 예 #1

어피치와 라이언이 아래와 같이 화살을 맞힐 경우,

과녁 점수	어피치가 맞힌 화살 개수	라이언이 맞힌 화살 개수	결과
10	2	3	라이언이 10점 획득
9	1	2	라이언이 9점 획득
8	1	0	어피치가 8점 획득
7	1	0	어피치가 7점 획득
6	0	0
5	0	0
4	0	0
3	0	0
2	0	0
1	0	0
0	0	0

어피치의 최종 점수는 15점, 라이언의 최종 점수는 19점입니다. 4점 차이로 라이언이 우승합니다.

하지만, 라이언이 아래와 같이 화살을 맞힐 경우 더 큰 점수 차로 우승할 수 있습니다.

과녁 점수	어피치가 맞힌 화살 개수	라이언이 맞힌 화살 개수	결과
10	2	0	어피치가 10점 획득
9	1	2	라이언이 9점 획득
8	1	2	라이언이 8점 획득
7	1	0	어피치가 7점 획득
6	0	1	라이언이 6점 획득
5	0	0
4	0	0
3	0	0
2	0	0
1	0	0
0	0	0

어피치의 최종 점수는 17점, 라이언의 최종 점수는 23점입니다. 6점 차이로 라이언이 우승합니다.

따라서 [0,2,2,0,1,0,0,0,0,0,0]을 return 해야 합니다.

입출력 예 #2

라이언이 10점을 맞혀도 어피치가 10점을 가져가게 됩니다.
따라서, 라이언은 우승할 수 없기 때문에 [-1]을 return 해야 합니다.

입출력 예 #3

어피치와 라이언이 아래와 같이 화살을 맞힐 경우,

과녁 점수	어피치가 맞힌 화살 개수	라이언이 맞힌 화살 개수	결과
10	0	1	라이언이 10점 획득
9	0	1	라이언이 9점 획득
8	1	2	라이언이 8점 획득
7	2	3	라이언이 7점 획득
6	0	0
5	1	2	라이언이 5점 획득
4	1	0	어피치가 4점 획득
3	1	0	어피치가 3점 획득
2	1	0	어피치가 2점 획득
1	1	0	어피치가 1점 획득
0	1	0	어피치가 0점 획득

어피치의 최종 점수는 10점, 라이언의 최종 점수는 39점입니다. 29점 차이로 라이언이 우승합니다.

하지만 라이언이 아래와 같이 화살을 맞힐 경우,

과녁 점수	어피치가 맞힌 화살 개수	라이언이 맞힌 화살 개수	결과
10	0	1	라이언이 10점 획득
9	0	1	라이언이 9점 획득
8	1	2	라이언이 8점 획득
7	2	0	어피치가 7점 획득
6	0	1	라이언이 6점 획득
5	1	2	라이언이 5점 획득
4	1	2	라이언이 4점 획득
3	1	0	어피치가 3점 획득
2	1	0	어피치가 2점 획득
1	1	0	어피치가 1점 획득
0	1	0	어피치가 0점 획득

어피치의 최종 점수는 13점, 라이언의 최종 점수는 42점입니다. 이 경우도 29점 차이로 라이언이 우승합니다.
하지만, 첫 번째 경우와 두 번째 경우를 비교했을 때, 두 번째 경우가 두 경우 중 가장 낮은 점수인 4점을 더 많이 맞혔기 때문에 [1,1,2,3,0,2,0,0,0,0,0]이 아닌 [1,1,2,0,1,2,2,0,0,0,0]을 return 해야 합니다.

입출력 예 #4

가장 큰 점수 차이로 이기는 경우 중에서 가장 낮은 점수를 가장 많이 맞힌, 10~3점을 한 발씩 맞히고 나머지 두 발을 0점에 맞히는 경우인 [1,1,1,1,1,1,1,1,0,0,2]를 return 해야 합니다.

풀이

• 문제는 되게 쉬운 거 같은데, 읽을 수록 아리송 하다.
  • 수학 문제인가?
• 어피치가 맞힌 화살 개수가 2개 이상이면 1개 낭비한거. 왜냐? 라이언은 거기 안 쏠거거든
  • 즉, 어치피 총점은 맞힌 화살이 있는 곳만 어피치 점수임.
    • 예를 들어 10점에 10발 맞췄다.
      • 그러면 라이언은 0점부터 9점까지 1발씩만 쏴도 45점으로 최고점  먹음
  • 빈칸에 먼저 쏘고, 적은 것부터 빼앗으면 되지 않나?
• 어피치가 10x2, 9x2, 8x2, 7x2, 6x2 이렇게 10발 쐈다 치면 = 40점
  • 5,4,3,2,1에 한발씩 쏘고 = 15점
  • 나머지 5발로, 10점에 3발 쏘면... 10점해서 25점. 어피치는 30점.
    • 잉? 아니구만
  • 10점 3발, 9점 3발 쏘면 19점. 어피치는 8+7+6 점(21점)
    • 2발 남은 걸로, 5+4 = 9점. 하면 19+9 = 28점
    • 이걸 어떻게 알고리즘으로 만들어...
• 어피치가 10x2, 9x2, 8x2, 7x2, 6x2 이렇게 10발 쐈다 치면 = 40점
  • 라이언은 비어있는 칸부터 채운다. 5,4,3,2,1 그리고 5발 남으면 어차피의 제일 높은 점수부터 깐다.
  • 어피치 : 9x2, 8x2, 7x2, 6x2 = 30점
  • 라이언 : 10x3, 5,4,3,2,1 = 25점. 남은 화살 2개
    • 1점에 있는 화살 1개 뽑아서 9점에 3발 쏘면...
      • 어피치 : 8x2, 7x2, 6x2 = 21점
      • 라이언 : 10x3, 9x3, 5,4,3,2 = 34점. 남은 화살 0개. 점수차 13점
        • 낮은 점수 화살 4개 더 뽑아서, 7이랑 6 무력화 시키면
          • 어피치 0점.
          • 라이언 10x3, 9x3 = 19점. 점수차 19점
• 아무리 해도 머리가 안돌아가는데... 여기 알고리즘 없는거 아닐까?
  • 그냥 랜덤으로 해보거나 전부 다 해보는 방법 밖에 없는건가...;;;
    • 어차피 화살 n은 1~10이고. 점수판 info의 길이는 11.
  • 아닌데 그럼 어차피 점수는 왜 줬겠어?
    • 뭔가 있겟지???
    • 흑흑흑...

#아우 몰?루...

def solution(n, info):
    infolen = 11
    ryan = [0 for _ in range(infolen)]
    
    def compare_sum():
        sum_info, sum_ryan = 0, 0
        for i in range(infolen):
            if info[i] > ryan[i]:
                sum_info += i
            elif info[i] < ryan[i]:
                sum_ryan += i
        return (sum_info, sum_ryan)
    
    while n > 0:
        for i in range(infolen):
            if info[i]+1 > ryan[i] and n>0:
                ryan[i] += 1
                n -= 1
            sum_info, sum_ryan = compare_sum()
            print("어피치:", info, "=", sum_info)
            print("라이언:", ryan, "=", sum_ryan, "(남은 화살:",n,")")
        
    return ryan
    
테스트 1
입력값 〉	5, [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[0, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,0,0,0,0,0,0]이 기댓값 [0,2,2,0,1,0,0,0,0,0,0]과 다릅니다.
출력 〉	
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 6
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 4 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 5
라이언: [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 3 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 3
라이언: [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 2 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 1 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 4 (남은 화살: 0 )

테스트 2
입력값 〉	1, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[-1]
실행 결과 〉	실행한 결괏값 [1,0,0,0,0,0,0,0,0,0,0]이 기댓값 [-1]과 다릅니다.
출력 〉	
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 0 )

테스트 3
입력값 〉	9, [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1]
기댓값 〉	[1, 1, 2, 0, 1, 2, 2, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,1,1,1,1,0,0]이 기댓값 [1,1,2,0,1,2,2,0,0,0,0]과 다릅니다.
출력 〉	
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 50
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 8 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 50
라이언: [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 1 (남은 화살: 7 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 48
라이언: [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] = 1 (남은 화살: 6 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 48
라이언: [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 1 (남은 화살: 5 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 48
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 5 (남은 화살: 4 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 43
라이언: [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0] = 5 (남은 화살: 3 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 37
라이언: [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0] = 5 (남은 화살: 2 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 30
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0] = 5 (남은 화살: 1 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 22
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] = 5 (남은 화살: 0 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 22
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] = 5 (남은 화살: 0 )
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 22
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] = 5 (남은 화살: 0 )

테스트 4
입력값 〉	10, [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3]
기댓값 〉	[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,1,1,1,1,1,0]이 기댓값 [1,1,1,1,1,1,1,1,0,0,2]과 다릅니다.
출력 〉	
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 9 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 1 (남은 화살: 8 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] = 3 (남은 화살: 7 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 6 (남은 화살: 6 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0] = 10 (남은 화살: 5 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0] = 15 (남은 화살: 4 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0] = 21 (남은 화살: 3 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0] = 28 (남은 화살: 2 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0] = 28 (남은 화살: 1 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] = 28 (남은 화살: 0 )
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
라이언: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0] = 28 (남은 화살: 0 )

• 생각해보니까... 어피치의 점수를 빼앗으려면 화살 갯수만큼 나누고 1을 더해야 되네...
• 그리고 어피치가 화살 안 쏜 곳은 점수 그대로고...?

def solution(n, info):
    infolen = 11
    ryan = [0 for _ in range(infolen)]
    effc = []
    # info는 과녁에 꽂힌 화살 수
    # ryan은 과녁에 꽂을 화살을 맞추는...
    # effc은 효율 계산
    
    def compare_sum(): # 점수 비교용
        sum_info, sum_ryan = 0, 0
        for i in range(infolen):
            if info[i] > ryan[i]:
                sum_info += i
            elif info[i] < ryan[i]:
                sum_ryan += i
        return (sum_info, sum_ryan)
    
    def calc_effecient(): # 효율 계산
        eff2 = []
        point = 10
        for i in range(infolen):
            eff2.append(point / (info[i]+1))
            if info[i] != 0:
                eff2[i] *= 2
            point -= 1
        return eff2
    
    effc = calc_effecient()
    sum_info, sum_ryan = compare_sum()
    print("어피치:", info, "=", sum_info)
    print("효__율:", effc,)
    print("라이언:", ryan, "=", sum_ryan, "(남은 화살:",n,")")

    while n > 0:
        for i in range(infolen):
            if info[i]+1 > ryan[i] and n>0:
                ryan[i] += 1
                n -= 1
            sum_info, sum_ryan = compare_sum()
        
    return ryan
    
테스트 1
입력값 〉	5, [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[0, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,0,0,0,0,0,0]이 기댓값 [0,2,2,0,1,0,0,0,0,0,0]과 다릅니다.
출력 〉	
어피치: [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0] = 6
효__율: [6.666666666666667, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0]
라이언: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 5 )

테스트 2
입력값 〉	1, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[-1]
실행 결과 〉	실행한 결괏값 [1,0,0,0,0,0,0,0,0,0,0]이 기댓값 [-1]과 다릅니다.
출력 〉	
어피치: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0
효__율: [10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0]
라이언: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 1 )

테스트 3
입력값 〉	9, [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1]
기댓값 〉	[1, 1, 2, 0, 1, 2, 2, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,1,1,1,1,0,0]이 기댓값 [1,1,2,0,1,2,2,0,0,0,0]과 다릅니다.
출력 〉	
어피치: [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1] = 50
효__율: [10.0, 9.0, 8.0, 4.666666666666667, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0]
라이언: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 9 )

테스트 4
입력값 〉	10, [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3]
기댓값 〉	[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,1,1,1,1,1,0]이 기댓값 [1,1,1,1,1,1,1,1,0,0,2]과 다릅니다.
출력 〉	
어피치: [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3] = 27
효__율: [10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 1.0, 0.4, 0.0]
라이언: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] = 0 (남은 화살: 10 )

• 효율이 높은 순으로 점수를 빼앗으면 되고,
  • 점수가 더 높아지지 않으면 화살을 0점 있는 곳 까지 보내서 낮은 점수를 많이 맞히도록 하면 된다. 되나?
    • 효율로도 어려움.
• 그래서... re:zero로부터 다시 시작하는 ㅋㅋㅋ
  • 요번 아이디어는 11칸에 화살 n개 박아넣는 경우의 수를 전부 만들어서 점수 비교해버리는 거...
    • 뭐... 얼마 안걸리겠지?

def solution(n, info):
    #n : 화살 수. 1~10 사이. 발수가 10개 밖에 안됨
    #info :과녁의_점수칸 11 고정.
    라이언의_과녁 = [0 for _ in range(len(info))]
    return 라이언의_과녁

• k개의 상자에 n개의 구슬을 몇개씩 넣는.. 경우의 수는 어떻게 구하더라?
  • 상자 구분x, 빈 상자 허용
    • 과녁점수칸(k) = 11, 빈 상자 허용
    • 화살(n) = 5 (1~10)
      • 경우의 수 P(n,i), i는 1~k = P(n,1) + P(n,2) + P(n,3) + ... P(n,k)
        • 가 아니다.
  • 상자 구분o, 빈 상자 허용
    • kHn (중복 조합) 11H5

17. 서로 (같은/다른) 상자에 서로 (같은/다른) 구슬을 넣는 경우의 수

• 그리고 중복조합은 itertools
  • 매번 검색하지 말고, 나도 블로그에 정리해놔야지

[Python] 순열, 조합, 중복순열, 중복조합(itertools를 활용한 구현)

• 중복조합 기본 구조
  • 근데 시간초과 날 것 같은 느낌이다.

from itertools import combinations_with_replacement

def solution(n, info):
    #n : 화살 수. 1~10 사이. 발수가 10개 밖에 안됨
    #info :과녁의_점수칸 11 고정.
    라이언의_과녁 = [i for i in range(len(info))]

    comb = combinations_with_replacement(라이언의_과녁, n)

    i = 0
    for c in comb:
        print(c)
        i += 1
        if i > 5:
            break

    return 라이언의_과녁
    
실행 결과
테스트 1
입력값 〉	5, [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[0, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [0,1,2,3,4,5,6,7,8,9,10]이 기댓값 [0,2,2,0,1,0,0,0,0,0,0]과 다릅니다.
출력 〉	(0, 0, 0, 0, 0)
(0, 0, 0, 0, 1)
(0, 0, 0, 0, 2)
(0, 0, 0, 0, 3)
(0, 0, 0, 0, 4)
(0, 0, 0, 0, 5)

테스트 2
입력값 〉	1, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[-1]
실행 결과 〉	실행한 결괏값 [0,1,2,3,4,5,6,7,8,9,10]이 기댓값 [-1]과 다릅니다.
출력 〉	(0,)
(1,)
(2,)
(3,)
(4,)
(5,)

테스트 3
입력값 〉	9, [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1]
기댓값 〉	[1, 1, 2, 0, 1, 2, 2, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [0,1,2,3,4,5,6,7,8,9,10]이 기댓값 [1,1,2,0,1,2,2,0,0,0,0]과 다릅니다.
출력 〉	(0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 1)
(0, 0, 0, 0, 0, 0, 0, 0, 2)
(0, 0, 0, 0, 0, 0, 0, 0, 3)
(0, 0, 0, 0, 0, 0, 0, 0, 4)
(0, 0, 0, 0, 0, 0, 0, 0, 5)

테스트 4
입력값 〉	10, [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3]
기댓값 〉	[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2]
실행 결과 〉	실행한 결괏값 [0,1,2,3,4,5,6,7,8,9,10]이 기댓값 [1,1,1,1,1,1,1,1,0,0,2]과 다릅니다.
출력 〉	(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 1)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 2)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 3)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 4)
(0, 0, 0, 0, 0, 0, 0, 0, 0, 5)

• 혹시 몰라서 채점 돌려봤는데... 괜찮은 걸까?

정확성  테스트
테스트 1 〉	실패 (0.00ms, 10.3MB)
테스트 2 〉	실패 (0.00ms, 10.3MB)
테스트 3 〉	실패 (0.00ms, 10.4MB)
테스트 4 〉	실패 (0.01ms, 10.4MB)
테스트 5 〉	실패 (0.00ms, 10.4MB)
테스트 6 〉	실패 (0.00ms, 10.4MB)
테스트 7 〉	실패 (0.00ms, 10.4MB)
테스트 8 〉	실패 (0.00ms, 10.4MB)
테스트 9 〉	실패 (0.00ms, 10.4MB)
테스트 10 〉	실패 (0.00ms, 10.3MB)
테스트 11 〉	실패 (0.00ms, 10.3MB)
테스트 12 〉	실패 (0.00ms, 10.4MB)
테스트 13 〉	실패 (0.00ms, 10.5MB)
테스트 14 〉	실패 (0.00ms, 10.3MB)
테스트 15 〉	실패 (0.00ms, 10.5MB)
테스트 16 〉	실패 (0.00ms, 10.4MB)
테스트 17 〉	실패 (0.01ms, 10.3MB)
테스트 18 〉	실패 (0.00ms, 10.4MB)
테스트 19 〉	실패 (0.00ms, 10.3MB)
테스트 20 〉	실패 (0.00ms, 10.3MB)
테스트 21 〉	실패 (0.00ms, 10.3MB)
테스트 22 〉	실패 (0.00ms, 10.4MB)
테스트 23 〉	실패 (0.00ms, 10.4MB)
테스트 24 〉	실패 (0.00ms, 10.3MB)
테스트 25 〉	실패 (0.00ms, 10.3MB)

• 코딩 하다보니까 중복 조합 잘 못 만들었네 ㅋㅋㅋ
  • 이렇게 만들어야 한다. 
    • 라이언의_과녁 = [i for i in range(n+1)]
    • comb = combinations_with_replacement(라이언의_과녁, 11)
  • 원래 answer=[]를 이름바꾼거라서 점수 조합인데 과녁 칸으로 생각했다.
  • 근데 그거 아니더라도 멍청이인게...
    • 0~5까지 숫자를 넣는게 중요한게 아니라....
      • 아 합이 5넘어가면 제거해버리면 되는구나?

from itertools import combinations_with_replacement

def solution(n, info):
    #n : 화살 수. 1~10 사이. 발수가 10개 밖에 안됨
    #info :과녁의_점수칸 11 고정.
    라이언의_과녁 = [i for i in range(n+1)]
    comb = combinations_with_replacement(라이언의_과녁, 11)
    
    #점수비교. 중복 조합에서 하나씩 꺼내서 점수를 먼저 계산한다.
    라이언_최대점수 = 0
    라이언_과녁배열 = [0 for i in range(11)]
    
    for c in comb:
        라이언점수 = 0
        어피치점수 = 0
        for i in range(len(info)):
            if info[i] > c[i]:
                어피치점수 += 10-i
            elif info[i] < c[i]:
                라이언점수 += 10-i
        if 라이언_최대점수 < 라이언점수 - 어피치점수:
            라이언_최대점수 = 라이언점수 - 어피치점수
            라이언_과녁배열.clear()
            라이언_과녁배열 = list(c)
            
    return 라이언_과녁배열
    
테스트 1
입력값 〉	5, [2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[0, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [3,3,3,3,3,3,3,3,3,3,3]이 기댓값 [0,2,2,0,1,0,0,0,0,0,0]과 다릅니다.
테스트 2
입력값 〉	1, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
기댓값 〉	[-1]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,1,1,1,1,1,1]이 기댓값 [-1]과 다릅니다.
테스트 3
입력값 〉	9, [0, 0, 1, 2, 0, 1, 1, 1, 1, 1, 1]
기댓값 〉	[1, 1, 2, 0, 1, 2, 2, 0, 0, 0, 0]
실행 결과 〉	실행한 결괏값 [1,1,2,3,3,3,3,3,3,3,3]이 기댓값 [1,1,2,0,1,2,2,0,0,0,0]과 다릅니다.
테스트 4
입력값 〉	10, [0, 0, 0, 0, 0, 0, 0, 0, 3, 4, 3]
기댓값 〉	[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 2]
실행 결과 〉	실행한 결괏값 [1,1,1,1,1,1,1,1,4,5,5]이 기댓값 [1,1,1,1,1,1,1,1,0,0,2]과 다릅니다.

• 중복 조합을 직접 만들까 하다가... 파이썬 모듈 보다 빠를리 없다며 포기
  • 그냥 for문 돌려 ㅋㅋㅋ
  • 이러면 되겠지?

• 잘 되네

• 뒤에 안됨.
  • 검색해보니까...
    • 리스트 길이가 길어서 멈춰버리는 것 같다.
      • 999,999,999 하면 메모리에러
      • 천만부터 느려지고
      • 2억까지 가능
      • 3억부터 메모리에러
      • 백만까지 스무스하게 빠르게 생성 가능
      • 100,000,000 (일억)이 381 MB 크기
  • 역시 직접 만들어야...?
    • 아니야 직접 만들 필요없고, 
      • combinations_with_replacement 한번 하고, permutation 한번 하고 결과 같은 건 걸러내면 되는데, 속도 무진장 안나온다. 포기... 다시 처음 방식으로 ㅋㅋㅋ

import itertools

def solution(n, info):
    #n : 화살 수. 1~10 사이. 발수가 10개 밖에 안됨
    #info :과녁의_점수칸 11 고정.
    라이언의_과녁 = [i for i in range(n+1)]
    comb = itertools.combinations_with_replacement(라이언의_과녁, 11)
    comb = [list(c) for c in comb if sum(c) == n]
    
    print(comb)
    perm = []
    for c in comb:
        all_permutations = itertools.permutations(c)
        for ap in all_permutations:
            if list(ap) not in perm:
                perm.append(list(ap))
    
    i = 2
    for p in perm:
        print(p)
        i -= 1
        if i<0 :
            break
    #    for pp in p:
    #       print(pp)
    ##   i += 1
    #  if i > 1:
    #       break
    #점수비교. 중복 조합에서 하나씩 꺼내서 점수를 먼저 계산한다.
    라이언_최대점수 = 0
    라이언_과녁배열 = [0 for i in range(11)]
    
    for c in comb:
        라이언점수 = 0
        어피치점수 = 0
        if c == (0,2,2,0,1,0,0,0,0,0,0):
            print("찾았다 요놈")
        for i in range(len(info)):
            if info[i] > c[i]:
                어피치점수 += 10-i
            elif info[i] < c[i]:
                라이언점수 += 10-i
        if 라이언_최대점수 < 라이언점수 - 어피치점수:
            라이언_최대점수 = 라이언점수 - 어피치점수
            #print(라이언_과녁배열,c)
            라이언_과녁배열 = c
    if 라이언_최대점수 <= 0:
        return [-1]
    
    return 라이언_과녁배열

print(solution(5, [1,1,1,1,1,0,0,0,0,0,0]))

• 다시... ㅋㅋㅋ
  • 테케는 성공

import itertools

def solution(n, info):
    arrow_n_score = []
    ryan_arrow = [0 for i in range(11)]
    for i in range(len(info)):
        점수위치 = i
        필요화살 = info[i]+1 #이기려면 필요한 화살
        점수효율 = (10-i)/필요화살
        if info[i] > 0:
            점수효율 *= 2
        arrow_n_score.append([점수위치, 점수효율, 필요화살])
        
    arrow_n_score.sort(key=lambda x:(-x[1],x[2]))
    print(arrow_n_score)
    index = 0
    while n > 0:
        print("첫번째", arrow_n_score[index])
        if arrow_n_score[index][2] <= n:
            ryan_arrow[arrow_n_score[index][0]] = arrow_n_score[index][2]
            n -= arrow_n_score[index][2]
        else:
            if index == 10:
                ryan_arrow[arrow_n_score[10][0]] = n
                n = 0
        index += 1
    
    # 점수계산해서... 못 넘어가면 [-1] 리턴
    sum_info, sum_ryan = 0, 0
    for i in range(len(info)):
        if info[i] > ryan_arrow[i]:
            sum_info += 10-i
        elif info[i] < ryan_arrow[i]:
            sum_ryan += 10-i
            
    if sum_info < sum_ryan:
        return ryan_arrow
    else:
        return [-1]

• 채점은?
  • 실패...
  • 다시 원점이네 ㅋㅋㅋㅋ

정확성  테스트
테스트 1 〉	통과 (0.01ms, 10.6MB)
테스트 2 〉	실패 (0.03ms, 10.4MB)
테스트 3 〉	실패 (0.02ms, 10.2MB)
테스트 4 〉	실패 (0.02ms, 10.3MB)
테스트 5 〉	통과 (0.02ms, 10.3MB)
테스트 6 〉	실패 (0.02ms, 10.5MB)
테스트 7 〉	통과 (0.02ms, 10.4MB)
테스트 8 〉	통과 (0.02ms, 10.4MB)
테스트 9 〉	통과 (0.02ms, 10.6MB)
테스트 10 〉	실패 (0.02ms, 10.3MB)
테스트 11 〉	통과 (0.02ms, 10.2MB)
테스트 12 〉	실패 (0.02ms, 10.4MB)
테스트 13 〉	통과 (0.02ms, 10.5MB)
테스트 14 〉	실패 (0.02ms, 10.4MB)
테스트 15 〉	실패 (0.02ms, 10.5MB)
테스트 16 〉	실패 (0.02ms, 10.4MB)
테스트 17 〉	통과 (0.02ms, 10.5MB)
테스트 18 〉	통과 (0.02ms, 10.5MB)
테스트 19 〉	통과 (0.02ms, 10.4MB)
테스트 20 〉	통과 (0.02ms, 10.4MB)
테스트 21 〉	실패 (0.02ms, 10.4MB)
테스트 22 〉	통과 (0.02ms, 10.3MB)
테스트 23 〉	통과 (0.02ms, 10.6MB)
테스트 24 〉	통과 (0.02ms, 10.3MB)
테스트 25 〉	통과 (0.02ms, 10.3MB)

• 수정 = 실패

정확성  테스트
테스트 1 〉	통과 (0.03ms, 10.4MB)
테스트 2 〉	통과 (0.03ms, 10.5MB)
테스트 3 〉	통과 (0.04ms, 10.5MB)
테스트 4 〉	통과 (0.05ms, 10.4MB)
테스트 5 〉	통과 (0.05ms, 10.4MB)
테스트 6 〉	통과 (0.03ms, 10.4MB)
테스트 7 〉	통과 (0.03ms, 10.5MB)
테스트 8 〉	실패 (0.03ms, 10.4MB)
테스트 9 〉	실패 (0.05ms, 10.5MB)
테스트 10 〉	통과 (0.05ms, 10.4MB)
테스트 11 〉	실패 (0.04ms, 10.4MB)
테스트 12 〉	통과 (0.05ms, 10.4MB)
테스트 13 〉	실패 (0.05ms, 10.4MB)
테스트 14 〉	통과 (0.05ms, 10.4MB)
테스트 15 〉	통과 (0.05ms, 10.6MB)
테스트 16 〉	통과 (0.04ms, 10.4MB)
테스트 17 〉	통과 (0.06ms, 10.4MB)
테스트 18 〉	실패 (0.03ms, 10.6MB)
테스트 19 〉	통과 (0.05ms, 10.4MB)
테스트 20 〉	실패 (0.04ms, 10.6MB)
테스트 21 〉	실패 (0.05ms, 10.5MB)
테스트 22 〉	실패 (0.04ms, 10.4MB)
테스트 23 〉	통과 (0.04ms, 10.3MB)
테스트 24 〉	통과 (0.05ms, 10.4MB)
테스트 25 〉	통과 (0.06ms, 10.4MB)

• 근데... 어랏?
  • 야... 이거? 이거!?!?!? 이거...
    • 키메라 전략 간다. ㅋㅋㅋ

• 키메라 코딩 전략 = 통과하는 코드 2개를 합쳐서 정답을 출력하는 알고리즘을 만드는 것을 말함.
  • 아... 젠장!
    • 21번은 A,B 둘다 통과 못 했네?
• 젠장!

import itertools

def solution(n, info):
    nn = n
    arrow_n_score = [] #공격
    arrow_n_score2 = [] #방어
    ryan_arrow = [0 for i in range(11)]
    ryan_arrow2 = [0 for i in range(11)]
    for i in range(len(info)):
        점수위치 = i
        필요화살 = info[i]+1 #이기려면 필요한 화살
        점수효율1 = (10-i)/필요화살
        점수효율2 = (10-i)/필요화살
        if info[i] > 0:
            점수효율1 += 10-i
            점수효율2 *= 2
        arrow_n_score.append([점수위치, 점수효율1, 필요화살])
        arrow_n_score2.append([점수위치, 점수효율2, 필요화살])
        
    arrow_n_score.sort(key=lambda x:(-x[1],x[2]))
    index = 0
    while n > 0:
        if arrow_n_score[index][2] <= n:
            ryan_arrow[arrow_n_score[index][0]] = arrow_n_score[index][2]
            n -= arrow_n_score[index][2]
        else:
            if index == 10:
                ryan_arrow[arrow_n_score[10][0]] = n
                n = 0
        index += 1
        
    arrow_n_score2.sort(key=lambda x:(-x[1],x[2]))
    
    n = nn
    index = 0
    while n > 0:
        if arrow_n_score2[index][2] <= n:
            ryan_arrow2[arrow_n_score2[index][0]] = arrow_n_score2[index][2]
            n -= arrow_n_score2[index][2]
        else:
            if index == 10:
                ryan_arrow2[arrow_n_score2[10][0]] = n
                n = 0
        index += 1
        
    sum_info, sum_ryan = 0, 0
    for i in range(len(info)):
        if info[i] > ryan_arrow[i]:
            sum_info += 10-i
        elif info[i] < ryan_arrow[i]:
            sum_ryan += 10-i

    sum_info2, sum_ryan2 = 0, 0
    for i in range(len(info)):
        if info[i] > ryan_arrow2[i]:
            sum_info2 += 10-i
        elif info[i] < ryan_arrow2[i]:
            sum_ryan2 += 10-i
            
    arrow_n_score.sort(key=lambda x:(x[0]))
    arrow_n_score2.sort(key=lambda x:(x[0]))
    sum1 = sum_ryan - sum_info
    sum2 = sum_ryan2 - sum_info2
    #print(sum1, ryan_arrow)
    #print(sum2, ryan_arrow2)
    
    if sum_ryan2 <= sum_info2 and sum_ryan <= sum_info: # 점수계산해서... 못 넘어가면 [-1] 리턴
        return [-1]
    elif sum_ryan2 - sum_info2 > sum_ryan - sum_info:
        return ryan_arrow2
    elif sum_ryan2 - sum_info2 < sum_ryan - sum_info:
        return ryan_arrow
    else:
        for i in reversed(range(len(info))):
            if ryan_arrow[i] > ryan_arrow2[i]:
                return ryan_arrow
            else:
                return ryan_arrow2
        return [0]
        
정확성  테스트
테스트 1 〉	통과 (0.03ms, 10.4MB)
테스트 2 〉	통과 (0.05ms, 10.4MB)
테스트 3 〉	통과 (0.05ms, 10.6MB)
테스트 4 〉	통과 (0.05ms, 10.3MB)
테스트 5 〉	통과 (0.03ms, 10.5MB)
테스트 6 〉	통과 (0.03ms, 10.4MB)
테스트 7 〉	통과 (0.04ms, 10.5MB)
테스트 8 〉	통과 (0.04ms, 10.4MB)
테스트 9 〉	통과 (0.03ms, 10.4MB)
테스트 10 〉	통과 (0.04ms, 10.6MB)
테스트 11 〉	통과 (0.03ms, 10.4MB)
테스트 12 〉	통과 (0.03ms, 10.5MB)
테스트 13 〉	통과 (0.03ms, 10.4MB)
테스트 14 〉	통과 (0.03ms, 10.5MB)
테스트 15 〉	통과 (0.03ms, 10.5MB)
테스트 16 〉	통과 (0.05ms, 10.5MB)
테스트 17 〉	통과 (0.03ms, 10.3MB)
테스트 18 〉	통과 (0.03ms, 10.2MB)
테스트 19 〉	통과 (0.04ms, 10.6MB)
테스트 20 〉	통과 (0.05ms, 10.4MB)
테스트 21 〉	실패 (0.03ms, 10.4MB)
테스트 22 〉	통과 (0.03ms, 10.4MB)
테스트 23 〉	통과 (0.04ms, 10.5MB)
테스트 24 〉	통과 (0.05ms, 10.5MB)
테스트 25 〉	통과 (0.05ms, 10.4MB)

• 테스트 케이스 21번 뭐냐???
  • 살려줘요. ㅠ.ㅠ
    • 아.. 왜 21번 실패한 걸 못 봤지?
      • 시간만 낭비했네...
• 리얼 멍청이의 재도전.
  • 스타트!
    • 화살 효율 + 공격 / 방어 구분 해서 하나의 리스트로 관리
      • 이상하다... ㅠ.ㅠ
• 문제에 가장 큰 점수 차이로 우승...인데... 이 문제는 포기다.

• 이 문제는 잘 모르겠다.
  • 진짜 카카오랑 나랑은 안맞는 듯... ㅡ.ㅡ;;;
    • 나중에 테스트 케이스 1번 답이 왜 6점 차이로 이기는 게 정답인지 듣고 나서 다시 도전하기로...
• 일주일이 지났고, 나는 내가 주화입마에 빠져있었다는 사실을 알게 되었다.
  • 분명히 처음 짠 코드에는 이렇게 되어 있었는데...
  • 새로 짜면서 이런 부분을 까먹어버렸다.
    • 만약, k(k는 1~10사이의 자연수)점을 어피치가 a발을 맞혔고 라이언이 b발을 맞혔을 경우
    • 더 많은 화살을 k점에 맞힌 선수가 k 점을 가져갑니다.
    • 단, a = b일 경우는 어피치가 k점을 가져갑니다.
    • k점을 여러 발 맞혀도 k점 보다 많은 점수를 가져가는 게 아니고 k점만 가져가는 것을 유의하세요.
    • 또한 a = b = 0 인 경우, 즉, 라이언과 어피치 모두 k점에 단 하나의 화살도 맞히지 못한 경우는 어느 누구도 k점을 가져가지 않습니다.

import itertools

def solution(n, info):
    arrow_n_score = [] # 명령 우선 순위
    ryan_arrow = [0 for i in range(11)]
    
    for i in range(11):
        점수위치 = i
        필요화살 = info[i] # 상대 점수를 무력화 시키려면 필요한 화살
        if 필요화살 == 0:
            arrow_n_score.append([점수위치, 10-i, 1, "무혈입성"])
        else:
            #점수효율 = (10-i)/필요화살
            #arrow_n_score.append([점수위치, 점수효율, 필요화살, "무력화"])  #무력화가 아니라 어피치가 점수를 가져감.
            점수효율 = ((10-i)+(10-i)/(필요화살+1) + 2*(10-i)/(필요화살+1))/2
            arrow_n_score.append([점수위치, 점수효율, 필요화살+1, "빼앗기"])
        
    arrow_n_score.sort(key=lambda x:(-x[1],x[2],-x[0]))
    
    index = 0
    while n > 0 and len(arrow_n_score) > index:
        print("스타트:",arrow_n_score)
        print(ryan_arrow)
        arrows = arrow_n_score[index][2]
        points = arrow_n_score[index][0]
        if arrows <= n:
            ryan_arrow[points] = arrows
            n -= arrows
            for i in range(len(arrow_n_score)):
                if arrow_n_score[i][0] == points:
                    arrow_n_score.pop(i)
                    arrow_n_score.insert(0,[])
            arrow_n_score= [a for a in arrow_n_score if len(a) != 0]
            index = 0
        else:
            index += 1
        print(ryan_arrow)
        
    if n > 0:
        ryan_arrow[10] = n
    
    sum_info, sum_ryan = 0, 0
    for i in range(11):
        if info[i] > ryan_arrow[i]:
            sum_info += 10-i
        elif info[i] < ryan_arrow[i]:
            sum_ryan += 10-i
            
    arrow_n_score.sort(key=lambda x:(x[0]))
    sum1 = sum_ryan - sum_info
    print(sum_info, info)
    print(sum_ryan, ryan_arrow)
    
    if sum_ryan <= sum_info: # 점수계산해서... 못 넘어가면 [-1] 리턴
        return [-1]
    else:
        return ryan_arrow

• 될 거 같기동? ㅋㅋㅋ

import itertools

def solution(n, info):
    arrow_n_score = [] # 명령 우선 순위
    arrow_n_score2 = []
    arrow_n_score3 = []
    ryan_arrow = [0 for i in range(11)]
    ryan_arrow2 = [0 for i in range(11)]
    ryan_arrow3 = [0 for i in range(11)]
    
    for i in range(11):
        점수위치 = i
        필요화살 = info[i] # 상대 점수를 무력화 시키려면 필요한 화살
        if 필요화살 == 0:
            arrow_n_score.append([점수위치, 10-i, 1]) #, "무혈입성"
        else:
            점수효율 = (10-i)/필요화살 * 2
            arrow_n_score.append([점수위치, -점수효율, 필요화살, "무쓸모"])  #무력화가 아니라 어피치가 점수를 가져감. 무쓸모
            점수효율 = (10-i)/필요화살 + (10-i)/(필요화살+1)
            arrow_n_score.append([점수위치, 점수효율, 필요화살+1]) #, "빼앗기"
            점수효율2 = (10-i)/필요화살 + (10-i)
            arrow_n_score2.append([점수위치, 점수효율, 필요화살+1]) #, "베리에이션2"
            점수효율3 = 2 * (10-i)/필요화살
            arrow_n_score3.append([점수위치, 점수효율, 필요화살+1]) #, "베리에이션3"
            
    arrow_n_score.sort(key=lambda x:(-x[1],x[2],-x[0]))
    arrow_n_score2.sort(key=lambda x:(-x[1],x[2],-x[0]))
    arrow_n_score3.sort(key=lambda x:(-x[1],x[2],-x[0]))
    n2 = n
    n3 = n
    
    index = 0
    while n > 0 and len(arrow_n_score) > index:
        arrows = arrow_n_score[index][2]
        points = arrow_n_score[index][0]
        if arrows <= n:
            ryan_arrow[points] = arrows
            n -= arrows
            for i in range(len(arrow_n_score)):
                if arrow_n_score[i][0] == points:
                    arrow_n_score.pop(i)
                    arrow_n_score.insert(0,[])
            arrow_n_score= [a for a in arrow_n_score if len(a) != 0]
            index = 0
        else:
            index += 1
    if n > 0:
        ryan_arrow[10] = n

    index = 0
    while n2 > 0 and len(arrow_n_score2) > index:
        arrows2 = arrow_n_score2[index][2]
        points2 = arrow_n_score2[index][0]
        if arrows2 <= n2:
            ryan_arrow2[points] = arrows2
            n2 -= arrows2
            for i in range(len(arrow_n_score2)):
                if arrow_n_score2[i][0] == points2:
                    arrow_n_score2.pop(i)
                    arrow_n_score2.insert(0,[])
            arrow_n_score2= [a for a in arrow_n_score2 if len(a) != 0]
            index = 0
        else:
            index += 1
    if n2 > 0:
        ryan_arrow2[10] = n2


    index = 0
    while n3 > 0 and len(arrow_n_score3) > index:
        arrows3 = arrow_n_score3[index][2]
        points3 = arrow_n_score3[index][0]
        if arrows3 <= n3:
            ryan_arrow3[points] = arrows3
            n3 -= arrows3
            for i in range(len(arrow_n_score3)):
                if arrow_n_score3[i][0] == points3:
                    arrow_n_score3.pop(i)
                    arrow_n_score3.insert(0,[])
            arrow_n_score3= [a for a in arrow_n_score3 if len(a) != 0]
            index = 0
        else:
            index += 1
    if n3 > 0:
        ryan_arrow3[10] = n3
    
    sum_info1, sum_ryan1 = 0, 0
    for i in range(11):
        if info[i] > ryan_arrow[i]:
            sum_info1 += 10-i
        elif info[i] < ryan_arrow[i]:
            sum_ryan1 += 10-i
    sum1 = sum_ryan1 - sum_info1
    
    sum_info2, sum_ryan2 = 0, 0
    for i in range(11):
        if info[i] > ryan_arrow2[i]:
            sum_info2 += 10-i
        elif info[i] < ryan_arrow2[i]:
            sum_ryan2 += 10-i
    sum2 = sum_ryan2 - sum_info2
    
    sum_info3, sum_ryan3 = 0, 0
    for i in range(11):
        if info[i] > ryan_arrow3[i]:
            sum_info3 += 10-i
        elif info[i] < ryan_arrow3[i]:
            sum_ryan3 += 10-i
    sum3 = sum_ryan3 - sum_info3
    
    if sum_ryan1 <= sum_info1 and sum_ryan2 <= sum_info2 and sum_ryan3 <= sum_info3: # 점수계산해서... 못 넘어가면 [-1] 리턴
        return [-1]
    elif sum1 > sum2 and sum1 > sum3:
        return ryan_arrow
    elif sum2 > sum1 and sum2 > sum3:
        return ryan_arrow2
    elif sum3 > sum1 and sum3 > sum2:
        return ryan_arrow3
    else:
        for i in reversed(range(len(info))):
            if ryan_arrow[i] > ryan_arrow2[i] and ryan_arrow[i] > ryan_arrow3[i] :
                return ryan_arrow
            elif ryan_arrow2[i] > ryan_arrow[i] and ryan_arrow2[i] > ryan_arrow3[i] :
                return ryan_arrow2
            else:
                return ryan_arrow3
            return [0]

• 3개를 섞자!