메...모...정..리..

영..환...코테..정..리한..다..

하..기싫..다...그..래도...한..다...

1. 각 자리수의 합

10으로 나눈 나머지는 1의 자리 수
기존의 수를 10으로 나눈 몫은 1의 자리 수를 날리는 것.

n = int(input())

answer = []
while n != 0:
	answer.append(n%10)
    n = n // 10

2. 순열 검사

중복없는 배열인지.
배열의 길이 만큼만 있는지

[4, 1, 2, 3] OK

[4, 2, 3] No -> 4는 배열의 길이 3보다 크므로.

풀이 방법 1 : 확인해야 할 array와 길이가 같으며 index가 값의 위치이다.

ex) index = 0 : 숫자 1의 위치 and 숫자 1이 array에 있는 개수

def solution(arr):
    answer = True
    checkArr = [0 for i in range(100000)]
    for i in range(len(arr)):
        checkArr[arr[i]-1] += 1
    for i in range(len(arr)):
        if checkArr[i] != 1:
            print(checkArr[i])
            answer = False
            break
    

    
    return answer

기억해야 할 것.

중복된 숫자를 확인할 때 checkArr를 쓴다.
index + 1 이 숫자를 의미하고, 해당 주소의 값이 숫자가 등장한 횟수를 의미한다.

풀이 방법 2 : 배열을 정렬 한 후에 체크하면 됨.

answer = True
arr.sort()
for num in range(1, len(arr) + 1):
	if arr[num - 1] != num:
    	answer = False
        break

3. 나머지 한 점

직사각형의 3개의 좌표가 주어졌을 때 나머지 하나의 좌표를 구하라는 문제.

직사각형의 각 변은 평행하고 직교한다는 정리에 따라 x 좌표와 y 좌표는 동일한 다른 좌표가 반드시 한 개 존재한다.

따라서 x 좌표 3개 중 2개가 동일하면 나머지 하나가 우리가 찾는 x 좌표이다. (y 좌표 동일)

기억해야 할 것

서로 다른 값을 바로 구하려면 XOR 연산을 사용하면 된다.

A xor A = 0
A xor A xor B = B

xor 연산 in python : ^

def solution(v):
    answer = []
    tempx = []
    tempy = []
    for point in v:
        tempx.append(point[0])
        tempy.append(point[1])
    answer.append(tempx[0] ^ tempx[1] ^ tempx[2])
    answer.append(tempy[0] ^ tempy[1] ^ tempy[2])
    
    return answer

4. 가장 큰 사각형 구하기

이거 진짜 BruteForce로 풀고싶었는데 일단 Dynamic으로....

4분점으로 1, 2, 3, 4 가 있다고 하자.

그러면 4를 우리가 지목할건데 지점 4 좌표 (i, j)를 우측 하단으로 가지는 정사각형의 최대 넓이를 구하려고 한다.

이때 지점 4 좌표가 0 이면 볼 필요도 없이 넘기면 된다.

1 지점 (i-1, j-1) 2 지점 (i-1, j)

3 지점 (i, j-1) 4지점(i, j)

변의 길이를 담을 dp 리스트는 1지점이 0이 아니고, 4지점이 1이면 변의 길이를 저장한다.

변의 길이를 저장했다면 이 데이터를 가지고 계속해서 변의 길이를 저장해 나간다.

def solution(board):
    dp = [[0 for i in range(1001)] for i in range(1001)]
    ans = 0
    row = len(board)
    col = len(board[0])
    
    for i in range(1, row+1):
        for j in range(1, col+1):
            if board[i-1][j-1] != 0:
                dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
                ans = max(ans, dp[i][j])
                
                            

    return ans*ans

솔직히 선언한다. 잘 모르겠다. 같은 유형 계속 풀다보면 감이 잡히겠지...

기억해야할 것

1. 리스트에 있어서 행과 열은 나의 생각과 반대였다.

예를들어
arr = [[0,0],[0,0]] 이 있으면
arr[row][col] 이다.

당연한 건데 왜 자꾸 헷갈렸는지 잘 모르겠다.
모르는건 인정하고 배우면 된다.

당연한 이란 말을 붙이는거 자체가 모르는걸 인정하기 싫었나보다.. 에휴

2. 2차원 리스트 만들기

dp = [[0 for i in range(1001)] for i in range(1001)]

요로케

5. 땅따먹기

땅따먹기를 하면서 내려가는건데 자기 바로 아래로는 못내려가고 무조건 대각선으로 내려가야 한다.

처음 생각 한 풀이

def solution(land):
    answer = 0
    prevColIdx = 0
    nextColIdx = 0
    for i in range(len(land)):
        if i == 0:
            nextColIdx = land[0].index(max(land[0]))
            answer += land[i][nextColIdx]
            prevColIdx = nextColIdx
        else:
            nextColIdx = land[i].index(max(land[i]))
            if nextColIdx == prevColIdx:
                temp = land[i]
                temp.remove(temp[nextColIdx])
                nextColIdx = land[i].index(max(temp))
                
            answer += land[i][nextColIdx]
            prevColIdx = nextColIdx
            
                
        
    return answer

이거 테스트 코드는 통과했는데 왜 틀리게 나오는지 모르겠음. 진짜로...

다이나믹 프로그래밍

def solution(land):
    dp = [[0,0,0,0] for i in range(100000)]
    ans = 0
    row = len(land)
    for i in range(4):
        dp[0][i] = land[0][i]

    for i in range(1, row):
        for j in range(4):
            for k in range(4):
                if j != k :
                    dp[i][j] = max(dp[i][j], land[i][j] + dp[i-1][k])

    for i in range(4):
        ans = max(ans, dp[row-1][i])
    
    return ans

6. 덩치들 (백준 7568번)

N = int(input())
members = []
for i in range(N):
    x, y = map(int, input().split())
    members.append((x, y))
tier = [1 for i in range(N)]
for i in range(N):
    for j in range(N):
        if j == i :
            continue
        if members[i][0] < members[j][0] and members[i][1] < members[j][1]:
            tier[i] += 1
print(' '.join(map(str,tier)))

기억해야 할 것

리스트를 공백으로 구분하여 출력하기
' '.join(map(str,array))

7. 최대공약수 최소공배수

2개의 자연수 a, b에 대해서 a를 b로 나눈 나머지를 r이라 하면(단, a > b),
a와 b의 최대공약수는 b와 r의 최대공약수와 같다.

이 성질에 따라, b를 r로 나눈 나머지 r'를 구하고, 다시 r을 r'로 나눈 나머지를 구하는 과정을 반복하여 나머지가 0이 되었을 때 나누는 수가 a와 b의 최대공약수이다.

최소공배수는 a, b의 곱을 a, b의 최대 공약수로 나누면 나오게 된다.

(최소공배수 x 최대 공약수) = gcd^2 * a * b [a, b은 서로수] => a * b
를 이용한 방법이다.

라고하네요. ㅋㅋ

a, b = map(int, input().split())

def gcd(a,b):
    while b>0:
        a, b = b, a % b
    return a
def lcm(a,b):
    return a * b // gcd(a, b)

print(gcd(a, b))
print(lcm(a, b))

이따가 종이로 다시 정리해보자. -> 오케이 이해완료.

근데 이거 파이썬에 내장 함수 있다던데

import math

math.gcd(a,b)
math.lcm(a,b)

8. 나이순 정렬 (백준 10814번)

나이가 어린 사람을 앞으로 정렬하되 같은 나이면 먼저 가입한 사람을 앞으로 정렬하는 문제.

sorted 함수를 잘 쓴다면 쉬웠다.

N = int(input())
nameList = []
for _ in range(N):
    age, name = input().split()
    nameList.append((int(age), name, _))

answerList = sorted(nameList, key = lambda x : (x[0], x[2]))

for item in answerList:
    print(item[0],item[1])

기억해야 할 것

sorted(list_name, key = lambda x : (+x[0], -x[1]))

x는 list_name의 하나의 데이터이며 이 데이터의 0번째 인자를 기준으로 오름차순 정렬한다.
이때 같은 수준의 값이 충돌시 1번째 인자를 기준으로 내림차순으로 정렬한다.

이럴 때 사용하면 된다.

9. 괄호 (백준 9012번)

() 쌍을 찾는 문제. 이런건 딱 봐도 stack이여따. 근데 그냥 deque 쓰기로함. 편하잖아

from collections import deque
queue = deque()

queue.popleft() # 디큐의 전단을 삭제
queue.pop() # 디큐의 후단을 삭제
queue.append('data') # 디큐의 후단에 데이터 삽입
queue.appendleft('data') # 디큐의 전단에 데이터 삽입
queue.extend('abc') # queue >> [a, b, c]
# deque에 iterable argument(list, str, tuple...)를 분리해서 append 해주는 메서드.
queue.extendleft('def') # queue >> [f, e, d, a, b, c]
# deque에 iterable argument(list, str, tuple...)를 분리해서 appendleft 해주는 메서드.
queue.rotate(n) # queue의 값들을 n 값 만큼 회전시켜주는 메서드. 양수면 오른쪽, 음수면 왼쪽으로 회전

(일단 deque 사용법 정리해 놓은 것)

from collections import deque
queue = deque()
container = deque()
answer = []
N = int(input())

for _ in range(N):
    container.extend(input())
    for i in range(len(container)):
        if len(queue) == 0:
            queue.append(container.popleft())
            continue
        ps = container.popleft()
        
        if queue[-1] + ps == "()":
            queue.pop()
        else:
            queue.append(ps)
        
    if len(queue) == 0:
        answer.append("YES")
    else:
        answer.append("NO")
        queue = deque()
    
for ans in answer:
    print(ans)

생각을 순간 잘못했다. ( 다음 무조건 반대 쌍인 ) 가 나오는게 아니라 그 두개가 ()를 만들어야 하는건데.

10. 소수구하기 (백준 1929번)

그냥 주어진 범위 내의 소수 구하는건데... 숫자 1을 예외처리 안해서 틀렸다. 주의하자

import math
minNum, maxNum = map(int, input().split())
def isPrime(n):
    if num==1:
        return False
    for i in range(2, int(math.sqrt(n))+1):
        if n % i == 0:
            return False
        
    return True

for num in range(minNum, maxNum + 1):
    if isPrime(num):
        print(num)

11. 균형맞추기 (백준 4949번)

이번엔 ()와[]를 같이 맞춰야 하는 문제다. 위에 () 문제도 굳이 deque 2개 쓸 필요없이 하나만 쓰면 되었다.

from collections import deque

while True:
    s = input()
    if s == ".":
        break
    queue = deque()
    temp = True
    for ss in s:
        if ss == "(" or ss == "[":
            queue.append(ss)
        elif ss == ")":
            if len(queue) == 0 or queue[-1] == "[":
                temp = False
                break
            elif queue[-1] == "(":
                queue.pop()
        elif ss == "]":
            if len(queue) == 0 or queue[-1] == "(":
                temp = False
                break
            elif queue[-1] == "[":
                queue.pop()

    if len(queue) == 0 and temp:
        print("yes")
    else:
        print("no")

11. 신고결과 받기 (프로그래머스 Lv.1)

이 문제의 핵심은 누가 누구를 신고했는지를 아는 것과 신고 당한 사람의 신고당한 횟수 그리고 신고당한 사람이 K 번 이상 신고당했을 때 신고한 사람이 누구인지 확인하는 것이다.

그래서 처음에는 무지성으로 내 생각을 코드로 그대로 옮겨적었다...

def solution(id_list, report, k):
    answer = []
    reportMember = {}
    reportedMember = {}
    reportLog = []
    for member in id_list:
        reportMember[member] = 0
        reportedMember[member] = 0
        
    for reportInfo in report:
        reporter, reportee = reportInfo.split()
        reportLog.append((reporter, reportee))
    reportLog = list(dict.fromkeys(reportLog))
    
    for rep in reportLog:
        reportedMember[rep[1]] += 1
        if reportedMember[rep[1]] % k == 0:
            for repInfo in reportLog:
                if repInfo[1] == rep[1]:
                    reportMember[repInfo[0]] += 1
    
    for reporter in reportMember.keys():
        answer.append(reportMember[reporter])

        
    return answer

그런데 83% 정답률이 나왔다. 나머지는 뭐가 문제일까... 문제가 있다면 % k == 0 부분인데..

생각을 또 다시해보니 신고 횟수가 K 번 이상일 땐 누가 신고해도 그대로 메일이 가는 것을 생각을 못했다.

이를 적용하고 코드를 조금 더 깔끔하게 수정했다.

def solution(id_list, report, k):
    reportee = {x:0 for x in id_list}
    reporter = [0] * len(id_list)
    
    for r in set(report): 
        reportee[r.split()[1]] += 1
            
    for r in set(report):
        if reportee[r.split()[1]] >= k:
            reporter[id_list.index(r.split()[0])] += 1
    
    return reporter

기억해야 할 것

- index로 고유값의 위치를 알 수 있다면 굳이 map 자료를 안써도 된다.
listName.index("인덱스를 찾고자 하는 값")
- map 자료구조 초기화
dic = {x:"value" for x in range(num)}
- 순서를 가만히 둔 채 리스트 중복 제거
 reportLog = list(dict.fromkeys(reportLog))

12. 로또의 최고 순번 (프로그래머스 Lv.1)

def solution(lottos, win_nums):
    rank = [6, 6, 5, 4, 3, 2, 1]
    cnt_0 = lottos.count(0)
    check = 0
    for num in lottos:
        if num in win_nums:
            check+=1
    answer = [rank[check + cnt_0], rank[check]]
    return answer

이걸 왜 썼냐면... if문을 ... 아니다.. 말을 말자... 다신 그러지 말자는 의미로... 쓰는거임.

그리고 list랑 map에 사용할 수 있는 메서드 총 정리 한 번 해야할듯. 아는 만큼 보이는거같다.

13. 신규 아이디 추천 (프로그래머스 Lv.1)

7단계로 문자열을 조작하는 문제

이런거 보다 보면 진짜 함수 정리 해야겠다는 생각 듬.

def solution(new_id):

    bannedSpecial = ['~','!','@','#','$','%','^','&','*','(',')','=','+','[','{',']','}',':','?',',','<','>','/']
    new_id = new_id.lower()
    for special in bannedSpecial:
        new_id = new_id.replace(special, '')

    while '..' in new_id:
        new_id = new_id.replace('..','.')

    new_id = new_id.strip('.')
    if new_id == '':
        new_id += 'a'

    if len(new_id) > 15:
        new_id = new_id[:15].rstrip('.')

    if len(new_id) == 1:
        new_id += (new_id[0] * 2)
    if len(new_id) == 2:
        new_id += new_id[-1]

    return new_id

좀 더 나은 풀이

def solution(new_id):
    answer = ''
    # 1
    new_id = new_id.lower()
    # 2
    for c in new_id:
        if c.isalpha() or c.isdigit() or c in ['-', '_', '.']:
            answer += c
    # 3
    while '..' in answer:
        answer = answer.replace('..', '.')
    # 4
    if answer[0] == '.':
        answer = answer[1:] if len(answer) > 1 else '.'
    if answer[-1] == '.':
        answer = answer[:-1]
    # 5
    if answer == '':
        answer = 'a'
    # 6
    if len(answer) > 15:
        answer = answer[:15]
        if answer[-1] == '.':
            answer = answer[:-1]
    # 7
    while len(answer) < 3:
        answer += answer[-1]
    return answer

14. 키패드 누르기 (프로그래머스 Lv.1)

왼손잡이와 오른손잡이에 따른 키패드를 누르는 손가락에 관한 문제.

개인적으로 index 개념을 거리로 생각해 손가락과 키패드 사이 거리를 구하는게 가장 깔끔하다고 생각함.

def solution(numbers, hand):
    answer = ''
    leftSide = [1, 4, 7, '*']
    rightSide = [3, 6, 9, '#']
    centerSide = [2, 5, 8, 0]
    recentLeft, recentRight = '*', '#'

    l_d = [0,0]
    r_d = [0,0]
    for num in numbers:
        if num in leftSide:
            answer += 'L'
            recentLeft = num
        elif num in rightSide:
            answer += 'R'
            recentRight = num
        else:
            if recentLeft in centerSide:
                l_d[1] += abs(centerSide.index(num) - centerSide.index(recentLeft))
            else:
                l_d[1] += abs(centerSide.index(num) - leftSide.index(recentLeft))
                l_d[0] += 1

            if recentRight in centerSide:
                r_d[1] += abs(centerSide.index(num) - centerSide.index(recentRight))
            else:
                r_d[1] += abs(centerSide.index(num) - rightSide.index(recentRight))
                r_d[0] += 1
            leftHandMove = l_d[0] + l_d[1]
            rightHandMove = r_d[0] + r_d[1]

            if rightHandMove > leftHandMove:
                answer += 'L'
                recentLeft = num
            elif rightHandMove < leftHandMove:
                answer += 'R'
                recentRight = num
            else:
                if hand == 'right':
                    answer += 'R'
                    recentRight = num
                else:
                    answer += 'L'
                    recentLeft = num
            l_d[0], l_d[1], r_d[0], r_d[1] = 0, 0, 0, 0

    return answer

13. 인형뽑기 (프로그래머스 Lv.1)

딱 봐도 스택쓰는문제. 같은 인형 두개가 모이면 펑 터진단다.

그런데 나는 터지는 횟수를 생각해서 한참 고민하다가 터지는 인형개수인걸 좀 늦게 깨달아 버림..

def checkPop(stack, recent):
    if len(stack) == 0:
        stack.append(recent)
        return 0
    if stack[-1] == recent:
        stack.pop()
        return 1
    else:
        stack.append(recent)
        return 0

def solution(board, moves):
    answer = 0
    basket = []

    for move in moves:
        for dool in board:
            if dool[move-1] != 0:
                answer += checkPop(basket, dool[move-1])
                dool[move-1] = 0
                break


    return answer*2

14. 없는 숫자 더하기 (프로그래머스 Lv.1)

기교를 부릴 수 있으나 이전에 풀었던 checkArray가 생각나서 활용해 보았다.

def solution(numbers):
    answer = 0
    checkArr = [0] * 10
    for num in numbers:
        checkArr[num] += 1
    for i in range(len(checkArr)):
        if checkArr[i] == 0:
            answer += i

    return answer

걍 생각난거

def solution(numbers):
    return 45 - sum(numbers)

15. 소수만들기 (프로그래머스 Lv.1)

BruteForce 알고리즘 쓰면 되는 건데 남의 풀이 보니까 combination 이라는 패키지가 있네?

내 풀이

import math

def findPrime(n):
    for i in range(2, int(math.sqrt(n))+1):
        if n % i == 0:
            return False
    return True

def solution(nums):
    answer = 0
    for i in range(len(nums)-2):
        for j in range(i+1, len(nums)-1):
            for k in range(j+1, len(nums)):
                if findPrime(nums[i]+nums[j]+nums[k]):
                    answer += 1


    return answer

남의 것

from itertools import combinations
def prime_number(x):
    answer = 0
    for i in range(1,int(x**0.5)+1):
        if x%i==0:
            answer+=1
    return 1 if answer==1 else 0

def solution(nums):
    return sum([prime_number(sum(c)) for c in combinations(nums,3)])

기억해야 할 것
https://docs.python.org/ko/3/library/itertools.html

여기서 쓸만한거 골라서 깃헙에 정리하자

itertools — 효율적인 루핑을 위한 이터레이터를 만드는 함수 — Python 3.10.5 문서

itertools — 효율적인 루핑을 위한 이터레이터를 만드는 함수 이 모듈은 APL, Haskell 및 SML의 구성물들에서 영감을 얻은 여러 이터레이터 빌딩 블록을 구현합니다. 각각을 파이썬에 적합한 형태로

docs.python.org

16. 완주하지 못한 사람(프로그래머스 Lv.1)

시간초과가 나서 못풀었다.

https://coding-grandpa.tistory.com/85 이거 보면서 재정리.

1명을 찾아내는 대에는 hashing이 최고인거 같긴 하다.

def solution(participant, completion):
    hashTable = {}
    hashSum = 0
    for person in participant:
        hashTable[hash(person)] = person
        hashSum += hash(person)
    for person in completion:
        hashSum -= hash(person)


    return hashTable[hashSum]

그런데 일반적으로는 이렇게 풀 것 같다.

def solution(participant, completion):
    participant.sort()
    completion.sort()
    for i in range(len(completion)):
        if participant[i] != completion[i]:
            return participant[i]
    return participant[-1]

17. 모의고사 (프로그래머스 Lv.1)

나는 미리 리스트를 만들어서 문제에서 주는 리스트에 대응했다.

def p1(num):
    return num + 1

def solution(answers):
    persons =[list(map(int, "1,2,3,4,5".split(","))) * 2001,list(map(int, "2,1,2,3,2,4,2,5".split(","))) * 1251,list(map(int, "3,3,1,1,2,2,4,4,5,5".split(","))) * 1001] 
    count = [0,0,0]
    iterPerson = 0
    for person in persons:
        for i in range(len(answers)):
            if answers[i] == person[i]:
                count[iterPerson] += 1
        iterPerson += 1

    count = list(filter(lambda x: count[x]==max(count), range(len(count)))) 
    return list(map(p1, count))

거기에 필터함수를 이용해 값을 다시 넣어놓고, map을 돌려서 index를 등수로 바꿔주었다.

def solution(answers):
    pattern1 = [1,2,3,4,5]
    pattern2 = [2,1,2,3,2,4,2,5]
    pattern3 = [3,3,1,1,2,2,4,4,5,5]
    score = [0, 0, 0]
    result = []

    for idx, answer in enumerate(answers):
        if answer == pattern1[idx%len(pattern1)]:
            score[0] += 1
        if answer == pattern2[idx%len(pattern2)]:
            score[1] += 1
        if answer == pattern3[idx%len(pattern3)]:
            score[2] += 1

    for idx, s in enumerate(score):
        if s == max(score):
            result.append(idx+1)

    return result

긴 리스트를 만들어 메모리를 차지할 필요 없이 순환 INDEX를 만들어 처리한 풀이.

기억해야 할 것

같은 패턴이 반복되는 list가 있고 그 list를 참조해야 할 때 index를 이용해 순환해야 한다면 % 개념을 이용해 index error 가 나지 않으면서 값을 지속적으로 돌릴 수 있다.

18. 체육복 (프로그래머스 Lv.1)

def solution(n, lost, reserve):
    _reserve = sorted([r for r in reserve if r not in lost])
    _lost = sorted([l for l in lost if l not in reserve])
    for r in _reserve:
        f = r - 1
        b = r + 1
        if f in _lost:
            _lost.remove(f)
        elif b in _lost:
            _lost.remove(b)
    return n - len(_lost)

def solution(n, lost, reserve):
    _reserve = set(reserve) - set(lost)
    _lost = set(lost) - set(reserve)
    for r in _reserve:
        f = r - 1
        b = r + 1
        if f in _lost:
            _lost.remove(f)
        elif b in _lost:
            _lost.remove(b)
    return n - len(_lost)

기억해야 할 것

두 리스트간 중복된 내용을 제거하려면 set 자료구조를 사용해 - 연산을 실시하면 된다. 좀더 효율적!

추가로 정렬이 됐다는 말이 문제에 없으면 정렬을 꼭 해주자..

19. 폰켓몬 (프로그래머스 Lv.1)

전체 리스트의 길이의 절반에 해당하는 폰켓몬을 고르는 문제로 가장 다양하게 고를 수 있는 폰켓몬의 수를 찾는 문제였다.

처음엔 그냥 pick 문제라 생각하고 combination 패키지를 사용하려 했으나 시간초과가 났다.

pick된 폰켓몬의 종류는 고유한 값이라는 점에서 dictionary 자료구조를 생각.

딕셔너리의 길이가 pick 할 폰켓몬 수의 길이보다 작거나 같다면 가능한 종류의 최대값은 딕셔너리의 길이이고

아니라면 pick할 포켓몬의 종류 수 이다.

def solution(nums):
    pickNum = len(nums) // 2
    pocket_dict = {}
    for num in nums:
        if num in pocket_dict:
            pocket_dict[num] += 1
        else:
            pocket_dict[num] = 1
    if pickNum <= len(pocket_dict):
        return pickNum
    else:
        return len(pocket_dict)

ㅋㅋ 파이썬 미쳤네

def solution(ls):
    return min(len(ls)/2, len(set(ls)))

20. 실패율 (프로그래머스 Lv.1)

게임에서 해당 스테이지의 실패율을 구하는 문제이다.

개념은 쉽다. 그런데 해당 스테이지를 통과한 녀석을 예외처리 하는 부분이 좀 힘들었었는데...

일단 계속 문제푸는 방식이 BruteForce라 생각의 전환이 좀 필요할 것 같다.


def solution(N, stages):
    stage_dict = {}
    failRate = {}
    stages.sort()
    
    for num in range(1, N+2):
        stage_dict[num] = 0
    for num in stages:
        stage_dict[num] += 1
    
    keys = list(stage_dict.keys())
    values = list(stage_dict.values())
    
    for i in range(len(keys)):
        if sum(values[i:]) == 0:
            stage_dict[keys[i]] = 0
        else:
            stage_dict[keys[i]] = values[i] / sum(values[i:])
    stage_dict.pop(N+1)
    
    temp = sorted(stage_dict.items(), key = lambda x : -x[1])
    
    for i in range(len(temp)):
        temp[i] = temp[i][0]
        
    return temp

와... 남이 푼거 보니까 난 진짜 파이썬을 파이썬처럼 못쓰는거 같다.

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)

stages 배열의 길이 수가 총 인원 수라는 개념으로 풀어낸 풀이이다. 우왕...

기억해야 할 것

d = {"dream": 0, "car": 99, "blockdmask": 1, "error": 30, "app": 20}

# value로 오름차순
d2 = sorted(d.items(), key=lambda x: x[1])

21 번 문제부터는 깃허브로 넘어감.

'알고리즘 > 개념' 카테고리의 다른 글

Dynamic programming (1)	2021.10.24
Divide and Conquer 알고리즘 (0)	2021.10.16
BruteForce 알고리즘 (0)	2021.10.16
정렬 알고리즘 (0)	2021.10.16
탐색 알고리즘 (0)	2021.10.16

개발자의 기록장 블로그

만나서 반가워 !
이거 좋아해?

메...모...정..리..

1. 각 자리수의 합

2. 순열 검사

3. 나머지 한 점

4. 가장 큰 사각형 구하기

5. 땅따먹기

6. 덩치들 (백준 7568번)

7. 최대공약수 최소공배수

8. 나이순 정렬 (백준 10814번)

9. 괄호 (백준 9012번)

10. 소수구하기 (백준 1929번)

11. 균형맞추기 (백준 4949번)

11. 신고결과 받기 (프로그래머스 Lv.1)

12. 로또의 최고 순번 (프로그래머스 Lv.1)

13. 신규 아이디 추천 (프로그래머스 Lv.1)

14. 키패드 누르기 (프로그래머스 Lv.1)

13. 인형뽑기 (프로그래머스 Lv.1)

14. 없는 숫자 더하기 (프로그래머스 Lv.1)

15. 소수만들기 (프로그래머스 Lv.1)

16. 완주하지 못한 사람(프로그래머스 Lv.1)

17. 모의고사 (프로그래머스 Lv.1)

18. 체육복 (프로그래머스 Lv.1)

19. 폰켓몬 (프로그래머스 Lv.1)

20. 실패율 (프로그래머스 Lv.1)

'알고리즘 > 개념' 카테고리의 다른 글

검색할 키워드가 떠오르지 않는다면, 아래 태그들을 클릭 해보세요!

티스토리툴바

개발자의 기록장 블로그

만나서 반가워 ! 이거 좋아해?

1. 각 자리수의 합

2. 순열 검사

3. 나머지 한 점

4. 가장 큰 사각형 구하기

5. 땅따먹기

6. 덩치들 (백준 7568번)

7. 최대공약수 최소공배수

8. 나이순 정렬 (백준 10814번)

9. 괄호 (백준 9012번)

10. 소수구하기 (백준 1929번)

11. 균형맞추기 (백준 4949번)

11. 신고결과 받기 (프로그래머스 Lv.1)

12. 로또의 최고 순번 (프로그래머스 Lv.1)

13. 신규 아이디 추천 (프로그래머스 Lv.1)

14. 키패드 누르기 (프로그래머스 Lv.1)

13. 인형뽑기 (프로그래머스 Lv.1)

14. 없는 숫자 더하기 (프로그래머스 Lv.1)

15. 소수만들기 (프로그래머스 Lv.1)

16. 완주하지 못한 사람(프로그래머스 Lv.1)

17. 모의고사 (프로그래머스 Lv.1)

18. 체육복 (프로그래머스 Lv.1)

19. 폰켓몬 (프로그래머스 Lv.1)

20. 실패율 (프로그래머스 Lv.1)

'알고리즘 > 개념' 카테고리의 다른 글

티스토리툴바

만나서 반가워 !
이거 좋아해?