문제 링크

문제 설명

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.

마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

제한사항

  • 마라톤 경기에 참여한 선수의 수는 1명 이상 100,000명 이하입니다.
  • completion의 길이는 participant의 길이보다 1 작습니다.
  • 참가자의 이름은 1개 이상 20개 이하의 알파벳 소문자로 이루어져 있습니다.
  • 참가자 중에는 동명이인이 있을 수 있습니다.

입출력 예

participant completion return
["leo", "kiki", "eden"] ["eden", "kiki"] "leo"
["marina", "josipa", "nikola", "vinko", "filipa"] ["josipa", "filipa", "marina", "nikola"] "vinko"
["mislav", "stanko", "mislav", "ana"] ["stanko", "ana", "mislav"] "mislav"

입출력 예 설명

예제 #1
"leo"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #2
"vinko"는 참여자 명단에는 있지만, 완주자 명단에는 없기 때문에 완주하지 못했습니다.

예제 #3
"mislav"는 참여자 명단에는 두 명이 있지만, 완주자 명단에는 한 명밖에 없기 때문에 한명은 완주하지 못했습니다.

코드

sol1) 딕셔너리를 이용한 풀이

def solution(participant, completion):
    temp = {} # key,value를 가진 딕셔너리 이용

    #딕셔너리에 참가자 이름(key)과 해당 이름 사람수(value) 넣기 
    for i in participant :
        if i in temp : # 딕셔너리에서 in을 쓰면 key값이 있는지를 묻는 것
            temp[i]+=1
        else: 
            temp[i] =1
    
    #완주자 이름(key)의 value가 1이면 지우기, 동명이인이면 -1  
    for i in completion :
        if temp[i]==1 : 
            del temp[i]
        else : 
            temp[i] -=1

    #딕셔너리를 리스트로 바꾸고 가장 첫번째꺼 리턴(어차피 하나뿐)
    return list(temp.keys())[0]

sol2) 딕셔너리의 get을 이용한 풀이

  • dic.get(key) : key값에 대응하는 value값을 출력한다. 이는 dic[key]와 같으나 만약 없는 key값을 출력하라고 하면 dic[key]는 error를 출력하고, dic.get(key)는 None을 출력함. 만약 해당 key가 없을 때 반환되는 값을 바꾸 고 싶다면, get() 메소드의 두번째 인자로 주면 됨.
def solution(participant, completion):
    dic = {}
    for x in participant:
        dic[x] = dic.get(x,0) + 1 # dic에 key값으로 x가 있으면 x에 대응하는 value를 출력하고 없으면 0을 출력 #O(n)
    for x in completion:
        dic[x] -= 1                # O(n)
    sol = [k for k, v in dic.items() if v > 0]  #O(n)
    answer = sol[0]
    return answer

 

sol3) 딕셔너리를 사용한 후 sorted를 이용한 풀이

def solution(participant, completion):
    dic = {}
    for i in participant:
        if i not in dic:
            dic[i] = 1
        else:
            dic[i] += 1
    for j in completion:
        dic[j] -= 1
        
    sol = sorted(dic.items(), key = lambda x: x[1], reverse = True)
    return sol[0][0]

sol4) zip을 이용한 풀이

  • zip : 배열을 같은 인덱스끼리 짝지어준다. 만약 배열의 길이가 다를 경우 같은 인덱스끼리만 짝지어주고, zip 객체에서 나머지 인덱스는 제외된다.
def solution(participant, completion):
    participant.sort()  # O(nlogn)
    completion.sort()   # O(nlogn)
    for p,c in zip(participant, completion):
        if p != c:
            return p
    return participant[-1] # 모두 일치하면 사람수가 하나 더 많은 participant의 마지막 번호의 사람이 완주못한 것

sol5) Counter()를 이용한 풀이

  • collections.Counter: 원소의 수를 딕셔너리 형태로 출력함. 딕셔너리는 차집합이 불가능하지만 Counter내의 딕셔너리는 차집합이 가능함.
import collections
def solution(participant, completion):
    sol=collections.Counter(participant) - collections.Counter(completion)
    return list(sol.keys())[0]

sol6) 해시함수 이용 2번째 방법

  • hash('a') # 해당 value에 해당하는 hash값을 출력해줌

       >>> 3338796687179829302

def solution(participant , completion):
    Dic ={}
    sum = 0
    for part in participant:
        Dic[hash(part)] = part  # {숫자:'참가자'} 형태의 딕셔너리를 만듦
        sum += hash(part)       # 해당 참가자에 해당하는 key겂인 숫자를 더해준다
        
    for comp in completion:
        sum -=hash(comp)       # 완주한 사람에서 해당하는 key값인 숫자를 빼준다
    return Dic[sum]          # 남은 숫자의 key에 대응하는 값이 완주 못한 사람임

 

 

출처: 프로그래머스 코딩 테스트 연습, https://school.programmers.co.kr/learn/challenges

'프로그래머스 > lv1' 카테고리의 다른 글

lv1 체육복  (0) 2022.09.22
lv1 예산  (0) 2022.09.21

문제 링크

문제 설명

길이가 같은 배열 A, B 두개가 있습니다. 각 배열은 자연수로 이루어져 있습니다.
배열 A, B에서 각각 한 개의 숫자를 뽑아 두 수를 곱합니다. 이러한 과정을 배열의 길이만큼 반복하며, 두 수를 곱한 값을 누적하여 더합니다. 이때 최종적으로 누적된 값이 최소가 되도록 만드는 것이 목표입니다. (단, 각 배열에서 k번째 숫자를 뽑았다면 다음에 k번째 숫자는 다시 뽑을 수 없습니다.)

예를 들어 A = [1, 4, 2] , B = [5, 4, 4] 라면

  • A에서 첫번째 숫자인 1, B에서 첫번째 숫자인 5를 뽑아 곱하여 더합니다. (누적된 값 : 0 + 5(1x5) = 5)
  • A에서 두번째 숫자인 4, B에서 세번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 5 + 16(4x4) = 21)
  • A에서 세번째 숫자인 2, B에서 두번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 21 + 8(2x4) = 29)

즉, 이 경우가 최소가 되므로 29를 return 합니다.

배열 A, B가 주어질 때 최종적으로 누적된 최솟값을 return 하는 solution 함수를 완성해 주세요.

 

제한사항

  • 배열 A, B의 크기 : 1,000 이하의 자연수
  • 배열 A, B의 원소의 크기 : 1,000 이하의 자연수

입출력 예

A B answer
[1, 4, 2] [5, 4, 4] 29
[1,2] [3,4] 10

 

입출력 예 설명

입출력 예 #1
문제의 예시와 같습니다.

입출력 예 #2
A에서 첫번째 숫자인 1, B에서 두번째 숫자인 4를 뽑아 곱하여 더합니다. (누적된 값 : 4) 다음, A에서 두번째 숫자인 2, B에서 첫번째 숫자인 3을 뽑아 곱하여 더합니다. (누적된 값 : 4 + 6 = 10)
이 경우가 최소이므로 10을 return 합니다.

 

솔루션

⇒ A의 가장 작은 값과 B의 가장 큰 값을 순서대로 곱해서 더하는 형태

⇒ A와 B를 하나는 오름차순, 하나는 내림차순으로 정렬한 후 각 원소끼리 곱해서 더하자

 

코드

sol1

def solution(A,B):
    n = len(A)
    A = sorted(A)
    B = sorted(B, reverse = True)
    answer = 0
    for i in range(n):
        answer += A[i]*B[i]
    return answer

sol2

def solution(A,B):
    return sum(a*b for a, b in zip(sorted(A), sorted(B, reverse = True)))

 

출처: 프로그래머스 코딩 테스트 연습, https://school.programmers.co.kr/learn/challenges

'프로그래머스 > lv2' 카테고리의 다른 글

lv2 더 맵게  (1) 2022.09.23
lv2 큰 수 만들기  (0) 2022.09.22
lv2 기능개발  (0) 2022.09.21
lv2 게임 맵 최단거리  (1) 2022.09.21
lv2 타겟 넘버  (0) 2022.09.20

문제 링크

문제 설명

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

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

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

 

제한 사항

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

입출력 예

progresses speeds return
[93, 30, 55] [1, 30, 5] [2, 1]
[95, 90, 99, 99, 80, 99] [1, 1, 1, 1, 1, 1] [1, 3, 2]

 

입출력 예 설명

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

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

입출력 예 #2
모든 기능이 하루에 1%씩 작업이 가능하므로, 작업이 끝나기까지 남은 일수는 각각 5일, 10일, 1일, 1일, 20일, 1일입니다. 어떤 기능이 먼저 완성되었더라도 앞에 있는 모든 기능이 완성되지 않으면 배포가 불가능합니다.

따라서 5일째에 1개의 기능, 10일째에 3개의 기능, 20일째에 2개의 기능이 배포됩니다.

 

코드

def solution(progress, speeds):
    import math
    from collections import deque
    q = deque()
    answer = []
    for i in range(len(progress)):
        q.append(math.ceil((100 - progress[i])/speeds[i]))

    while q:
        a = q.popleft()
        cnt = 1
        for _ in range(len(q)): 
            if a >= q[0]:
                q.popleft()
                cnt += 1
            else:
                break   
        answer.append(cnt)  
    return answer

 

출처: 프로그래머스 코딩 테스트 연습, https://school.programmers.co.kr/learn/challenges

'프로그래머스 > lv2' 카테고리의 다른 글

lv2 큰 수 만들기  (0) 2022.09.22
lv2 최솟값 만들기  (0) 2022.09.21
lv2 게임 맵 최단거리  (1) 2022.09.21
lv2 타겟 넘버  (0) 2022.09.20
lv2 JadenCase 문자열 만들기  (1) 2022.09.20

문제 링크

문제 설명

S사에서는 각 부서에 필요한 물품을 지원해 주기 위해 부서별로 물품을 구매하는데 필요한 금액을 조사했습니다. 그러나, 전체 예산이 정해져 있기 때문에 모든 부서의 물품을 구매해 줄 수는 없습니다. 그래서 최대한 많은 부서의 물품을 구매해 줄 수 있도록 하려고 합니다.

물품을 구매해 줄 때는 각 부서가 신청한 금액만큼을 모두 지원해 줘야 합니다. 예를 들어 1,000원을 신청한 부서에는 정확히 1,000원을 지원해야 하며, 1,000원보다 적은 금액을 지원해 줄 수는 없습니다.

부서별로 신청한 금액이 들어있는 배열 d와 예산 budget이 매개변수로 주어질 때, 최대 몇 개의 부서에 물품을 지원할 수 있는지 return 하도록 solution 함수를 완성해주세요.

 

제한 사항

  • d는 부서별로 신청한 금액이 들어있는 배열이며, 길이(전체 부서의 개수)는 1 이상 100 이하입니다.
  • d의 각 원소는 부서별로 신청한 금액을 나타내며, 부서별 신청 금액은 1 이상 100,000 이하의 자연수입니다.
  • budget은 예산을 나타내며, 1 이상 10,000,000 이하의 자연수입니다.

입출력 예

d budget result
[1,3,2,5,4] 9 3
[2,2,3,3] 10 4

 

입출력 예 설명

입출력 예 #1
각 부서에서 [1원, 3원, 2원, 5원, 4원]만큼의 금액을 신청했습니다. 만약에, 1원, 2원, 4원을 신청한 부서의 물품을 구매해주면 예산 9원에서 7원이 소비되어 2원이 남습니다. 항상 정확히 신청한 금액만큼 지원해 줘야 하므로 남은 2원으로 나머지 부서를 지원해 주지 않습니다. 위 방법 외에 3개 부서를 지원해 줄 방법들은 다음과 같습니다.

  • 1원, 2원, 3원을 신청한 부서의 물품을 구매해주려면 6원이 필요합니다.
  • 1원, 2원, 5원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.
  • 1원, 3원, 4원을 신청한 부서의 물품을 구매해주려면 8원이 필요합니다.
  • 1원, 3원, 5원을 신청한 부서의 물품을 구매해주려면 9원이 필요합니다.

3개 부서보다 더 많은 부서의 물품을 구매해 줄 수는 없으므로 최대 3개 부서의 물품을 구매해 줄 수 있습니다.

입출력 예 #2
모든 부서의 물품을 구매해주면 10원이 됩니다. 따라서 최대 4개 부서의 물품을 구매해 줄 수 있습니다.

 

코드

sol1)

# budget에서 d의 원소가 작은것부터 뺌. budget이 0보다 작아질때까지 뺌
def solution(d, budget):
    cnt = 0
    d.sort()
    for i in d:
        budget -= i
        if budget < 0:
            break
        cnt +=1
    return cnt

sol2) pop을 이용한 풀이

def solution(d, budget):
    d.sort()  # 오름차순 정렬
    while budget < sum(d): # 위와 반대로 가장 큰 것들을 빼면서 남은 d의 원소들의 길이를 return함 
        d.pop()  # 가장 왼쪽의 원소를 삭제함
    return len(d)

 

출처: 프로그래머스 코딩 테스트 연습, https://school.programmers.co.kr/learn/challenges

'프로그래머스 > lv1' 카테고리의 다른 글

lv1 체육복  (0) 2022.09.22
lv1 완주하지 못한 선수  (1) 2022.09.22

n진수 ⇒ 10진수로 변환

  • int(string, n진수) : string을 n진수값으로 간주하고 결과값을 10진수로 반환
  • 인자로는 n진수를 문자열로 넣고 결과값은 int로 출력함
  • 진수를 생략하면 n진수를 10진수로 간주하여 문자열을 그냥 숫자로 바꿈
print(int('101',2))
>>> 5
print(int('101'))
>>>101
print(int('202',3))
>>> 20
print(int('303',4))
>>> 51
print(int('404',5))
>>> 104
print(int('505',6))
>>> 185
print(int('ACF',16))
>>> 2767

 

10진수 ⇒ 2, 8, 16진수로 변환

  • 2, 8, 16진수는 bin(), oct(), hex() 함수를 지원함
  • 입력값은 int이지만, 결과값은 string으로 반환함
  • 2진수는 앞에 0b, 8진수는 앞에 0o, 16진수는 앞에0x를 붙혀서 반환함
print(bin(110))
>>> 0b1101110
print(oct(110))
>>> 0o156
print(hex(110))
>>> 0x6e

# 앞에 진수를 나타내는 글자 제외하기
print(bin(110)[2:])
>>> 1101110
print(oct(110)[2:])
>>> 156
print(hex(110)[2:])
>>> 6e

 

10진수 ⇒ n진수로 변환

  • int 같은 함수가 없기 때문에 코드작성이 필요함
def solution(n, q):    # n: 10진수,  q : 변환할 진수   int -> str
    answer = ''
    while n >0:
        a = n%q
        answer = str(a) + answer
        n = n//q
    return answer 

print(solution(45,3))
>>> 1200

 

n진수 ⇒ n진수로 변환

  • 바꾸기 전 n진수를 int()함수를 이용해서 10진수로 만들고(str → int), 위에서 만든 solution함수를 이용해서 바꿀 n진수로 바꿈(int → str)
print(solution(int('c',16),4)) # 16진수인 C를 4진수로 바꾸는것
>>> 30
print(solution(int('4',6),3))  # 6진수인 4를 3진수로 바꾸는것
>>> 11
print(solution(int('21',3),7)) # 3진수인 21을 7진수로 바꾸는것
>>> 10
print(solution(int('15',9),5)) # 9진수인 15를 5진수로 바꾸는것
>>> 24

문제링크

문제설명

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.

지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다. 다음은 5 x 5 크기의 맵에, 당신의 캐릭터가 (행: 1, 열: 1) 위치에 있고, 상대 팀 진영은 (행: 5, 열: 5) 위치에 있는 경우의 예시입니다.

위 그림에서 검은색 부분은 벽으로 막혀있어 갈 수 없는 길이며, 흰색 부분은 갈 수 있는 길입니다. 캐릭터가 움직일 때는 동, 서, 남, 북 방향으로 한 칸씩 이동하며, 게임 맵을 벗어난 길은 갈 수 없습니다. 아래 예시는 캐릭터가 상대 팀 진영으로 가는 두 가지 방법을 나타내고 있습니다.

 

첫 번째 방법은 11개의 칸을 지나서 상대 팀 진영에 도착했습니다.

 

두 번째 방법은 15개의 칸을 지나서 상대팀 진영에 도착했습니다.

위 예시에서는 첫 번째 방법보다 더 빠르게 상대팀 진영에 도착하는 방법은 없으므로, 이 방법이 상대 팀 진영으로 가는 가장 빠른 방법입니다.

 

만약, 상대 팀이 자신의 팀 진영 주위에 벽을 세워두었다면 상대 팀 진영에 도착하지 못할 수도 있습니다. 예를 들어, 다음과 같은 경우에 당신의 캐릭터는 상대 팀 진영에 도착할 수 없습니다.

게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요. 단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요.

 

제한사항

  • maps는 n x m 크기의 게임 맵의 상태가 들어있는 2차원 배열로, n과 m은 각각 1 이상 100 이하의 자연수입니다.
    • n과 m은 서로 같을 수도, 다를 수도 있지만, n과 m이 모두 1인 경우는 입력으로 주어지지 않습니다.
  • maps는 0과 1로만 이루어져 있으며, 0은 벽이 있는 자리, 1은 벽이 없는 자리를 나타냅니다.
  • 처음에 캐릭터는 게임 맵의 좌측 상단인 (1, 1) 위치에 있으며, 상대방 진영은 게임 맵의 우측 하단인 (n, m) 위치에 있습니다.

입출력 예

maps answer
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]] 11
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]] -1

 

입출력 예 설명

예제 #1
주어진 데이터는 다음과 같습니다.

캐릭터가 적 팀의 진영까지 이동하는 가장 빠른 길은 다음 그림과 같습니다.

따라서 총 11칸을 캐릭터가 지나갔으므로 11을 return 하면 됩니다.

 

예제 #2

문제의 예시와 같으며, 상대 팀 진영에 도달할 방법이 없습니다. 따라서 -1을 return 합니다.

 

코드

def bfs(maps):
    from collections import deque
    n=len(maps)
    m =len(maps[0])
    visit = [[False]*m for _ in range(n)]
    
    dx = [-1,1,0,0]
    dy = [0,0,-1,1]
    
    
    q = deque()
    q.append((0,0,1))
    visit[0][0] = True
    while q:
        y, x, d =q.popleft()
        if y == n-1 and x == m-1:
            return d
        else:
            for k in range(4):
                nx = x+dx[k]
                ny = y+dy[k]
                if (0 <= nx < m) and (0 <= ny <n) and (visit[ny][nx] == False) and (maps[ny][nx] ==1):
                    q.append((ny,nx,d+1))
                    visit[ny][nx] = True
    return -1


def solution(maps):
    sol = bfs(maps)
    return sol

 

 

출처: 프로그래머스 코딩 테스트 연습, https://school.programmers.co.kr/learn/challenges

'프로그래머스 > lv2' 카테고리의 다른 글

lv2 최솟값 만들기  (0) 2022.09.21
lv2 기능개발  (0) 2022.09.21
lv2 타겟 넘버  (0) 2022.09.20
lv2 JadenCase 문자열 만들기  (1) 2022.09.20
lv2 N개의 최소 공배수  (0) 2022.09.20

문제링크

문제 설명

n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.

 

제한 사항

  • 주어지는 숫자의 개수는 2개 이상 20개 이하입니다.
  • 각 숫자는 1 이상 50 이하인 자연수입니다.
  • 타겟 넘버는 1 이상 1000 이하인 자연수입니다.

 

입출력 예

 

numbers  target return
[1, 1, 1, 1, 1] 3 5
[4, 1, 2, 1] 4 2

 

입출력 예 설명

입출력 예 #1

문제 예시와 같습니다.

입출력 예 #2

+4+1-2+1 = 4
+4-1+2-1 = 4
  • 총 2가지 방법이 있으므로, 2를 return 합니다.

 

코드

DFS 풀이

def dfs(i, numbers, target, tot):
    global cnt
    n = len(numbers)
    if i== n:
        if tot == target:
            cnt += 1
            
    else:
        dfs(i+1, numbers, target, tot + numbers[i])
        dfs(i+1, numbers, target, tot + numbers[i]*(-1))
            
def solution(numbers, target):
    global cnt
    cnt = 0
    dfs(0,numbers, target, 0)
    return cnt

 

중복순열

  • 중복조합은 from itertools import combinations_with_replacement를 쓰는 반면 중복순열은 from itertools import product를 쓴다
  • combinations_with_replacement(뽑을 곳, 반복횟수)을 써주기만 하면 되는 반면 product(뽑을 곳, repeat = 반복횟수)임 만약 product에서 repeat을 안쓰면 오류가 뜸 

ex)

from itertools import combinations_with_replacement

li = [1,2]
for com in combinations_with_replacement(li, 2):
    print(com)

>>>(1, 1)
   (1, 2)
   (2, 2)
from itertools import product

li = [1,2]
for pro in product(li,2):
    print(pro)

>>> TypeError
from itertools import product

li = [1,2]
for pro in product(li,repeat = 2):
    print(pro)

>>> (1, 1)
    (1, 2)
    (2, 1)
    (2, 2)

 

중복순열을 이용한 풀이

def solution(numbers, target):
    from itertools import product
    w = [-1,1]
    n = len(numbers)
    cnt = 0
    for per in  product(w, repeat = n):
        sol = 0
        for i in range(n):
            sol += per[i]*numbers[i]
        if sol == target:
            cnt +=1
    return cnt

 

 

출처: 프로그래머스 코딩 테스트 연습, https://school.programmers.co.kr/learn/challenges

'프로그래머스 > lv2' 카테고리의 다른 글

lv2 기능개발  (0) 2022.09.21
lv2 게임 맵 최단거리  (1) 2022.09.21
lv2 JadenCase 문자열 만들기  (1) 2022.09.20
lv2 N개의 최소 공배수  (0) 2022.09.20
lv2 피보나치 수  (0) 2022.09.18

dictionary[key] = v ⇒ key 라는 곳에 v 값 삽입 : O(1)

del dictionary[key] ⇒ key 라는 곳을 삭제 :  O(1)

dictionary[key] ⇒ key 라는 곳에 있는 v 값 조회 : O(1)

ex = {1:'가', 2:'나', 3:'다'}
ex[4] = '라'  # 삽입  O(1)
print(ex) >>> {1: '가', 2: '나', 3: '다', 4: '라'}

del ex[2]  # 삭제 O(1)  주의! remove가 아닌 del을 사용해야 한다.
print(ex)  >>>  {1: '가', 3: '다', 4: '라'}

print(ex[3])  # 조회 O(1) 
>>> 다

 

딕셔너리는 중복된 key값을 가질 수 없다. 중복된 key값을 쓰면 하나를 제외한 나머지는 무시된다.

a = {1:'a', 1:'b'}
print(a)
>>>{1: 'b'}

 

dic.get(key) : key값에 대응하는 value값을 출력한다. 이는 dic[key]와 같으나 만약 없는 key값을 출력하라고 하면 dic[key]는 error를 출력하고, dic.get(key)는 None을 출력함. 만약 해당 key가 없을 때 반환되는 값을 바꾸고 싶다면, get() 메소드의 두번째 인자로 주면 됨. 

ex = {1:'가', 2:'나', 3:'다'}

print(ex.get(1))
>>> 가
print(ex[1])
>>> 가

print(ex[4])
>>> KeyError
print(ex.get(4))
>>> None
print(ex.get(4,0))
>>> 0

 

리스트나 튜플을 딕셔너리로 만들기

list1 = ['a','b','c','d','e']
list2 = [1,2,3,4,5]
li = []

for x,y in zip(list1, list2):
    li.append((x,y))
print(li)
>>> [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]


dic1 = dict(li)
print( dic1 ) # 리스트의 원소가 튜플이나 리스트로 길이가 2일 때 dict()를 하면 앞에 것은 key , 뒤에 것은 value가 된다.
>>> {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}


# 좀 더 빠른 방법
dic2 = dict(zip(list2, list1))
print( dic2 )
>>> {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

 

딕셔너리에서 값을 확인 하는 방법에는 딕셔너리.keys(), 딕셔너리.items(), 딕셔너리.values()가 있다. 주의할 것은 ()를 안하면 객체가 생성되지 않는다. 또한 모두 s가 붙는 복수형이라는 것을 잊지 말자.

     s = {'1':'a', '2':'b'} 
     s.keys()                         
     >>> dict_keys(['1', '2']) 
     s.keys 
     >>> <function dict.keys>
     

     s.values()                       
     >>> dict_values(['a', 'b'])
     s.values 
     >>> <function dict.values>


     s.items()                                    
     >>> dict_items([('1', 'a'), ('2', 'b')])    
     s.items
     >>> <function dict.items>

 

for 문 혹은 if 문에서 딕셔너리 이름을 쓰면 key값만 나오게 된다.

s = {'1':'a', '2':'b'} 

for i in s:                              
    print(i, end = ' ')                                              
>>> 1 2                                                                    

for i in s.keys():
    print(i, end = ' ')
>>> 1 2



if '1' in s:
    print(True)
>>> True 

if '1' in s.keys():
    print(True)
>>> True

 

만약 for문 혹은 if문에서 value값을 찾고 싶거나 item 값을 찾고 싶으면 .values() 혹은 .items()를 써야 한다.

ex) s = {'1':'a', '2':'b'} 

for i in s.values():
    print(i, end = ' ')
>>> a b

for i in s.items():
    print(i, end = ' ')
>>> ('1', 'a') ('2', 'b')



if 'a' in s.values():
    print(True)  
>>> True

if ('1','a') in s.items():
    print(True)
>>>> True

 

딕셔너리 정렬하기

dic = {'toy': 70, 'snack': 200, 'python': 10}
print(dic)
>>> {'toy': 70, 'snack': 200, 'python': 10}

 

1. 딕셔너리에 정렬을 하면 key값을 기준으로 key값을 정렬한 후 key값만 리스트로 출력함 이때, 주의할 점은 문자열을 정렬할때 정렬 순서는 문자열의 길이가 아닌 사전식 배열이 정렬의 기준임

print( sorted(dic) )
>>> ['python', 'snack', 'toy'] # 사전식 정렬

print( sorted(dic, reverse= True) )
>>> ['toy', 'snack', 'python'] # 사전식 배열의 내림차순으로 정렬

 

딕셔너리를 key값을 기준으로 정렬한 후 딕셔너리를 출력하는 방법
⇒ dic.items()를 정렬하면 key값을 기준으로 정렬됨. 이를 이용하면 key값을 기준으로 정렬된 딕셔너리를 출력할 수 있음

print( sorted(dic.items()) )
>>> [('python', 10), ('snack', 200), ('toy', 70)]


print( dict(sorted(dic.items())) )
>>> {'python': 10, 'snack': 200, 'toy': 70}

print( dict(sorted(dic.items(), reverse = True)) )
>>> {'toy': 70, 'snack': 200, 'python': 10} # key값을 기준으로 사전식 배열의 내림차순으로 정렬한 딕셔너리

 

3. 딕셔너리를 value값을 기준으로 정렬한 후 딕셔너리를 출력하는 방법
⇒ dic.items()를 정렬하면 value값을 기준으로 정렬됨. 이를 이용하면 value값을 기준으로 정렬된 딕셔너리를 출력할 수 있음

print( sorted(dic.items(), key = lambda x:x[1]) )
>>>  [('python', 10), ('toy', 70), ('snack', 200)]


print( dict(sorted(dic.items(), key = lambda x:x[1])) )
>>> {'python': 10, 'toy': 70, 'snack': 200}


print( dict(sorted(dic.items(), key = lambda x:x[1], reverse = True)) )
>>> {'snack': 200, 'toy': 70, 'python': 10}

 

4. 딕셔너리를 key값의 문자열 길이를 기준으로 정렬하는 방법

print( sorted(dic, key = lambda x: len(x)) )  # 딕셔너리를 sort하면 key값을 기준으로 정렬됨. 이때 lambda를 써서 key값의 문자열 길이를 기준으로 정렬할 수 있음
>>> ['toy', 'snack', 'python']

print( sorted(dic, key = lambda x: len(x), reverse = True) )
>>> ['python', 'snack', 'toy']

print( sorted(dic.items(), key = lambda x: len(x[0])) )
>>> [('toy', 70), ('snack', 200), ('python', 10)]

print( sorted(dic.items(), key = lambda x: len(x[0]), reverse = True) )
>>> [('python', 10), ('snack', 200), ('toy', 70)]


print( dict(sorted(dic.items(), key = lambda x: len(x[0]))) ) # 딕셔너리의 key값의 문자열 길이를 기준으로 정렬한 딕셔너리
>>> {'toy': 70, 'snack': 200, 'python': 10}
print( dict(sorted(dic.items(), key = lambda x: len(x[0]), reverse = True)) )
>>>  {'python': 10, 'snack': 200, 'toy': 70}

+ Recent posts