ram2

공유 타이머 서비스

coram22 — Tue, 24 Feb 2026 13:27:37 +0900

발표를 하거나, 타인과 같은 타이머를 공유해야 하는 상황을 해결하기 위해 바이브코딩으로 만든 서비스입니다.

https://timesharing-rose.vercel.app

Create Next App

Shared Timer 링크를 공유하면 다른 기기에서도 같은 타이머를 볼 수 있어요. 새 방 만들기 * 방 ID는 랜덤으로 생성돼요. (사실상 비공개 링크)

timesharing-rose.vercel.app

방을 만들고, 해당 링크를 공유하면, 언제 어디서든 같은 타이머를 공유할 수 있어요!!!

[python] 리스트에서 슬라이싱 후 리스트 형태가 아닌 요소들만 추가하는 방법

coram22 — Thu, 21 Aug 2025 00:58:22 +0900

Python에서 리스트를 다루다 보면, 한 리스트의 일부 요소를 slicing을 사용해서 다른 리스트에 추가할 때, append를 사용하면 리스트 형태로 추가된다.

answer.append(a[i:])
# [[1, 2, 3], 2, [2, 3], 3, 3, [3]] # append 사용한 결과

이 때, 리스트 형태가 아닌 slicing 범위에 있는 각 요소들을 개별 요소로 추가하고 싶을 때는 어떻게 해야할까?

# [1, 2, 3, 2, 2, 3, 3, 3, 3]

위와 같이 추가하기 위해서는 extend 함수를 사용하면 된다.

answer.extend(a[i:])

이렇게 append가 아닌, extend를 사용하면 이중리스트가 아닌 각각의 개별 요소로 추가할 수 있다!

[프로그래머스] : 영어 끝말잇기

coram22 — Thu, 17 Jul 2025 17:39:06 +0900

문제

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

이 문제는 n명의 사람들이 끝말잇기 게임을 할 때, (1)잘못된 단어를 말하거나, 이전에 말한 (2)중복된 단어를 말하는 경우 종료된다.

이 때, 오답을 말한 사람이 (1)몇 번째 사람이며, 게임이 종료되는 시점은 (2)몇 번째 턴에 종료되는지를 구하면 된다.

즉, 정리하면 게임이 종료되는 조건은 다음과 같다.

(1)잘못된 단어 : 마지막 단어의 끝 문자로 시작하지 않는 단어

(2)중복된 단어 : 앞에 언급된 단어와 같은 단어

그리고, 우리가 구해야 하는 것은 두 가지 이다.

(1)몇 번째 사람 : 오답을 말한 사람은 n명 중 몇 번째 사람인지

(2)몇 번째 턴에 종료 : 총 몇 번의 턴이 지나는 시점에 오답이 발생했는지

이 문제를 해결하기 위해 3가지 함수를 만들었다.

1) duplicate_word(n, words) : 중복된 단어를 말했는지 검사하는 함수. 만약 있다면, 중복된 단어의 index를 반환한다.

2) not_correct(n, words) : 마지막 단어의 끝 알파벳으로 시작하는 단어를 올바르게 말했는지 검사하는 함수. 만약 다르다면, 해당 단어의 index를 반환한다.

- 지금 다시 생각해보니, 1,2 함수에서는 n을 받지 않아도 된다.

3) find_num_turn(n, idx) : 오답 단어의 idx 위치와 참여자 수를 받아 오답을 말한 사람이 몇 번째 사람인지, 몇 번째 턴인지를 반환하는 함수이다.

이렇게 각각 함수를 만들어 문제를 해결했다.

다음은 이를 구체적으로 구현한 코드이다.

정답

def solution(n, words):
    answer = []
    idx = 0
    turn = 0
    p_id = 0
    
    # 두 함수에서 가장 작은 값을 찾는다 -> 먼저 발견된 오답에 맞게 게임이 종료돼야 하므로
    idx = min(duplicate_word(n, words), not_correct(n, words))
    # idx의 초기값을 각 함수 내에서 101로 잡았기 때문에 101이 아니면 그전에 종료되는 조건이 있다는 것
    if idx != 101 :
        p_id, turn = find_num_turn(n, idx) # 각 idx에 맞는 참가자 번호와 게임의 턴을 구하는 함수
        answer = [p_id, turn]
    else :
        answer = [0,0]
    return answer

# 중복된 단어가 있는지 찾기 위한 함수
def duplicate_word(n, words) :
    said = []
    idx = 101
    for i in range(len(words)) :
        if words[i] in said :
                print(words[i])
                idx = i
                break
        said.append(words[i])
    return idx

# 끝 단어로 시작하지 않는 단어가 있는지 찾기 위한 함수
def not_correct(n, words) :
    idx = 101
    for i in range(len(words)-1) :
        if words[i][-1] != words[i+1][0] :
            print(words[i+1])
            idx = i+1
            break
    return idx

# 오답 단어 idx를 기준으로 계산하여 오답을 말한 사람과 게임의 차례를 구하는 함수
def find_num_turn(n, idx) :
    p_id = (idx % n)+1
    turn = ((idx) // n)+1
    return p_id, turn

분명 이러한 문제를 푸는 통상적인 풀이와 방법이 있겠지만 생각나는대로 풀어보았다.

[프로그래머스] : [1차] 비밀지도

coram22 — Wed, 16 Jul 2025 17:10:50 +0900

문제

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 설명

네오는 평소 프로도가 비상금을 숨겨놓는 장소를 알려줄 비밀지도를 손에 넣었다. 그런데 이 비밀지도는 숫자로 암호화되어 있어 위치를 확인하기 위해서는 암호를 해독해야 한다. 다행히 지도 암호를 해독할 방법을 적어놓은 메모도 함께 발견했다.

지도는 한 변의 길이가 n인 정사각형 배열 형태로, 각 칸은 "공백"(" ") 또는 "벽"("#") 두 종류로 이루어져 있다.
전체 지도는 두 장의 지도를 겹쳐서 얻을 수 있다. 각각 "지도 1"과 "지도 2"라고 하자. 지도 1 또는 지도 2 중 어느 하나라도 벽인 부분은 전체 지도에서도 벽이다. 지도 1과 지도 2에서 모두 공백인 부분은 전체 지도에서도 공백이다.
"지도 1"과 "지도 2"는 각각 정수 배열로 암호화되어 있다.
암호화된 배열은 지도의 각 가로줄에서 벽 부분을 1, 공백 부분을 0으로 부호화했을 때 얻어지는 이진수에 해당하는 값의 배열이다.

네오가 프로도의 비상금을 손에 넣을 수 있도록, 비밀지도의 암호를 해독하는 작업을 도와줄 프로그램을 작성하라.

입력 형식

입력으로 지도의 한 변 크기 n 과 2개의 정수 배열 arr1, arr2가 들어온다.

1 ≦ n ≦ 16
arr1, arr2는 길이 n인 정수 배열로 주어진다.
정수 배열의 각 원소 x를 이진수로 변환했을 때의 길이는 n 이하이다. 즉, 0 ≦ x ≦ 2n - 1을 만족한다.

출력 형식

원래의 비밀지도를 해독하여 '#', 공백으로 구성된 문자열 배열로 출력하라.

입출력 예제

풀이

이 문제는 십진수를 이진수로 변환해서, 비트 연산자를 사용해 풀면 된다.

1. 각 배열의 숫자를 이진수로 변환하고

2. 변환한 이진수끼리 비트 연산자 | 를 사용해 둘 다 0인 경우만 0이 되도록 만든다.

이 때 | 연산자는 (OR) 연산자로, '1100' | '1010' => '1110' 으로 계산된다.
같이 알면 좋은 & 연산자는 (AND) 연산자로, '1100' & '1010' => 1000' 으로 계산된다.
즉, |는 둘 중 하나만 1이더라도 1로 계산되고,
&는 둘 다 1이어야만 1로 계산된다.

3. 비트 연산자로 변환된 수가 1->'#', 0-> ' ' 으로 변환해준다.

정답 코드

위 순서대로 구현하면 다음과 같이 구현할 수 있다.

# 최종 결과를 만드는 메인 함수
def solution(n, arr1, arr2):
    # arr1과 arr2를 비트 OR 연산 후 이진 문자열 리스트로 변환
    result = binary_num(arr1, arr2, n)
    answer = []

    # 각 이진 문자열을 '#' 또는 ' '로 변환
    for i in range(len(result)):
        ans = ''
        for j in range(len(result[i])):
            if result[i][j] == '1':  # '1'이면 벽이므로 '#'
                ans += "#"
            else:                   # '0'이면 공백
                ans += " "
        answer.append(ans)  # 완성된 문자열을 리스트에 추가
    return answer

# 두 리스트의 각 요소를 비트 OR 연산한 후, n자리 이진 문자열로 변환하는 함수
def binary_num(arr1, arr2, n):
    result = []
    for a, b in zip(arr1, arr2):  # arr1과 arr2에서 같은 인덱스끼리 짝지어 반복
        binary = bin(a | b)[2:].zfill(n)  # 비트 OR 후, 앞의 '0b' 제거하고 n자릿수로 채움
        result.append(binary)  # 변환된 이진 문자열을 결과 리스트에 추가
    return result

이 때 새롭게 알게된 함수는 .zfill()이다. 이 함수는 n자리에서 빈 곳을 채워주는 함수이다.

bin 함수를 잘 사용하는 것과 .zfill()과 같이 자릿수를 고려하는 것이 중요한 핵심이었던 것 같다.

[프로그래머스] : 연속 부분 수열 합의 개수

coram22 — Mon, 14 Jul 2025 02:54:49 +0900

문제

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

문제 설명

철호는 수열을 가지고 놀기 좋아합니다. 어느 날 철호는 어떤 자연수로 이루어진 원형 수열의 연속하는 부분 수열의 합으로 만들 수 있는 수가 모두 몇 가지인지 알아보고 싶어졌습니다. 원형 수열이란 일반적인 수열에서 처음과 끝이 연결된 형태의 수열을 말합니다. 예를 들어 수열 [7, 9, 1, 1, 4] 로 원형 수열을 만들면 다음과 같습니다.

원형 수열은 처음과 끝이 연결되어 끊기는 부분이 없기 때문에 연속하는 부분 수열도 일반적인 수열보다 많아집니다.
원형 수열의 모든 원소 elements가 순서대로 주어질 때, 원형 수열의 연속 부분 수열 합으로 만들 수 있는 수의 개수를 return 하도록 solution 함수를 완성해주세요.

제한사항

3 ≤ elements의 길이 ≤ 1,000
1 ≤ elements의 원소 ≤ 1,000

입출력 예

입출력 예 설명

입출력 예 #1
길이가 1인 연속 부분 수열로부터 [1, 4, 7, 9] 네 가지의 합이 나올 수 있습니다.
길이가 2인 연속 부분 수열로부터 [2, 5, 10, 11, 16] 다섯 가지의 합이 나올 수 있습니다.
길이가 3인 연속 부분 수열로부터 [6, 11, 12, 17, 20] 다섯 가지의 합이 나올 수 있습니다.
길이가 4인 연속 부분 수열로부터 [13, 15, 18, 21] 네 가지의 합이 나올 수 있습니다.
길이가 5인 연속 부분 수열로부터 [22] 한 가지의 합이 나올 수 있습니다.
이들 중 중복되는 값을 제외하면 다음과 같은 18가지의 수들을 얻습니다.
[1, 2, 4, 5, 6, 7, 9, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21, 22]

풀이

이 문제는 원형으로 가장 끝값과 처음 값이 연결되어 있다는 것을 잘 기억해야 한다.

문제를 푼 방식은 다음과 같다.

1. 기존 리스트를 복사해 temp_e 변수에 저장한다.

2. temp_e에서 n개씩 묶어 합을 구할텐데, 뒤에 가장 끝 요소와 연결되는 원소들을 미리 붙여준다.

예를 들어, n이 3이라면 3개씩 묶을 수 있다.
7, 9, 1, 1, 4에서 4, 7, 9가 나올 수 있으므로 미리 7, 9를 뒤에 붙여준다.
그래서 다음과 같이 정리할 수 있다.
i) n = 2 인 경우, 7, 9, 1, 1, 4 => 7, 9, 1, 1, 4, 7
i) n = 3 인 경우, 7, 9, 1, 1, 4 => 7, 9, 1, 1, 4, 7, 9
i) n = 4 인 경우, 7, 9, 1, 1, 4 => 7, 9, 1, 1, 4, 7, 9, 1
이렇게 미리 붙여 넣은 배열을 다시 만들어주면, 쉽게 합을 구할 수 있다.

3. find_case라는 함수를 만들어 n개씩 묶어 나올 수 있는 합을 구한다.

정답 코드

위 순서대로 구현하면 다음과 같이 구현할 수 있다.

def solution(elements):
    fin_list = [] # 최종적으로 발생한 모든 합을 저장할 리스트형의 변수
    fin_list += elements # 1개씩 묶는 경우, 기존 리스트의 각 요소가 들어가므로 추가
    fin_list.append(sum(elements)) # 가장 마지막의 경우, 모든 요소의 합이 되므로 미리 추가
    
    # 반복문으로 2개씩, 3개씩, .. 전체개수-1개씩 묶었을 떄 나오는 합을 구한다.
    for i in range(2, len(elements)) :
    	# find_case에서 반환된 값을 리스트에 추가한다.
        fin_list += find_case(i, elements)
    return len(set(fin_list)) # 중복을 제거해야 하므로, set으로 변환한 뒤 길이 출력

# n개씩 elements를 묶었을 때 나오는 합의 경우들을 반환하는 함수이다.
def find_case(n, elements) :
    temp_e = elements.copy() # 복사하지 않으면 기존 elements까지 바뀌므로 copy()한다.
    sum_list = [] # 반환하기 위한 합들을 저장하는 리스트형 변수
    for i in range(n-1) : # 끝 요소와 연결되는 앞부분의 요소들을 미리 뒤에 붙여준다.
        temp_e.append(elements[i])
    for i in range(len(temp_e)-n+1): # 반복문으로 n개씩 묶어 합을 구한다.
        temp = temp_e[i:i+(n%cnt)]
        sum_list.append(sum(temp))
    return sum_list

코드와 옆에 있는 주석을 차근차근 읽으면 이해에 많은 도움이 될 것이다.

물론 이렇게 푸는 사람들은 거의 없었지만, 도움이 되었기를..!

[프로그래머스] : 멀리뛰기

coram22 — Sun, 13 Jul 2025 16:51:44 +0900

문제

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

효진이는 멀리 뛰기를 연습하고 있습니다. 효진이는 한번에 1칸, 또는 2칸을 뛸 수 있습니다. 칸이 총 4개 있을 때, 효진이는
(1칸, 1칸, 1칸, 1칸)
(1칸, 2칸, 1칸)
(1칸, 1칸, 2칸)
(2칸, 1칸, 1칸)
(2칸, 2칸)
의 5가지 방법으로 맨 끝 칸에 도달할 수 있습니다. 멀리뛰기에 사용될 칸의 수 n이 주어질 때, 효진이가 끝에 도달하는 방법이 몇 가지인지 알아내, 여기에 1234567를 나눈 나머지를 리턴하는 함수, solution을 완성하세요. 예를 들어 4가 입력된다면, 5를 return하면 됩니다.

입출력 예

입출력 예 설명

입출력 예 #1
위에서 설명한 내용과 같습니다.

입출력 예 #2
(2칸, 1칸)
(1칸, 2칸)
(1칸, 1칸, 1칸)
총 3가지 방법으로 멀리 뛸 수 있습니다.

풀이

위 문제는 DP를 사용해서 해결할 수 있다.

먼저, 1과 2를 사용하여 합이 n이 되는 모든 경우의 수를 구하고

그 개수에서 1234567를 나눈 나머지를 반환하면 된다.

1. 1과 2를 사용하여 합이 n이 되는 모든 경우의 수 구하기

def count_combinations(n):
    dp = [0] * (n + 1)   # dp[i]는 합이 i가 되는 순열의 수
    dp[0] = 1            # 합이 0이 되는 방법은 "아무것도 선택하지 않기" 1가지

    for i in range(1, n + 1):           # i는 현재 만들고 싶은 목표 합
        for num in [1, 2]:              # num은 사용할 수 있는 숫자 (1 또는 2)
            if i - num >= 0:            # 음수가 되면 안 되니까 확인
                dp[i] += dp[i - num]    # 이전 경우에 num을 붙여서 현재 합 만들기

    return dp[n]  # 최종적으로 합이 n이 되는 경우의 수

이렇게 하면, 1과 2를 사용해 합이 n이 되는 경우의 수를 구할 수 있다.

2. 1234567에서 나눈 나머지

print(count_combinations(n) % 1234567)

이렇게 구한 개수에서 1234567을 나눈 나머지를 구하면 된다.

정답

def solution(n):
    return count_combinations(n) % 1234567

def count_combinations(n):
    dp = [0] * (n + 1)
    dp[0] = 1
    for i in range(1, n + 1):
        for num in [1, 2]:
            if i - num >= 0:
                dp[i] += dp[i - num]
    return dp[n]

DP 알고리즘이 궁금하다면 아래 글을 참고해주세요.

https://haram22.tistory.com/95

[DP] 파이썬으로 Dynamic Programming 정복하기

coram22 — Sun, 13 Jul 2025 16:40:45 +0900

코테 문제를 풀다 보면, 자주 나오는 개념인 Dynamic Programming에 대해 정리하고자 한다.

DP는 큰 문제를 작은 문제로 나눠서 푸는 방식으로, 단순히 쪼개는 것 뿐 아니라 이미 계산한 결과를 저장해서 다시 계산하는 수고를 덜어주는 방법이다.

즉, 반복되는 계산을 줄이기 위해, 중간 결과를 저장(memoization 또는 tabulation) 해두고 재활용하는 방식이다.

DP는 언제 사용할까?

아래 두 조건을 만족할 때 쓸 수 있다.

1. 겹치는 부분 문제 : 같은 문제를 여러 번 다시 계산해야 하는 상황

2. 최적 부분 구조 : 큰 문제의 최적해가 작은 문제들의 최적해로 이루어져 있는 구조

가장 대표적인 예는 피보나치 수열을 구하는 문제이다.

DP 사용 방식은?

DP는 크게 두 가지 방식으로 사용법을 나눌 수 있다.

1. Top-down 방식 (재귀 + Memoization)

이름 그대로 위에서부터 내려오면서 계산하고, 중간 결과를 저장한다.
주로 재귀함수를 사용해서 구현할 수 있다.
대표적인 예가 피보나치 수열!

2. Bottom-up 방식 (반복문 + Tabulation)

이름대로 아래에서부터 차곡차곡 계산해서 최종 결과를 도출하는 방식이다.
주로 반복문으로 구현한다.

DP가 사용되는 문제 예시들

최대/최소값을 구하는 문제
특정 조건을 만족하는 개수를 구하는 문제
경로의 수, 방법의 수를 구하는 문제
배낭 문제(0/1 Knapsack), 동전 교환 문제 등
정수 분할 문제

정수 분할(Partition Problem) 문제 풀이 - 순서고려X

그 중, 문제를 풀며 가장 많이 주저했던 유형을 정리하고자 한다. 정수 분할문제는 다음과 같은 경우이다.

양의 정수들의 조합 중에서, 그 합이 정수 n이 되는 경우의 수 구하기

예를 들어, n = 4일 때, 가능한 조합(순서를 무시)은:

1 + 1 + 1 + 1
1 + 1 + 2
2 + 2
1 + 3
4

→ 총 5가지

이러한 경우의 수를 구하는 DP를 구현해보자.

def count_combinations(n):
    dp = [0] * (n + 1)
    dp[0] = 1  # 합이 0이 되는 방법은 '아무것도 선택하지 않는 1가지'뿐

    # 1부터 n까지의 숫자를 사용해서 조합을 만듦
    for num in range(1, n + 1):
        for i in range(num, n + 1):
            dp[i] += dp[i - num]

    return dp[n]

dp[i]는 "합이 i가 되는 조합의 수"를 저장한다.
처음엔 dp[0] = 1 → 아무것도 안 써서 0을 만드는 경우 한 가지.
그 다음, 숫자 1부터 n까지 차례대로 사용하면서, 각 숫자를 사용해서 만들 수 있는 합들을 업데이트 한다.
이때는 중복 조합은 허용하지만 순서는 무시.

정수 분할(Partition Problem) 문제 풀이 - 순서고려O

순서를 고려하는 방법은 Permutation(순열) 문제이다.

def count_permutations(n):
    dp = [0] * (n + 1)
    dp[0] = 1  # base case

    for i in range(1, n + 1):
        for num in range(1, n + 1):
            if i - num >= 0:
                dp[i] += dp[i - num]

    return dp[n]

프로그래머스 : 귤 고르기

coram22 — Sat, 28 Jun 2025 16:47:13 +0900

문제 설명

경화는 과수원에서 귤을 수확했습니다. 경화는 수확한 귤 중 'k'개를 골라 상자 하나에 담아 판매하려고 합니다. 그런데 수확한 귤의 크기가 일정하지 않아 보기에 좋지 않다고 생각한 경화는 귤을 크기별로 분류했을 때 서로 다른 종류의 수를 최소화하고 싶습니다.

예를 들어, 경화가 수확한 귤 8개의 크기가 [1, 3, 2, 5, 4, 5, 2, 3] 이라고 합시다. 경화가 귤 6개를 판매하고 싶다면, 크기가 1, 4인 귤을 제외한 여섯 개의 귤을 상자에 담으면, 귤의 크기의 종류가 2, 3, 5로 총 3가지가 되며 이때가 서로 다른 종류가 최소일 때입니다.

경화가 한 상자에 담으려는 귤의 개수 k와 귤의 크기를 담은 배열 tangerine이 매개변수로 주어집니다. 경화가 귤 k개를 고를 때 크기가 서로 다른 종류의 수의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한사항

1 ≤ k ≤ tangerine의 길이 ≤ 100,000
1 ≤ tangerine의 원소 ≤ 10,000,000

입출력 예

풀이

from collections import Counter

def solution(k, tangerine):
    answer = 0
    counter = Counter(tangerine)
    counts = sorted(counter.values(), reverse=True)
    for i in range(len(counts)) :
        k -= counts[i]
        answer += 1
        if k <= 0 :
            break
    return answer

주어진 문제는 파이썬의 collections를 통해 풀 수 있다. Counter를 import하면 내장되어 있는 Counter 함수를 사용할 수 있다.

counter = Counter(tangerine)

// 실행결과 (입력값: 6, [1, 3, 2, 5, 4, 5, 2, 3])
// Counter({3: 2, 2: 2, 5: 2, 1: 1, 4: 1})

이렇게 Counter함수를 사용하면 입력된 리스트에서 각 숫자가 총 몇 번 나왔는지를 딕셔너리형태로 세어 저장해준다.

이를 사용하면 중첩for문을 사용해 set으로 바꾸고, 각 숫자가 나오는 횟수를 찾아 저장하지 않아도 된다.

시간복잡도 또한 한번의 순회로 모두 구할 수 있으므로 O(N)의 시간 복잡도를 갖는다.

앞으로 문제를 풀다 보면, 한 리스트에 숫자가 몇 번 나오는지 구하는 문제들이 종종 있는데, collections와 Counter를 기억하면 좋을 것 같다.

백준 17219: 비밀번호 찾기

coram22 — Tue, 13 May 2025 23:33:52 +0900

문제

이 문제는 각 사이트와 비밀번호를 저장해두고, 특정 사이트의 비밀번호들을 찾는 문제이다.

다음과 같은 순서로 접근했다.

1. 전체 사이트 개수, 찾고 싶은 사이트 개수를 입력받는다.

2. 사이트와 해당 사이트의 비밀번호를 딕셔너리형태로 저장한다.

3. 찾고 싶은 사이트의 value값을 찾아 answer라는 리스트에 저장한다.

4. 원하는 사이트의 비밀번호만 담긴 answer 리스트를 출력한다.

풀이 및 알고리즘

해당 문제에서는 dictionary의 특성을 사용하여 풀었다.

dictionay는 키-값 형태로 데이터를 저장하고, key값을 알면 이와 매칭된 value를 찾을 수 있다.

솔직히 말하면 dictionary로 푸는 것이 hash table 기반의 탐색임을 몰랐다...

python의 dict()는 해시테이블 자료구조이다.

Hash Table은 Key-value 데이터를 저장하고, 빠르게 찾는 자료구조를 말한다.

내가 푼 코드에서는 주소와 비밀번호를 key-value 형태로 딕셔너리에 저장하여 pwDict에서 원하는 사이트의 비밀번호를 바로 찾으므로 O(1)만큼의 시간이 걸린다.

코드

a, b = map(int, input().split())
pwDict = dict()
answer = [''] * b
for i in range(a) :
    s, p = map(str, input().split())
    pwDict[s] = p

for j in range(b) :
    f = input()
    answer[j] = pwDict[f]

for i in answer :
    print(i)

백준 10989: 수 정렬하기 3

coram22 — Tue, 13 May 2025 23:08:07 +0900

문제

https://www.acmicpc.net/problem/10989

1. 수의 개수인 N을 입력받는다.

2. N개의 숫자를 입력받는다.

3. 입력받은 수를 오름차순으로 정렬하여 출력한다.

풀이 및 알고리즘

처음에는 수를 입력할 때마다 리스트에 append하고, 파이썬에 내장되어 있는 sort 함수를 사용하였다.

하지만 메모리 초과가 발생했다. 찾아보니 입력받자마자 원소를 append하는 것은 시간이 오래 걸린다는 것을 알게 되었다.

리스트의 append는 비용이 발생한다.
-> python의 리스트는 동적 배열인데, append할 때 메모리가 꽉 차면 더 큰 새로운 배열을 만들고 기존 데이터를 복사한다.
-> 그래서, 메모리가 작게 설정되어 있는 이 문제를 풀기 위해서는 이러한 복사하여 중복되는 메모리 문제를 해결해야 한다.

그럼 메모리초과를 해결하기 위해서는 어떻게 해야할까?

기존 구현 방식에서의 문제가 append할 때 비용이 발생한다는 문제였는데, 이를 해결하기 위해서는 공간을 미리 할당하는 것도 방법이다.

공간을 미리 할당해두면 복사가 필요없어서 훨씬 빠르다고 한다.

정답

import sys
N = int(sys.stdin.readline())
answer = [0] * 10001

for i in range(N) :
    a = int(sys.stdin.readline())
    answer[a] += 1

for i in range(10001):
    if answer[i] != 0 :
        for j in range(answer[i]) :
            print(i)

문제에서 최대 입력이 10000라고 했으므로, 10001만큼의 공간을 미리 할당해둔다.

그래서, 특정 숫자가 나왔을 때 그 숫자를 인덱스로 갖는 공간에 접근하여 1씩 증가시킨다.

이렇게 하면 불필요한 중복을 없앨 수 있을 뿐 아니라 메모리초과 문제도 해결할 수 있다.