🤖 옌지니어의 IT 기록 🤖

https://school.programmers.co.kr/learn/courses/30/lessons/250137

문제

문제 설명

어떤 게임에는 붕대 감기라는 기술이 있습니다.

붕대 감기는 t초 동안 붕대를 감으면서 1초마다 x만큼의 체력을 회복합니다. t초 연속으로 붕대를 감는 데 성공한다면 y만큼의 체력을 추가로 회복합니다. 게임 캐릭터에는 최대 체력이 존재해 현재 체력이 최대 체력보다 커지는 것은 불가능합니다.

기술을 쓰는 도중 몬스터에게 공격을 당하면 기술이 취소되고, 공격을 당하는 순간에는 체력을 회복할 수 없습니다. 몬스터에게 공격당해 기술이 취소당하거나 기술이 끝나면 그 즉시 붕대 감기를 다시 사용하며, 연속 성공 시간이 0으로 초기화됩니다.

몬스터의 공격을 받으면 정해진 피해량만큼 현재 체력이 줄어듭니다. 이때, 현재 체력이 0 이하가 되면 캐릭터가 죽으며 더 이상 체력을 회복할 수 없습니다.

당신은 붕대감기 기술의 정보, 캐릭터가 가진 최대 체력과 몬스터의 공격 패턴이 주어질 때 캐릭터가 끝까지 생존할 수 있는지 궁금합니다.

붕대 감기 기술의 시전 시간, 1초당 회복량, 추가 회복량을 담은 1차원 정수 배열 bandage와 최대 체력을 의미하는 정수 health, 몬스터의 공격 시간과 피해량을 담은 2차원 정수 배열 attacks가 매개변수로 주어집니다. 모든 공격이 끝난 직후 남은 체력을 return 하도록 solution 함수를 완성해 주세요. 만약 몬스터의 공격을 받고 캐릭터의 체력이 0 이하가 되어 죽는다면 -1을 return 해주세요.

제한 사항

• bandage는 [시전 시간, 초당 회복량, 추가 회복량] 형태의 길이가 3인 정수 배열입니다.
• 1 ≤ 시전 시간 = t ≤ 50
• 1 ≤ 초당 회복량 = x ≤ 100
• 1 ≤ 추가 회복량 = y ≤ 100
• 1 ≤ health ≤ 1,000
• 1 ≤ attacks의 길이 ≤ 100
• attacks[i]는 [공격 시간, 피해량] 형태의 길이가 2인 정수 배열입니다.
• attacks는 공격 시간을 기준으로 오름차순 정렬된 상태입니다.
• attacks의 공격 시간은 모두 다릅니다.
• 1 ≤ 공격 시간 ≤ 1,000
• 1 ≤ 피해량 ≤ 100

입출력 예

소스 코드

def solution(bandage, health, attacks):
    t, x, y = bandage
    max = health
    success = 0

    # 공격 당한 시간 구하기
    attack_times = []
    for attack in attacks:
        attack_times.append(attack[0])

    # 마지막 공격까지 생존여부 확인
    for now in range(1,attack_times[-1]+1):
        # 공격 당하면 체력감소 및 연속성공 초기화
        if now in attack_times:
            idx = attack_times.index(now)
            health -= attacks[idx][1]
            success = 0

            # 공격 당해서 체력이 바닥나는 경우
            if health <= 0:
                return -1
                break

        # 공격 당하지 않으면 붕대스킬
        else:
            # 체력이 최대치보다 작으면 회복 / 최대치이거나 크면 최대치로 초기화
            # 몬스터의 공격을 받지 않았으므로 연속 성공
            if health < max:
                health += x
            else:
                health = max

            success += 1
            if success == t:
                health += y
                success = 0    

    return health

풀이

• 붕대감기 스킬 리스트에서 시전 시간, 초당 회복량, 추가 회복량 설정
  • t = 시전 시간 (붕대감기 스킬의 최대 진행시간)
  • x = 초당 회복량 (1초동안 회복량)
  • y = 추가 회복량 (t시간만큼 붕대감기 스킬을 성공할 경우 추가 회복)
• 체력의 최대치 max, 연속성공 횟수 succes 설정
• 몬스터에게 공격당한 시간을 attack_times에 추가
• 마지막 공격시간까지 for문을 돌면서 공격여부 확인
  • 현재 시간이 공격당한 시간 attack_times에 있으면 체력감소 및 연속성공 초기화
    
    • 공격을 당해서 체력이 0보다 작아지면 -1을 리턴하고 종료
  • 공격당하지 않았으면 붕대감기로 체력 회복
    • 체력이 max보다 작으면 회복하고 max보다 크면 max로 초기화
    • 연속 성공했을 경우 추가 회복

조건이 많긴 한데 복잡하지는 않아서 하나씩 생각하면서 푸니까 의외로 금방 풀린 문제였다. 프로그래머스는 재미있는 문제 상황이 많아서 좋다..ㅎㅎ....

https://school.programmers.co.kr/learn/courses/30/lessons/172928

문제

문제 설명

지나다니는 길을 'O', 장애물을 'X'로 나타낸 직사각형 격자 모양의 공원에서 로봇 강아지가 산책을 하려합니다. 산책은 로봇 강아지에 미리 입력된 명령에 따라 진행하며, 명령은 다음과 같은 형식으로 주어집니다.

["방향 거리", "방향 거리" … ]
예를 들어 "E 5"는 로봇 강아지가 현재 위치에서 동쪽으로 5칸 이동했다는 의미입니다. 로봇 강아지는 명령을 수행하기 전에 다음 두 가지를 먼저 확인합니다.

주어진 방향으로 이동할 때 공원을 벗어나는지 확인합니다.
주어진 방향으로 이동 중 장애물을 만나는지 확인합니다.
위 두 가지중 어느 하나라도 해당된다면, 로봇 강아지는 해당 명령을 무시하고 다음 명령을 수행합니다.
공원의 가로 길이가 W, 세로 길이가 H라고 할 때, 공원의 좌측 상단의 좌표는 (0, 0), 우측 하단의 좌표는 (H - 1, W - 1) 입니다.

공원을 나타내는 문자열 배열 park, 로봇 강아지가 수행할 명령이 담긴 문자열 배열 routes가 매개변수로 주어질 때, 로봇 강아지가 모든 명령을 수행 후 놓인 위치를 [세로 방향 좌표, 가로 방향 좌표] 순으로 배열에 담아 return 하도록 solution 함수를 완성해주세요.

제한 사항

• 3 ≤ park의 길이 ≤ 50
  • 3 ≤ park[i]의 길이 ≤ 50
    • park[i]는 다음 문자들로 이루어져 있으며 시작지점은 하나만 주어집니다.
      • S : 시작 지점
      • O : 이동 가능한 통로
      • X : 장애물
  • park는 직사각형 모양입니다.
• 1 ≤ routes의 길이 ≤ 50
  • routes의 각 원소는 로봇 강아지가 수행할 명령어를 나타냅니다.
  • 로봇 강아지는 routes의 첫 번째 원소부터 순서대로 명령을 수행합니다.
  • routes의 원소는 "op n"과 같은 구조로 이루어져 있으며, op는 이동할 방향, n은 이동할 칸의 수를 의미합니다.
    • op는 다음 네 가지중 하나로 이루어져 있습니다.
      • N : 북쪽으로 주어진 칸만큼 이동합니다.
      • S : 남쪽으로 주어진 칸만큼 이동합니다.
      • W : 서쪽으로 주어진 칸만큼 이동합니다.
      • E : 동쪽으로 주어진 칸만큼 이동합니다.
    • 1 ≤ n ≤ 9

입출력 예

소스 코드

# 1
def solution(park, routes):
    # x = 열 번호 / y = 행 번호
    # 행열의 최대값 설정
    x_max = len(park[0])
    y_max = len(park)
    
    # 시작 위치 찾기
    x = 0
    y = 0
    for i in range(y_max):          # i = 행 번호 = y값
        for j in range(x_max):      # j = 열 번호 = x값
            if park[i][j] == 'S':
                x = j
                y = i
                break
    
    # 좌표 이동
    for route in routes:
        # 방향과 이동거리를 저장
        direction, distance = route.split(" ")

        # 현재의 좌표를 임시로 이동
        xx = x
        yy = y

        # 한 칸씩 이동하면서 공원을 벗어나거나 장애물을 만나는지 확인
        # step이 이동거리와 같아지면 현재 좌표를 임시 좌표로 변경
        for step in range(1, int(distance)+1):
            # 동쪽으로 이동
            if direction == 'E' and xx != x_max-1 and park[yy][xx+1] != 'X':
                xx += 1
                if step == int(distance):
                    x = xx
            # 서쪽으로 이동
            elif direction == 'W' and xx != 0 and park[yy][xx-1] != 'X':
                xx -= 1
                if step == int(distance):
                    x = xx
            # 남쪽으로 이동
            elif direction == 'S' and yy != y_max-1 and park[yy+1][xx] != 'X':
                yy += 1
                if step == int(distance):
                    y = yy
            # 북쪽으로 이동
            elif direction == 'N' and yy != 0 and park[yy-1][xx] != 'X':
                yy -= 1
                if step == int(distance):
                    y = yy

    return [y, x]

풀이 # 1

• 좌표에서 고려사항
  • x = 열 번호 / y = 행 번호
  • x_max = 열의 길이 / y_max = 행의 길이
• 시작 위치 찾기
  • i = 행 번호 = y값 / j = 열 번호 / x값
  • 위의 내용을 고려하여 시작점 S 찾기
• 좌표 이동
  • 띄어쓰기를 기준으로 앞의 값은 방향(direction), 뒤의 값은 이동거리(distance)
  • 현재 좌표와 동일한 임시 좌표를 만들어서 이동 (조건을 만족시키지 않을 경우 초기화하기 위해 필요)
    • 방향 확인
      • E = 동쪽 : x좌표 + 1
      • W = 서쪽 : x좌표 - 1
      • S = 남쪽 : y좌표 + 1
      • N = 북쪽 : y좌표 -1
    • 현재 좌표가 행이나 열의 길이를 벗어나는지 확인
    • 한 칸 이동했을 때 장애물이 있는지 확인
  • 각 조건을 모두 만족한 경우 임시 좌표를 한 칸 이동
  • step이 이동 거리에 도달하면 현재 좌표를 임시 좌표로 바꾸기
  • x는 열 번호, y는 행 번호이므로 [y,x] 를 반환

# 2
def solution(park, routes):
    # 행열의 최대값 설정
    w, h = len(park[0]), len(park)

    # 방향별로 이동해야하는 거리를 딕셔너리에 저장
    move = {"N":(-1,0), "S":(1,0), "W":(0,-1), "E":(0,1)}
    
    # 시작 위치 찾기
    x, y = 0, 0
    for i in range(h):
        for j in range(w):
            if park[i][j] == "S":
                x, y = i, j
                break
        
    # 좌표 이동
    for route in routes:
        # 방향과 이동거리를 저장
        direction, distance = route.split(" ")

        # 현재의 좌표를 저장해서 조건을 만족하지 못하면 해당값으로 초기화
        dx, dy = x, y
        
        for idx in range(int(distance)):
            # 이동할 위치
            nx = x + move[direction][0]
            ny = y + move[direction][1]
        
            if 0 <= nx <= h-1 and 0 <= ny <= w-1 and (park[nx][ny]!="X"):
                x, y = nx, ny                    
            else:
                x, y = dx, dy
                break

    return [x,y]

풀이 #2

• 위의 풀이와 반대로 x를 행 번호, y를 행 번호로 생각한 풀이
• 키가 이동 방향, 값이 이동해야하는 거리인 딕셔너리 생성
  • E = 동쪽 : y좌표 + 1
  • W = 서쪽 : y좌표 - 1
  • S = 남쪽 : x좌표 + 1
  • N = 북쪽 : x좌표 -1
• 시작 위치 찾기
• 현재 좌표를 dx, dy에 저장 (조건을 만족시키지 않을 경우 초기화하기 위해 필요)
• 임시 좌표 nx, ny를 만들어 모든 조건을 만족했을 경우에 현재 좌표를 변경

x좌표, y좌표 나오면 일단 헷갈리기 시작....다시 차근차근 생각해보겠다며 코드 12938091번 수정했는데 개인적으로 첫 번째 풀이가 좀 더 이해하기 쉬웠다. 두 번째 풀이는 속도가 조금 더 빠르지만 머리가 따라주지 않아서 힘들었다...휴...어쨌든 풀었으니까 쉬어야겠다.공원 산책을 왜이렇게 빡세게 하시는 거에요... 🏃🏻 🏃🏻

https://school.programmers.co.kr/learn/courses/30/lessons/136798

문제

문제 설명

숫자나라 기사단의 각 기사에게는 1번부터 number까지 번호가 지정되어 있습니다. 기사들은 무기점에서 무기를 구매하려고 합니다.

각 기사는 자신의 기사 번호의 약수 개수에 해당하는 공격력을 가진 무기를 구매하려 합니다. 단, 이웃나라와의 협약에 의해 공격력의 제한수치를 정하고, 제한수치보다 큰 공격력을 가진 무기를 구매해야 하는 기사는 협약기관에서 정한 공격력을 가지는 무기를 구매해야 합니다.

예를 들어, 15번으로 지정된 기사단원은 15의 약수가 1, 3, 5, 15로 4개 이므로, 공격력이 4인 무기를 구매합니다. 만약, 이웃나라와의 협약으로 정해진 공격력의 제한수치가 3이고 제한수치를 초과한 기사가 사용할 무기의 공격력이 2라면, 15번으로 지정된 기사단원은 무기점에서 공격력이 2인 무기를 구매합니다. 무기를 만들 때, 무기의 공격력 1당 1kg의 철이 필요합니다. 그래서 무기점에서 무기를 모두 만들기 위해 필요한 철의 무게를 미리 계산하려 합니다.

기사단원의 수를 나타내는 정수 number와 이웃나라와 협약으로 정해진 공격력의 제한수치를 나타내는 정수 limit와 제한수치를 초과한 기사가 사용할 무기의 공격력을 나타내는 정수 power가 주어졌을 때, 무기점의 주인이 무기를 모두 만들기 위해 필요한 철의 무게를 return 하는 solution 함수를 완성하시오.

제한 사항

• 1 ≤ number ≤ 100,000
• 2 ≤ limit ≤ 100
• 1 ≤ power ≤ limit

입출력 예

소스 코드

# 1 (시간 초과)
def solution(number,limit,power):
    answer = 0
    knights = list(range(1,number+1))
    
    for knight in knights:
        cnt = 0
        for n in range(1,knight+1):
            if knight%n == 0:
                cnt += 1
        if cnt > limit:
            answer += power
        else:
            answer += cnt

    return answer

풀이 # 1

• knights 리스트에 각 기사들의 번호 담기
• knights 리스트를 돌면서 각 기사 번호의 약수 갯수를 cnt 변수에 넣기
  • cnt가 limit보다 크다면 정해진 power를 answer에 더하기
  • cnt가 limit보다 작다면 cnt를 answer에 더하기

# 2
def solution(number,limit,power):
    knights = list(range(1,number+1))
    knights_score = []
    
    for knight in knights:
        cnt = 0
        for n in range(1,int(knight**(1/2))+1):
            if knight%n == 0:
                cnt += 1
                if n**2 != knight: 
                    cnt += 1
            if cnt > limit:
                cnt = power
                break
        knights_score.append(cnt)

    return sum(knights_score)

풀이 #2

• knights 리스트에 각 기사들의 번호 담기
• knights 리스트를 돌면서 각 기사 번호의 약수 갯수를 cnt 변수에 넣기
  • 이 때, 기사 번호의 제곱근까지의 범위 사용 (약수는 짝이 있으므로 제곱근까지만 반복하여 이후에 제곱)
  • 약수의 갯수가 limit을 넘어가면 for문을 종료하여 연산의 수 줄이기
• knights_score 리스트에 각 기사의 점수를 입력
• knights_score의 합을 리턴

시간 복잡도 문제가 나왔는데요...? 제출하고 시간 초과 뜨니까 아찔해서 인생의 재미를 느낄 수 있었습니다. 첫 번째 풀이로 했을 때 테스트1에 3000ms 걸렸는데 두 번째 풀이로 하니까 50ms가 나왔다. 두 번째 풀이는 블로그 글을 참고했는데 설명을 잘해주셔서 이해가 잘 됐다.

https://school.programmers.co.kr/learn/courses/30/lessons/131128

문제

문제 설명

두 정수 X, Y의 임의의 자리에서 공통으로 나타나는 정수 k(0 ≤ k ≤ 9)들을 이용하여 만들 수 있는 가장 큰 정수를 두 수의 짝꿍이라 합니다(단, 공통으로 나타나는 정수 중 서로 짝지을 수 있는 숫자만 사용합니다). X, Y의 짝꿍이 존재하지 않으면, 짝꿍은 -1입니다. X, Y의 짝꿍이 0으로만 구성되어 있다면, 짝꿍은 0입니다.

예를 들어, X = 3403이고 Y = 13203이라면, X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 3, 0, 3으로 만들 수 있는 가장 큰 정수인 330입니다. 다른 예시로 X = 5525이고 Y = 1255이면 X와 Y의 짝꿍은 X와 Y에서 공통으로 나타나는 2, 5, 5로 만들 수 있는 가장 큰 정수인 552입니다(X에는 5가 3개, Y에는 5가 2개 나타나므로 남는 5 한 개는 짝 지을 수 없습니다.)
두 정수 X, Y가 주어졌을 때, X, Y의 짝꿍을 return하는 solution 함수를 완성해주세요.

제한 사항

• 3 ≤ X, Y의 길이(자릿수) ≤ 3,000,000입니다.
• X, Y는 0으로 시작하지 않습니다.
• X, Y의 짝꿍은 상당히 큰 정수일 수 있으므로, 문자열로 반환합니다.

입출력 예

소스 코드

# 1 (시간 초과)
def solution(X, Y):
    answer = ""

    inter = []

    for x in X:
        if x in Y:
            inter.append(int(x))
            Y = Y.replace(x,"",1)  

    inter.sort(reverse=True) 
    if len(inter) == 0:
        answer = "-1"
    elif inter[0] == 0:
        answer = "0"
    else:
        for i in inter:
            answer += str(i)
        
    return answer

풀이 # 1

• 교집합 원소를 담을 inter 리스트 생성
• X를 돌면서 X의 원소가 Y에 있으면 inter 리스트에 해당 원소 추가하고 Y에서 해당 원소 삭제
  • replace("바꾸기 전 문자", "바꾼 후의 문자", 바꾸고 싶은 문자 갯수)
• inter 를 내림차순으로 정렬
• inter가 없을 경우 "-1", 0이 여러개인 경우에는 "0"을 출력
• inter가 있고 0이 아니라면 리스트를 돌면서 문자를 answer에 추가

# 2
def solution(X, Y):
    answer = ""

    numberX = [0]*10
    numberY = [0]*10
    
    # 각 숫자가 몇 개씩 있는지 카운트
    for x in X:
        numberX[int(x)] += 1
    
    for y in Y:
        numberY[int(y)] += 1


    # 반복문을 돌면서 추가
    for idx in range(9,-1,-1):
        if numberX[idx] > 0 and numberY[idx] > 0:
            cnt = min(numberX[idx], numberY[idx])
            answer += (str(idx) * cnt)

    if answer == "":
        answer = "-1"
    elif answer[0] == "0":
        answer = "0"

        
    return answer

풀이 #2

• X와 Y의 각 숫자 갯수를 numberX와 numberY에 카운트 (각 숫자 = 인덱스)
• sort를 하지 않기 위해 가장 큰 수부터 반복문
  • numberX와 numberY에 둘 다 존재하면 둘 중에 작은 수만큼 answer에 추가
• 교집합이 없거나 0이 여러 개인 경우 처리

문제 자체는 단순한데 제한 사항을 보면 정수가 상당히 클 수도 있다는 조건이 있다. sort를 이용하면 시간이 오래 걸리므로 sort를 사용하지 않고 for문도 10개 숫자 내에서 돌도록 코드를 수정하였다. 통과는 했지만 시간이 적게 걸리는 것 같지는 않다. 시간 복잡도도 고려해서 코드를 짜는 게 중요한데....어렵구만...

https://school.programmers.co.kr/learn/courses/30/lessons/118666

문제

문제 설명

나만의 카카오 성격 유형 검사지를 만들려고 합니다.
성격 유형 검사는 다음과 같은 4개 지표로 성격 유형을 구분합니다. 성격은 각 지표에서 두 유형 중 하나로 결정됩니다.

4개의 지표가 있으므로 성격 유형은 총 16(=2 x 2 x 2 x 2)가지가 나올 수 있습니다. 예를 들어, "RFMN"이나 "TCMA"와 같은 성격 유형이 있습니다.

검사지에는 총 n개의 질문이 있고, 각 질문에는 아래와 같은 7개의 선택지가 있습니다.

• 매우 비동의
• 비동의
• 약간 비동의
• 모르겠음
• 약간 동의
• 동의
• 매우 동의

각 질문은 1가지 지표로 성격 유형 점수를 판단합니다.

예를 들어, 어떤 한 질문에서 4번 지표로 아래 표처럼 점수를 매길 수 있습니다.

이때 검사자가 질문에서 약간 동의 선택지를 선택할 경우 어피치형(A) 성격 유형 1점을 받게 됩니다. 만약 검사자가 매우 비동의 선택지를 선택할 경우 네오형(N) 성격 유형 3점을 받게 됩니다.

위 예시처럼 네오형이 비동의, 어피치형이 동의인 경우만 주어지지 않고, 질문에 따라 네오형이 동의, 어피치형이 비동의인 경우도 주어질 수 있습니다.
하지만 각 선택지는 고정적인 크기의 점수를 가지고 있습니다.

매우 동의나 매우 비동의 선택지를 선택하면 3점을 얻습니다.
동의나 비동의 선택지를 선택하면 2점을 얻습니다.
약간 동의나 약간 비동의 선택지를 선택하면 1점을 얻습니다.
모르겠음 선택지를 선택하면 점수를 얻지 않습니다.
검사 결과는 모든 질문의 성격 유형 점수를 더하여 각 지표에서 더 높은 점수를 받은 성격 유형이 검사자의 성격 유형이라고 판단합니다. 단, 하나의 지표에서 각 성격 유형 점수가 같으면, 두 성격 유형 중 사전 순으로 빠른 성격 유형을 검사자의 성격 유형이라고 판단합니다.

질문마다 판단하는 지표를 담은 1차원 문자열 배열 survey와 검사자가 각 질문마다 선택한 선택지를 담은 1차원 정수 배열 choices가 매개변수로 주어집니다. 이때, 검사자의 성격 유형 검사 결과를 지표 번호 순서대로 return 하도록 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ survey의 길이 ( = n) ≤ 1,000
• survey의 원소는 "RT", "TR", "FC", "CF", "MJ", "JM", "AN", "NA" 중 하나입니다.
• survey[i]의 첫 번째 캐릭터는 i+1번 질문의 비동의 관련 선택지를 선택하면 받는 성격 유형을 의미합니다.
• survey[i]의 두 번째 캐릭터는 i+1번 질문의 동의 관련 선택지를 선택하면 받는 성격 유형을 의미합니다.
• choices의 길이 = survey의 길이
• choices[i]는 검사자가 선택한 i+1번째 질문의 선택지를 의미합니다.
• 1 ≤ choices의 원소 ≤ 7

입출력 예

소스 코드

# 1
def solution(survey, choices):
    answer = ''

    types = [["R","T"],["C","F"],["J","M"],["A","N"]]
    scores = [[0,0],[0,0],[0,0],[0,0]]

    # survey 기반 점수 계산
    n = len(survey)
    for idx in range(n):
        front = survey[idx][0]
        back = survey[idx][1]
        if "R" in survey[idx]:
            if choices[idx] < 4:
                scores[0][types[0].index(front)] += (4-choices[idx])
            else:
                scores[0][types[0].index(back)] += (choices[idx]-4)
        elif "C" in survey[idx]:
            if choices[idx] < 4:
                scores[1][types[1].index(front)] += (4-choices[idx])
            else:
                scores[1][types[1].index(back)] += (choices[idx]-4)
        elif "J" in survey[idx]:
            if choices[idx] < 4:
                scores[2][types[2].index(front)] += (4-choices[idx])
            else:
                scores[2][types[2].index(back)] += (choices[idx]-4)
        elif "A" in survey[idx]:
            if choices[idx] < 4:
                scores[3][types[3].index(front)] += (4-choices[idx])
            else:
                scores[3][types[3].index(back)] += (choices[idx]-4)          



    # scores를 보고 점수가 높은 유형 출력 
    for idx in range(4):
        if scores[idx][0] >= scores[idx][1]:
            answer += types[idx][0]
        else:
            answer += types[idx][1]

    return answer

풀이 # 1

• 각 타입과 점수를 2차원 배열로 생성
• survey 길이만큼 인덱스를 돌면서 점수를 계산
  • survey에서 앞글자와 뒷글자를 구분
  • 어떤 글자를 포함하고 있는지 확인하고 socres에 점수 더하기
  • 점수가 4보다 작으면 앞글자의 인덱스에 4보다 크면 뒷글자의 인덱스에 점수 더하기
• 앞에서 계산한 scores를 돌면서 점수가 높은 값의 type을 answer로 출력

# 2
def solution(survey, choices):
    answer = ''

    scores = {"A":0, "N":0, "C":0, "F":0, "M":0, "J":0, "R":0, "T":0}
    for idx, choice in enumerate(choices):
        if choice - 4 > 0:
            scores[survey[idx][1]] += choice - 4
        elif choice - 4 < 0:
            scores[survey[idx][0]] += 4 - choice

    if scores["R"] >= scores["T"]:
        answer += "R"
    else:
        answer += "T"

    if scores["C"] >= scores["F"]:
        answer += "C"
    else:
        answer += "F"

    if scores["J"] >= scores["M"]:
        answer += "J"
    else:
        answer += "M"

    if scores["A"] >= scores["N"]:
        answer += "A"
    else:
        answer += "N"
    

    return answer

풀이 #2

• 딕셔너리의 키에 유형 값에 점수를 표기
• 점수가 4보다 작으면 앞글자의 인덱스에 4보다 크면 뒷글자의 인덱스에 점수 더하기
• RT, CF, JM, AN의 점수를 각각 비교해서 answer로 출력

# 3
def solution(survey, choices):
    types = {"RT":0,"CF":0,"JM":0,"AN":0}
    
    for A,B in zip(survey,choices):
        if A not in types.keys():
            A = A[::-1]
            types[A] -= B-4
        else:
            types[A] += B-4

    answer = ''    
    for name in types.keys():
        if types[name] > 0:
            answer += name[1]
        elif types[name] < 0:
            answer += name[0]
        else:
            answer += sorted(name)[0]

    return answer

풀이 #3

• 짝이 되는 유형끼리 딕셔너리의 키로 구성
• survey에 있는 문자가 딕셔너리의 키가 아닌 경우에 키를 역순으로 바꾸고 점수 빼기 (순서 변경 O)
  
  • 점수가 높으면 (점수-4)가 0보다 크므로 양수 = 뒤에 있는 문자에 점수 빼기
  • 점수가 낮으면 (점수-4)가 0보다 작으므로 음수 = 뒤에 있는 문자에 점수 더하기
• survey에 있는 문자가 딕셔너리의 키인 경우에는 그냥 점수 더하기 (순서 변경 X)
  • 점수가 높으면 (점수-4)가 0보다 크므로 양수 = 뒤에 있는 문자에 점수 더하기
  • 점수가 낮으면 (점수-4)가 0보다 작으므로 음수 = 뒤에 있는 문자에 점수 빼기
• 위의 방식대로 점수를 더하고 빼면 점수는 결국 키의 뒷 문자 기반
  • 점수가 0보다 크면 뒷 문자를 출력하고 0보다 작은면 앞 문자를 출력

문제에 대해 설명이 자세해서 이해는 잘 되었는데 코드를 구현하려니까 좀 복잡해졌다. 첫 번째 풀이는 점수가 4보다 작으면 앞에 있는 문자에 +3, 4보다 크면 뒤에 있는 문자에 +3이 되는 것을 이용해서 풀었다. 첫 번째 풀이 기반으로 딕셔너리를 이용해서 두 번째 풀이까지 만들었는데 다른 사람 풀이를 보다 보니 세 번째 풀이가 진짜 씽크빅이어서 추가했다....문자열을 바꾸면서 점수 더하기? 도대체 이런 생각은 어떻게 하시는거에요? 해석하기도 어려웠는데...천재 아니신가요...? 

https://school.programmers.co.kr/learn/courses/30/lessons/120840

문제

문제 설명

머쓱이는 구슬을 친구들에게 나누어주려고 합니다. 구슬은 모두 다르게 생겼습니다. 머쓱이가 갖고 있는 구슬의 개수 balls와 친구들에게 나누어 줄 구슬 개수 share이 매개변수로 주어질 때, balls개의 구슬 중 share개의 구슬을 고르는 가능한 모든 경우의 수를 return 하는 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ balls ≤ 30
• 1 ≤ share ≤ 30
• 구슬을 고르는 순서는 고려하지 않습니다.
• share ≤ balls

입출력 예

소스 코드

# 1 (런타임 에러)
def solution(balls, share):
    answer = 1
    
    ball_list = list(range(balls,1,-1))
    share_list = list(range(1,share+1))
    
    for idx in range(1,share+1):
        answer *= ball_list[idx-1]
        answer = int(answer/share_list[idx-1])
    
    
    return answer

풀이 # 1

• 공의 갯수에서 1씩 빼서 ball_list에 담고, 공유할 공의 갯수를 1부터 1씩 더해 share_list에 담기
• share 숫자 범위에서 ball_list의 원소는 곱하고 share_list의 원소는 나누기

# 2
def solution(balls, share):
    answer = 1
    cnt = 0

    while cnt < share:
        answer *= (balls-cnt)
        answer = int(answer/(cnt+1))
        cnt += 1    
    
    return answer

풀이 #2

• cnt가 share의 숫자보다 작을동안 곱하기와 나누기를 실행
  • balls-cnt를 곱하기
  • 위의 숫자에서 cnt+1을 나누기 

# 3
import math

def solution(balls, share):
    return math.comb(balls, share)

풀이 #3

• math 라이브러리에서 combination 함수 사용

처음에 숫자를 곱하고 나누는 방향으로 하다가 잘 안되길래 리스트로 풀어봤는데 역시나 런타임 에러가 났다. 그래서 숫자를 조작해서 while문에 넣었더니 결과는 나왔지만 뭔가 더 빠르게 나왔으면 좋겠다는 생각이 들었다. 다른 사람들의 풀이를 보다보니 math 라이브러리에 combination 함수가 있었다...라이브러리 함수 쓰는거 최고...!!

https://school.programmers.co.kr/learn/courses/30/lessons/120876

문제

문제 설명

선분 3개가 평행하게 놓여 있습니다. 세 선분의 시작과 끝 좌표가 [[start, end], [start, end], [start, end]] 형태로 들어있는 2차원 배열 lines가 매개변수로 주어질 때, 두 개 이상의 선분이 겹치는 부분의 길이를 return 하도록 solution 함수를 완성해보세요.

lines가 [[0, 2], [-3, -1], [-2, 1]]일 때 그림으로 나타내면 다음과 같습니다.

선분이 두 개 이상 겹친 곳은 [-2, -1], [0, 1]로 길이 2만큼 겹쳐있습니다.

제한 사항

• lines의 길이 = 3
• lines의 원소의 길이 = 2
• 모든 선분은 길이가 1 이상입니다.
• lines의 원소는 [a, b] 형태이며, a, b는 각각 선분의 양 끝점 입니다.
• -100 ≤ a < b ≤ 100

입출력 예

소스 코드

# 1
def solution(lines):
    answer = 0
    count = [0]*200
    
    starts = []
    ends = []

    for line in lines:
        start, end = line

        starts.append(start)
        ends.append(end)

        for num in range(start, end):
            count[num+100] += 1

    for cnt in count[100+min(starts):100+max(ends)+1]:
        if cnt > 1:
            answer += 1

    return answer

풀이 # 1

• 원소가 0인 길이 200의 리스트 count 생성
  • 선분이 점 (-100,100) 범위에 있으므로 길이가 200
• 각 선분의 시작 및 끝 좌표를 담을 starts / ends 리스트 생성
• linelist 돌기
  • 각 선분의 시작 및 끝 좌표 추가
  • 시작과 끝 좌표 사이 숫자에 +1 (count 리스트 범위가 -100~100이므로 인덱스에 +100)
• 시작 좌표 중 가장 작은 수와 끝 좌표 중 가장 큰 수 범위에서 count가 2보다 크면 선분이 겹치는 것이므로 +1

# 2
def solution(lines):
    s1 = set(i for i in range(lines[0][0], lines[0][1]))
    s2 = set(i for i in range(lines[1][0], lines[1][1]))
    s3 = set(i for i in range(lines[2][0], lines[2][1]))
    
    return len((s1 & s2) | (s2 & s3) | (s1 & s3))

풀이 #2

• 각 라인의 시작 좌표부터 끝 좌표까지의 숫자를 세트로 생성 (s1 / s2 / s3)
• 선분끼리의 교집합(&)들의 합집합(|) 길이를 출력

(-100,100) 범위를 만들어 놓는 걸 생각하지 못했었는데 범위를 만들고 나니 간단하게 풀 수 있는 문제였다. 굳이 시작과 끝 좌표의 min/max는 구하지 않아도 괜찮을 거 같다. 두 번째 풀이처럼 세트에서 합집합과 교집합을 이용하면 더 간단하게 풀 수 있는 문제인데...방법을 생각해 내는 게 항상 어렵다...

https://school.programmers.co.kr/learn/courses/30/lessons/120880

문제

문제 설명

정수 n을 기준으로 n과 가까운 수부터 정렬하려고 합니다. 이때 n으로부터의 거리가 같다면 더 큰 수를 앞에 오도록 배치합니다. 정수가 담긴 배열 numlist와 정수 n이 주어질 때 numlist의 원소를 n으로부터 가까운 순서대로 정렬한 배열을 return하도록 solution 함수를 완성해주세요.

제한 사항

• 1 ≤ n ≤ 10,000
• 1 ≤ numlist의 원소 ≤ 10,000
• 1 ≤ numlist의 길이 ≤ 100
• numlist는 중복된 원소를 갖지 않습니다.

입출력 예

소스 코드

# 1
def solution(numlist, n):
    # Key = 숫자 / Value = 차이
    num_diff = {}
    for num in numlist:
        num_diff[num] = abs(num-n)   

    rank = dict(sorted(num_diff.items(), key=lambda x:(x[1],-x[0])))
    
    return list(rank.keys())

풀이 # 1

• num_diff 라는 딕셔너리 생성
  • Key값에 numlist의 숫자 / Value값에 numlist 숫자와 n의 차이 입력
• rank라는 딕셔너리 생성
  • num_diff의 Value(= numlist 숫자와 n의 차이) 기준 오름차순 정렬 → x[1]
  • Value가 같다면 Key가 큰 값 먼저 오도록 내림차순 정렬 → -x[0]
• 정렬된 rank 딕셔너리의 Key값(=numlist의 숫자) 출력

# 2
def solution(numlist, n):
    numlist.sort(key=lambda x:(abs(n-x), -x))
    return numlist

풀이 #2

• numlist 숫자와 n의 차이 오름차순 / numlist 숫자 내림차순으로 정렬
• 정렬된 numlist 출력

첫 번째 풀이는 '차이값 만들기 → 차이값과 숫자를 딕셔너리에 넣기 → 차이값 기준으로 정렬하기 → 정렬된 딕셔너리에서 키 값 출력하기' 의 과정을 거치고 두 번째 풀이는 '차이값 기준으로 정렬하기'가 끝이다. 원리?는 같지만 얼마나 간결하게 표현하는지에 따라서 코드가 좀 더 깔끔해지는 것 같다. 문제를 많이 풀어봐야겠다고 3928490번째 다짐하는 중이다.