IT-garden

문제 설명

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다.
전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

• 구조대 : 119
• 박준영 : 97 674 223
• 지영석 : 11 9552 4421

전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

제한조건

• phone_book의 길이는 1 이상 1,000,000 이하입니다.
• 각 전화번호의 길이는 1 이상 20 이하입니다.

입출력 예

입출력 예 설명

입출력 예 #1
앞에서 설명한 예와 같습니다.

입출력 예 #2
한 번호가 다른 번호의 접두사인 경우가 없으므로, 답은 true입니다.

입출력 예 #3
첫 번째 전화번호, “12”가 두 번째 전화번호 “123”의 접두사입니다. 따라서 답은 false입니다.

나의 풀이

def solution(phone_book):
    answer = True
    for i in range(len(phone_book)):
        a = phone_book[:i] + phone_book[i+1:] 
        for j in a:
            jj = j[:len(phone_book[i])]
            if phone_book[i] == jj:
                answer = False
                break
        if answer == False:
            break
    return answer

1. 전화번호부에 적힌 전화번호를 하나씩 기준으로 삼아 다른 번호의 접두어인 경우가 있는지 확인합니다.
2. 하나라도 접두어인 경우가 있으면 반복문을 나오고 False를 출력합니다.

다른 사람의 풀이

def solution(phoneBook):
    phoneBook = sorted(phoneBook)

    for p1, p2 in zip(phoneBook, phoneBook[1:]):
        if p2.startswith(p1):
            return False
    return True

전화번호부를 정렬하고 기준인 번호보다 뒤에 있는 전화번호부만 확인합니다.
뒤에 있는 전화번호가 기준인 번호로 시작하면 False를 리턴합니다.

프로그래머스 '전화번호 목록' : https://programmers.co.kr/learn/courses/30/lessons/42577

문제 설명

초 단위로 기록된 주식가격이 담긴 배열 prices가 매개변수로 주어질 때, 가격이 떨어지지 않은 기간은 몇 초인지를 return 하도록 solution 함수를 완성하세요.

제한조건

• prices의 각 가격은 1 이상 10,000 이하인 자연수입니다.
• prices의 길이는 2 이상 100,000 이하입니다.

입출력 예

입출력 예 설명

• 1초 시점의 ₩1은 끝까지 가격이 떨어지지 않았습니다.
• 2초 시점의 ₩2은 끝까지 가격이 떨어지지 않았습니다.
• 3초 시점의 ₩3은 1초뒤에 가격이 떨어집니다. 따라서 1초간 가격이 떨어지지 않은 것으로 봅니다.
• 4초 시점의 ₩2은 1초간 가격이 떨어지지 않았습니다.
• 5초 시점의 ₩3은 0초간 가격이 떨어지지 않았습니다.

나의 풀이

def solution(prices):
    answer = [0] * len(prices)
    for i in range(len(prices)):
        c=0
        for j in range(i+1,len(prices)):
            c += 1
            if prices[i] > prices[j]:
                break
        answer[i] = c      
    return answer

1. 리스트 prices의 각 원소들을 기준으로 잡고 뒤의 값들과 비교합니다.
2. 만약 앞에 있는 값이 뒤에 있는 값보다 크면 for문을 나와 개수를 리스트 answer에 넣습니다.
3. 마지막에 리스트 answer를 리턴합니다.

프로그래머스 '주식가격' : programmers.co.kr/learn/courses/30/lessons/42584

문제 설명

프로그래머스 팀에서는 기능 개선 작업을 수행 중입니다. 각 기능은 진도가 100%일 때 서비스에 반영할 수 있습니다.

또, 각 기능의 개발속도는 모두 다르기 때문에 뒤에 있는 기능이 앞에 있는 기능보다 먼저 개발될 수 있고, 이때 뒤에 있는 기능은 앞에 있는 기능이 배포될 때 함께 배포됩니다.

먼저 배포되어야 하는 순서대로 작업의 진도가 적힌 정수 배열 progresses와 각 작업의 개발 속도가 적힌 정수 배열 speeds가 주어질 때 각 배포마다 몇 개의 기능이 배포되는지를 return 하도록 solution 함수를 완성하세요.

제한조건

• 작업의 개수(progresses, speeds배열의 길이)는 100개 이하입니다.
• 작업 진도는 100 미만의 자연수입니다.
• 작업 속도는 100 이하의 자연수입니다.
• 배포는 하루에 한 번만 할 수 있으며, 하루의 끝에 이루어진다고 가정합니다. 예를 들어 진도율이 95%인 작업의 개발 속도가 하루에 4%라면 배포는 2일 뒤에 이루어집니다.

입출력 예

입출력 예 설명

첫 번째 기능은 93% 완료되어 있고 하루에 1%씩 작업이 가능하므로 7일간 작업 후 배포가 가능합니다.
두 번째 기능은 30%가 완료되어 있고 하루에 30%씩 작업이 가능하므로 3일간 작업 후 배포가 가능합니다. 하지만 이전 첫 번째 기능이 아직 완성된 상태가 아니기 때문에 첫 번째 기능이 배포되는 7일째 배포됩니다.
세 번째 기능은 55%가 완료되어 있고 하루에 5%씩 작업이 가능하므로 9일간 작업 후 배포가 가능합니다.

따라서 7일째에 2개의 기능, 9일째에 1개의 기능이 배포됩니다.

나의 풀이

def solution(progresses, speeds):
    c = 0
    answer = [0] * len(progresses)
    while True:
        c += 1
        for i in range(len(progresses)):
            if progresses[i] < 100:
                progresses[i] += speeds[i]
            if progresses[i] >= 100 and speeds[i] != 0:
                progresses[i] = 100
                speeds[i] = 0
                answer[i] = c
        if 0 not in answer:
            break
    
    k = answer[0]
    cou = 1
    r = []
    for i in range(1,len(answer)):
        if k >= answer[i]:
            cou += 1
        else:
            r.append(cou)
            cou = 1
            k = answer[i]
    r.append(cou) 
    return r

1. progresses에 각 작업의 개발 속도를 더해줍니다.
2. progresses의 요소가 완료되면 걸린 날을 리스트 answer에 넣습니다.
3. 1, 2과정을 모든 작업이 완료될때까지 합니다.
4. 한번에 몇 개의 기능이 배포되는지 확인해 리스트 r을 리턴합니다.

프로그래머스 '기능개발' : programmers.co.kr/learn/courses/30/lessons/42586

문제 설명

선행 스킬이란 어떤 스킬을 배우기 전에 먼저 배워야 하는 스킬을 뜻합니다.

예를 들어 선행 스킬 순서가 스파크 → 라이트닝 볼트 → 썬더일때, 썬더를 배우려면 먼저 라이트닝 볼트를 배워야 하고, 라이트닝 볼트를 배우려면 먼저 스파크를 배워야 합니다.

위 순서에 없는 다른 스킬(힐링 등)은 순서에 상관없이 배울 수 있습니다. 따라서 스파크 → 힐링 → 라이트닝 볼트 → 썬더와 같은 스킬트리는 가능하지만, 썬더 → 스파크나 라이트닝 볼트 → 스파크 → 힐링 → 썬더와 같은 스킬트리는 불가능합니다.

선행 스킬 순서 skill과 유저들이 만든 스킬트리1를 담은 배열 skill_trees가 매개변수로 주어질 때, 가능한 스킬트리 개수를 return 하는 solution 함수를 작성해주세요.

제한조건

• 스킬은 알파벳 대문자로 표기하며, 모든 문자열은 알파벳 대문자로만 이루어져 있습니다.
• 스킬 순서와 스킬트리는 문자열로 표기합니다.
  • 예를 들어, C → B → D 라면 CBD로 표기합니다
• 선행 스킬 순서 skill의 길이는 1 이상 26 이하이며, 스킬은 중복해 주어지지 않습니다.
• skill_trees는 길이 1 이상 20 이하인 배열입니다.
• skill_trees의 원소는 스킬을 나타내는 문자열입니다.
  • skill_trees의 원소는 길이가 2 이상 26 이하인 문자열이며, 스킬이 중복해 주어지지 않습니다.

입출력 예

입출력 예 설명

• BACDE: B 스킬을 배우기 전에 C 스킬을 먼저 배워야 합니다. 불가능한 스킬트립니다.
• CBADF: 가능한 스킬트리입니다.
• AECB: 가능한 스킬트리입니다.
• BDA: B 스킬을 배우기 전에 C 스킬을 먼저 배워야 합니다. 불가능한 스킬트리입니다.

나의 풀이

def solution(skill, skill_trees):
    answer = 0
    skill=list(skill)

    for i in skill_trees:
        a = [-1] * len(skill)
        tree=list(i)
        
        for j, v in enumerate(skill):
            if v in tree:
                a[j]=tree.index(v)

        if sum(a) == (-1)*len(a): # 아무것도 속하지 않는 경우
            answer += 1
            continue    
        if a[0] == -1:
            continue
                            
        while True:
            if a[-1] == -1:
                a.pop()
            else:
                break
            
        b=sorted(a)
        a=list(filter((-1).__ne__ ,a))
        if a == b:
            answer += 1
        
    return answer

1. 스킬을 리스트로 만들고 스킬트리의 값들을 하나씩 리스트로 만듭니다.

2. 스킬에 있는 값이 스킬트리에 있는지 확인하고 있다면 스킬트리에서의 위치를 리스트 a에 넣습니다.

3. 스킬트리에 스킬의 값이 하나도 없다면 스킬트리가 가능한 경우이기 때문에 가능한 스킬트리의 개수 answer를 1 올려줍니다.

4. 스킬트리에 첫번째 스킬이 있어야 스킬트리가 될 가능성이 있기 때문에 첫번째 스킬트리가 있는지 확인합니다.

5. 리스트 a의 마지막 요소가 -1이면 -1을 전부 지워줍니다. 해당 위치의 스킬이 없는것으로 생각합니다.

6. 그 후 정렬한 리스트와 리스트 a에서 -1을 제거한 것을 비교합니다. (-1을 제거한 이유는 중간에 -1이 있다면 해당 스킬을 배우지 않은 것으로 간주하기 때문입니다.)

7. 두 리스트가 같으면 스킬트리의 개수 answer에 1 올려줍니다.

8. 위의 과정들을 반복한 뒤 answer를 리턴합니다.

다른 사람의 풀이

def solution(skill, skill_trees):
    answer = 0

    for skills in skill_trees:
        skill_list = list(skill)

        for s in skills:
            if s in skill:
                if s != skill_list.pop(0):
                    break
        else:
            answer += 1

    return answer

프로그래머스 '스킬트리' : programmers.co.kr/learn/courses/30/lessons/49993

문제 설명

다트 게임

카카오톡에 뜬 네 번째 별! 심심할 땐? 카카오톡 게임별~

카카오톡 게임별의 하반기 신규 서비스로 다트 게임을 출시하기로 했다. 다트 게임은 다트판에 다트를 세 차례 던져 그 점수의 합계로 실력을 겨루는 게임으로, 모두가 간단히 즐길 수 있다.

갓 입사한 무지는 코딩 실력을 인정받아 게임의 핵심 부분인 점수 계산 로직을 맡게 되었다. 다트 게임의 점수 계산 로직은 아래와 같다.

1. 다트 게임은 총 3번의 기회로 구성된다.
2. 각 기회마다 얻을 수 있는 점수는 0점에서 10점까지이다.
3. 점수와 함께 Single(S), Double(D), Triple(T) 영역이 존재하고 각 영역 당첨 시 점수에서 1제곱, 2제곱, 3제곱 (점수1 , 점수2 , 점수3 )으로 계산된다.
4. 옵션으로 스타상(*) , 아차상(#)이 존재하며 스타상(*) 당첨 시 해당 점수와 바로 전에 얻은 점수를 각 2배로 만든다. 아차상(#) 당첨 시 해당 점수는 마이너스된다.
5. 스타상(*)은 첫 번째 기회에서도 나올 수 있다. 이 경우 첫 번째 스타상(*)의 점수만 2배가 된다. (예제 4번 참고)
6. 스타상(*)의 효과는 다른 스타상(*)의 효과와 중첩될 수 있다. 이 경우 중첩된 스타상(*) 점수는 4배가 된다. (예제 4번 참고)
7. 스타상(*)의 효과는 아차상(#)의 효과와 중첩될 수 있다. 이 경우 중첩된 아차상(#)의 점수는 -2배가 된다. (예제 5번 참고)
8. Single(S), Double(D), Triple(T)은 점수마다 하나씩 존재한다.
9. 스타상(*), 아차상(#)은 점수마다 둘 중 하나만 존재할 수 있으며, 존재하지 않을 수도 있다.

0~10의 정수와 문자 S, D, T, *, #로 구성된 문자열이 입력될 시 총점수를 반환하는 함수를 작성하라.

입력 형식

점수|보너스|[옵션]으로 이루어진 문자열 3세트.
예) 1S2D*3T

• 점수는 0에서 10 사이의 정수이다.
• 보너스는 S, D, T 중 하나이다.
• 옵선은 *이나 # 중 하나이며, 없을 수도 있다.

출력 형식

3번의 기회에서 얻은 점수 합계에 해당하는 정수값을 출력한다.
예) 37

입출력 예

나의 풀이

def solution(dartResult):
    bb=list(dartResult)
    answer=[]
    d=[]
    for i in range(len(bb)):    
        if bb[i] == '1' and bb[i+1] == '0':
            d.append('10')
        elif bb[i] == '0' and bb[i-1] =='1':
            continue
        else:
            
            d.append(bb[i])

    for i in range(1,len(d)):
        if d[i] == 'S':
            answer.append(int(d[i-1]))
        elif d[i] == 'D':
            answer.append(int(d[i-1])**2)
        elif d[i] == 'T':
            answer.append(int(d[i-1])**3)

        if d[i] == '*':
            if len(answer) >= 2:
                answer[-1]=answer[-1]*2
                answer[-2]=answer[-2]*2
            else:
                answer[-1]=answer[-1]*2
        elif d[i] == '#':
            answer[-1]=answer[-1]*(-1)
        
    return sum(answer)

1. dartResult를 리스트 bb로 만들어 각 자리의 숫자를 비교합니다.
2. 리스트 bb의 앞 뒤 요소가 1, 0로 분리되어 있으면 10으로 합쳐 리스트 d에 넣습니다.
이 외의 문자는 그대로 리스트 d에 넣습니다.
3. 리스트 d[i]가 'S'인 경우 1배, 'D'인 경우 2배, 'T'인 경우 3배를 d[i-1]에 적용해 리스트 answer에 넣습니다.
4. 리스트 d[i]가 스타상 '*'인 경우 해당 점수와 바로 전에 얻은 점수를 각 2배로 만듭니다.
리스트 d[i]가 아차상 '#'인 경우 해당 점수에 -1배로 만듭니다.

5. 리스트 answer의 합을 구해 리턴합니다.

프로그래머스 '[1차] 다트 게임' : https://programmers.co.kr/learn/courses/30/lessons/17682

문제 설명

실패율

슈퍼 게임 개발자 오렐리는 큰 고민에 빠졌다. 그녀가 만든 프랜즈 오천성이 대성공을 거뒀지만, 요즘 신규 사용자의 수가 급감한 것이다. 원인은 신규 사용자와 기존 사용자 사이에 스테이지 차이가 너무 큰 것이 문제였다.

이 문제를 어떻게 할까 고민 한 그녀는 동적으로 게임 시간을 늘려서 난이도를 조절하기로 했다. 역시 슈퍼 개발자라 대부분의 로직은 쉽게 구현했지만, 실패율을 구하는 부분에서 위기에 빠지고 말았다. 오렐리를 위해 실패율을 구하는 코드를 완성하라.

• 실패율은 다음과 같이 정의한다.
  • 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수 / 스테이지에 도달한 플레이어 수

전체 스테이지의 개수 N, 게임을 이용하는 사용자가 현재 멈춰있는 스테이지의 번호가 담긴 배열 stages가 매개변수로 주어질 때, 실패율이 높은 스테이지부터 내림차순으로 스테이지의 번호가 담겨있는 배열을 return 하도록 solution 함수를 완성하라.

제한조건

• 스테이지의 개수 N은 1 이상 500 이하의 자연수이다.
• stages의 길이는 1 이상 200,000 이하이다.
• stages에는 1 이상 N + 1 이하의 자연수가 담겨있다.
  • 각 자연수는 사용자가 현재 도전 중인 스테이지의 번호를 나타낸다.
  • 단, N + 1 은 마지막 스테이지(N 번째 스테이지) 까지 클리어 한 사용자를 나타낸다.
• 만약 실패율이 같은 스테이지가 있다면 작은 번호의 스테이지가 먼저 오도록 하면 된다.
• 스테이지에 도달한 유저가 없는 경우 해당 스테이지의 실패율은 0 으로 정의한다.

입출력 예

입출력 예 설명

입출력 예 #1
1번 스테이지에는 총 8명의 사용자가 도전했으며, 이 중 1명의 사용자가 아직 클리어하지 못했다. 따라서 1번 스테이지의 실패율은 다음과 같다.

• 1 번 스테이지 실패율 : 1/8

2번 스테이지에는 총 7명의 사용자가 도전했으며, 이 중 3명의 사용자가 아직 클리어하지 못했다. 따라서 2번 스테이지의 실패율은 다음과 같다.

• 2 번 스테이지 실패율 : 3/7

마찬가지로 나머지 스테이지의 실패율은 다음과 같다.

• 3 번 스테이지 실패율 : 2/4
• 4번 스테이지 실패율 : 1/2
• 5번 스테이지 실패율 : 0/1

각 스테이지의 번호를 실패율의 내림차순으로 정렬하면 다음과 같다.

• [3,4,2,1,5]

입출력 예 #2

모든 사용자가 마지막 스테이지에 있으므로 4번 스테이지의 실패율은 1이며 나머지 스테이지의 실패율은 0이다.

• [4,1,2,3]

나의 풀이

def solution(N, stages):
    k=len(stages)
    s=[]
    for i in range(1,N+1):
        c=0
        for j in range(len(stages)):
            if stages[j] == i:
                c += 1
        if c == 0:
            s.append(0)
        else:
            s.append(c/k)
        k =k- c

    a=sorted(s,reverse=True)
    answer=[]

    for i in range(len(a)):
        answer.append(s.index(a[i])+1)
        s[s.index(a[i])]=2

    return answer

1. 각 스테이지마다 for문을 통해 스테이지 실패율을 구해 리스트 s에 넣습니다.
c는 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수이고 k는 스테이지에 도달한 플레이어 수입니다.

2. 스테이지 실패율을 내림차순으로 정렬합니다.
3. 리스트 a의 값이 리스트 s의 어느 위치에 있는지 값을 확인해 리스트 answer에 저장합니다.
4. 리스트 s의 값을 2로 바꿔줍니다. (실패율이 1이 최대이기 때문에 2로 설정하면 한번만 거치고 중복 방지를 할 수 있습니다.)
5. 3, 4과정을 리스트 a 길이만큼 반복하고 리스트 answer를 리턴합니다.

다른 사람의 풀이

def solution(N, stages):
    result = {}
    denominator = len(stages)
    for stage in range(1, N+1):
        if denominator != 0:
            count = stages.count(stage)
            result[stage] = count / denominator
            denominator -= count
        else:
            result[stage] = 0
    return sorted(result, key=lambda x : result[x], reverse=True)

1. 각 스테이지마다 for문을 통해 스테이지 실패율을 구해 딕셔너리 result에 넣습니다.
count를 통해 스테이지에 도달했으나 아직 클리어하지 못한 플레이어의 수를 구합니다.
2. 딕셔너리 result를 value를 기준으로 정렬하고 keys를 출력합니다.

프로그래머스 '실패율' : https://programmers.co.kr/learn/courses/30/lessons/42889