공부블로그

TODAY TIL

안녕하세요! 이번 포스팅에서는 폰켓몬 선택과 관련된 흥미로운 코딩 문제를 다뤄보겠습니다. 단계적으로 설명하고 코드 구현을 공유합니다.

문제 설명

여러분은 오랜 여행 끝에 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 여러분에게 연구실에 있는 N마리의 폰켓몬 중 N/2마리를 선택해도 좋다고 했습니다. 같은 종류의 폰켓몬은 같은 번호를 가지며, 여러분은 최대한 다양한 종류의 폰켓몬을 선택하고 싶습니다.

문제의 목표: N마리의 폰켓몬 중 최대 N/2마리를 선택할 때, 가장 다양한 종류의 폰켓몬을 선택하는 경우를 찾고, 그때의 폰켓몬 종류의 수를 반환하는 것입니다.

제한사항

• nums는 폰켓몬의 종류 번호가 담긴 1차원 배열입니다.
• N은 항상 짝수이며, 1 이상 10,000 이하의 자연수입니다.
• 폰켓몬의 종류 번호는 1 이상 200,000 이하의 자연수입니다.

단계별 해결 방법

1. 입력 분석:
   • nums 배열에는 각 폰켓몬의 종류 번호가 포함되어 있습니다.
   • 배열의 길이 N은 항상 짝수입니다. 따라서 N/2마리의 폰켓몬을 선택할 수 있습니다.
2. 중복 제거:
   • set 자료형을 사용하여 배열에서 중복을 제거하고 고유한 폰켓몬 종류의 수를 구합니다.
3. 최대 선택 가능한 폰켓몬 수 계산:
   • 선택할 수 있는 최대 종류의 개수는 min(len(unique_pokemon), N // 2)입니다.
     • len(unique_pokemon)은 중복 제거 후 고유한 종류의 개수입니다.
     • N // 2는 선택할 수 있는 폰켓몬의 총 수입니다.
4. 코드 구현

def solution(nums):
    # 중복 제거 후 고유한 폰켓몬 종류의 수 계산
    unique_pokemon = set(nums)
    
    # 선택할 수 있는 폰켓몬 종류의 최댓값 계산
    return min(len(unique_pokemon), len(nums) // 2)

코드 설명

• set(nums)를 사용하여 nums 배열에서 중복된 종류 번호를 제거합니다.
• min(len(unique_pokemon), len(nums) // 2)를 사용해 선택할 수 있는 폰켓몬 종류의 최대 개수를 계산합니다.
  • 고유한 폰켓몬 종류의 수(len(unique_pokemon))가 선택 가능한 수(N/2)보다 작으면 모든 고유 종류를 선택할 수 있습니다.
  • 고유한 폰켓몬 종류의 수가 N/2보다 크다면 N/2만큼의 고유 종류만 선택할 수 있습니다.

예제

입력: nums = [3, 1, 2, 3]

1. set(nums) 결과: {1, 2, 3} (고유한 폰켓몬 종류: 3개)
2. 선택할 수 있는 최대 개수: len(nums) // 2 = 2
3. 반환값: min(3, 2) = 2

결과: 최대 2종류의 폰켓몬을 선택할 수 있습니다.

결론

이 문제는 배열에서 중복된 항목을 제거하고 선택할 수 있는 폰켓몬의 종류를 비교하는 간단한 문제였습니다. 중복 제거를 위한 set 사용과 최소값 계산을 통해 다양한 경우를 쉽게 처리할 수 있었습니다.

이제 여러분도 다양한 알고리즘 문제를 해결할 때 중복 제거와 최소값 계산을 활용해 보세요!

TODAY TIL

안녕하세요! 이번 포스팅에서는 비밀번호 찾기 문제 와 관련된 흥미로운 코딩 문제를 다뤄보겠습니다. 단계적으로 설명하고 코드 구현을 공유합니다.

문제 설명

창영이는 민균이의 컴퓨터에서 비밀번호가 포함된 텍스트 파일을 얻었습니다. 이 파일에는 여러 단어가 줄마다 적혀있으며, 민균이의 비밀번호는 특정 조건을 만족해야 합니다:

1. 목록에 포함된 단어의 길이는 모두 홀수입니다.
2. 비밀번호를 뒤집은 형태의 문자열도 목록에 포함되어 있습니다.

목표는 목록에서 비밀번호를 찾아 비밀번호의 길이와 가운데 글자를 출력하는 것입니다.

문제 해결을 위한 단계별 접근 방법

1단계: 입력받기

• 첫째 줄에 단어의 개수 NNN이 주어집니다.
• 이후 NNN개의 단어를 입력받아 words 리스트에 저장합니다.

# 입력 받기
N = int(input())
words = [input().strip() for _ in range(N)]

2단계: 단어와 뒤집은 단어 비교

• 모든 단어에 대해 해당 단어의 뒤집힌 형태가 리스트에 있는지 확인합니다.
  • 예를 들어, 단어가 "tulipan"이라면, 뒤집은 형태는 "napilut"입니다.
• 이를 위해 for 루프를 사용해 words 리스트의 각 단어를 순회하며 뒤집힌 단어가 words에 있는지 검사합니다.

# 비밀번호 찾기
password = ""
for word in words:
    reversed_word = word[::-1]  # 단어 뒤집기
    if reversed_word in words:  # 뒤집은 단어가 목록에 있는지 확인
        password = word
        break

3단계: 비밀번호 길이와 가운데 글자 찾기

• 비밀번호를 찾았다면:
  • 길이는 len(password)로 구할 수 있습니다.
  • 가운데 글자는 (길이 // 2) 인덱스를 통해 찾습니다.

# 비밀번호 길이와 가운데 글자 찾기
length = len(password)
middle_char = password[length // 2]

4단계: 결과 출력

• 비밀번호의 길이와 가운데 글자를 한 줄에 출력합니다.

# 결과 출력
print(length, middle_char)

전체 코드

아래는 전체 코드를 정리한 것입니다.

# 1. 입력 받기
N = int(input())
words = [input().strip() for _ in range(N)]

# 2. 비밀번호 찾기
password = ""
for word in words:
    reversed_word = word[::-1]
    if reversed_word in words:
        password = word
        break

# 3. 비밀번호 길이와 가운데 글자 찾기
length = len(password)
middle_char = password[length // 2]

# 4. 결과 출력
print(length, middle_char)

예제와 결과

예제 입력

4
tulipan
napilut
apple
banana

예제 출력

7 i

요약

이 문제는 문자열을 뒤집어 비교하는 방법과 문자열의 가운데 글자를 찾는 기본적인 접근 방식을 통해 해결할 수 있습니다. 단계별로 문제를 나누고 각 단계에서 필요한 작업을 순차적으로 구현하면 쉽게 답을 구할 수 있습니다.

TODAY TIL

안녕하세요! 이번 포스팅에서는 군대 근무 시간 공평성 확인 문제와 관련된 흥미로운 코딩 문제를 다뤄보겠습니다. 단계적으로 설명하고 코드 구현을 공유합니다.

군대 근무 시간 공평성 확인 문제 풀이 (단계별 접근법)

문제 개요

푸앙이와 동기들은 군대에서 4교대 근무를 합니다. 각 시간대(08:00 :12:00, 12:00 : 18:00, 18:00 :22:00, 22:00 :08:00)별로 근무 시간이 다르고, 각자의 근무 시간이 최대한 공평하게 배분되기를 원합니다. 주어진 근무표가 공평하게 분배되었는지, 즉 각 근무자의 총 근무 시간 차이가 12시간 이하인지 판단하는 프로그램을 작성해보겠습니다.

단계별 문제 해결 과정

1단계: 문제 이해하기

• 주어진 정보
  • 주 수(N)가 주어지고, 각 주마다 4개의 근무 시간이 제공됩니다.
  • 시간대는 각각 4시간, 6시간, 4시간, 10시간으로 구성됩니다.
  • 근무표에서 -는 근무자가 없는 것을 의미하고, 근무자가 여러 명일 경우 공백으로 구분됩니다.
• 목표
  • 근무표에서 모든 근무자의 총 근무 시간을 계산하여, 최대 근무 시간과 최소 근무 시간의 차이가 12시간 이하인지 확인합니다.
  • 근무자가 없는 경우는 공평한 것으로 간주합니다.

2단계: 계획 세우기

1. 입력 처리: 주의 개수 N을 입력받고, 각 주별로 4줄씩 근무표를 읽어옵니다.
2. 근무 시간 계산하기: 각 시간대의 근무자를 확인하여 근무 시간을 누적합니다. 각 시간대에 따라 4, 6, 4, 10시간을 해당 근무자에게 추가합니다.
3. 공평성 검사: 모든 근무자의 근무 시간을 비교하여 차이가 12시간 이하인지 확인하고, 결과를 출력합니다.

3단계: 코드 작성 (단계별로 해결)

각 단계를 코드로 작성하면서 이해해보겠습니다

# 1. 입력 처리
N = int(input())  # 주의 개수 입력받기
schedule = [input().strip() for _ in range(N * 4)]  # 전체 근무표 입력받기

설명: N은 주의 개수이고, 근무표는 N * 4 줄로 주어집니다. schedule 리스트에 각 줄을 저장합니다.

# 2. 근무 시간 정의
hours = [4, 6, 4, 10]  # 각 시간대의 근무 시간 (08:00~12:00, 12:00~18:00, 18:00~22:00, 22:00~08:00)
work_time = {}  # 각 사람의 총 근무 시간을 저장할 딕셔너리

• 설명: 각 시간대별 근무 시간을 리스트에 저장하여 반복문에서 참조하기 쉽게 합니다.
• 딕셔너리 생성: work_time은 각 근무자의 이름을 키로 하고 근무 시간을 값으로 저장합니다.

# 3. 근무 시간 누적 계산
for i in range(N):  # 매 주마다 4개의 시간대가 있음
    for j in range(4):  # 각 시간대별로 근무자 확인
        people = schedule[i * 4 + j].split()  # 각 시간대별 근무자를 공백으로 분리
        for person in people:
            if person != '-':  # 근무자가 있는 경우만 처리
                if person not in work_time:
                    work_time[person] = 0
                work_time[person] += hours[j]  # 해당 시간대의 근무 시간을 더해줌

설명: i와 j를 이용해 각 주의 근무표에서 4개의 시간대를 차례로 가져오고, split()으로 각 시간대별 근무자를 분리합니다. -이 아닌 근무자에게만 시간을 누적합니다.

# 4. 공평성 검사
if work_time:  # 근무자가 있는 경우
    max_hours = max(work_time.values())
    min_hours = min(work_time.values())
    print("Yes" if max_hours - min_hours <= 12 else "No")
else:  # 근무자가 없는 경우
    print("Yes")

• 설명: 모든 근무자의 근무 시간을 비교하여 차이가 12시간 이하인 경우 “Yes”, 그렇지 않으면 “No”를 출력합니다.
• 예외 처리: 근무자가 없다면 바로 "Yes"를 출력합니다.

코드 전체

위의 각 단계를 하나의 코드로 합치면 다음과 같습니다.

# 입력 처리
N = int(input())  # 주의 개수
schedule = [input().strip() for _ in range(N * 4)]  # 전체 근무표 입력받기

# 각 시간대에 해당하는 근무 시간 정의
hours = [4, 6, 4, 10]  # 08:00~12:00, 12:00~18:00, 18:00~22:00, 22:00~08:00
work_time = {}  # 각 사람의 총 근무 시간을 저장할 딕셔너리

# 근무 시간 계산
for i in range(N):  # 매 주마다 4개의 시간대가 있음
    for j in range(4):  # 각 시간대별로 근무자 확인
        people = schedule[i * 4 + j].split()  # 각 시간대별 근무자를 분리
        for person in people:
            if person != '-':  # 근무자가 있는 경우만
                if person not in work_time:
                    work_time[person] = 0
                work_time[person] += hours[j]  # 해당 시간대의 근무 시간을 추가

# 공평성 검사
if work_time:  # 근무자가 있는 경우
    max_hours = max(work_time.values())
    min_hours = min(work_time.values())
    print("Yes" if max_hours - min_hours <= 12 else "No")
else:  # 근무자가 없는 경우
    print("Yes")

결론

이 문제를 통해 단계별로 문제를 나누어 풀어보았습니다. 입력을 먼저 처리한 후, 근무 시간을 누적 계산하고 공평성을 검사하는 방식으로 해결했습니다. 각 단계마다 목표를 명확히 설정하고 코드를 작성해 가면 더욱 이해하기 쉬울 것입니다.

TODAY TIL

안녕하세요! 이번 포스팅에서는 전주 듣고 노래 맞히기」 프로그램 와 관련된 흥미로운 코딩 문제를 다뤄보겠습니다. 첫 세 음만으로 노래 제목을 맞히는 프로그램을 단계적으로 설명하고 코드 구현을 공유합니다.

문제 설명

정환이 알고 있는 노래는 총 NNN개이고, 각각의 노래는 제목과 일곱 개의 음으로 이루어진 전주를 가지고 있습니다. 정환은 이 전주의 첫 세 음을 듣고 제목을 맞히려고 합니다.

요구사항

1. 주어진 첫 세 음에 맞는 노래가 딱 하나 있다면 해당 제목을 출력합니다.
2. 같은 첫 세 음으로 시작하는 노래가 여러 개면 ?를 출력합니다.
3. 해당하는 노래가 전혀 없다면 !를 출력합니다.

입력 및 출력 형식

• 첫 줄에는 정환이 알고 있는 노래의 개수 NNN과 맞히기를 시도할 노래의 개수 MMM이 주어집니다.
• 다음으로, NNN개의 노래 정보가 각각 제목과 전주의 일곱 개 음으로 주어집니다.
• 그 뒤에 맞히기를 시도할 첫 세 음이 MMM개 주어집니다.

출력 형식: 각 시도에 대해 노래 제목, ?, 또는 ! 중 하나를 한 줄에 출력합니다.

해결 방법

이 문제는 특정 패턴(첫 세 음)을 기준으로 노래 제목을 빠르게 찾는 문제입니다. 노래 정보를 사전에 딕셔너리에 저장해 두고, 맞히기 시도마다 해당 패턴이 있는지 빠르게 탐색하도록 합니다.

1. 아이디어 정리
   • 딕셔너리 자료 구조를 사용하여 각 노래의 첫 세 음을 키로 설정하고, 제목을 값으로 저장합니다.
   • 맞히기 시도 시, 입력된 첫 세 음으로 시작하는 노래를 딕셔너리에서 조회해 결과를 도출합니다.
   • 만약 해당 첫 세 음으로 시작하는 제목이 여러 개라면 ?, 하나라면 제목, 없으면 !를 출력합니다.
2. 코드 구현 단계
   • 노래 데이터 저장: 노래 정보를 입력받아 딕셔너리에 첫 세 음을 키로 하고, 제목을 리스트로 저장합니다. 리스트에 저장함으로써 다중 매칭이 가능하도록 합니다.
   • 맞히기 시도 처리: 맞히기 시도 시 딕셔너리를 조회하여 조건에 맞는 결과를 출력합니다.

# 1. 입력 받기
N, M = map(int, input().split())

# 2. 노래 정보를 저장할 딕셔너리 생성
song_dict = {}

# 3. 각 노래 정보를 입력 받아 첫 세 음을 키로 노래 제목을 딕셔너리에 저장
for _ in range(N):
    data = input().split()
    title = data[1]
    melody = ''.join(data[2:5])  # 첫 세 음만 추출
    
    if melody in song_dict:
        song_dict[melody].append(title)
    else:
        song_dict[melody] = [title]

# 4. 맞히기 시도 처리
for _ in range(M):
    guess_melody = ''.join(input().split())
    
    if guess_melody in song_dict:
        titles = song_dict[guess_melody]
        if len(titles) == 1:
            print(titles[0])  # 유일하게 일치하는 제목
        else:
            print('?')  # 여러 개의 제목이 일치
    else:
        print('!')  # 일치하는 제목이 없음

코드 설명

• 노래 정보 입력: 입력받은 각 노래 정보에서 첫 세 음만 추출해 딕셔너리에 저장합니다. 딕셔너리의 키는 첫 세 음, 값은 해당 제목의 리스트입니다.
• 맞히기 시도 처리: 첫 세 음을 기반으로 딕셔너리를 조회하여 조건에 맞는 출력을 도출합니다.

이 코드와 설명을 통해 전주 듣고 노래 맞히기 프로그램을 성공적으로 구현할 수 있습니다.

TODAY TIL

안녕하세요! 이번 포스팅에서는 보드게임 할리갈리와 관련된 흥미로운 코딩 문제를 다뤄보겠습니다. 게임에서 한별이가 종을 쳐야 할 시점을 자동으로 판단하는 코드를 작성하는 방법을 단계별로 설명하겠습니다.

📋 문제 설명

할리갈리 게임은 과일이 그려진 카드들과 종으로 이루어져 있습니다. 카드를 차례로 펼쳐서 한 종류의 과일이 정확히 5개가 될 때 가장 먼저 종을 쳐야 하는 게임입니다. 만약 한 종류의 과일이 5개가 되는 순간을 놓치지 않고 종을 칠 수 있도록 도와주는 프로그램을 만들어봅시다!

입력 조건

• 첫 번째 줄: 펼쳐진 카드의 개수 NNN
• 이후 각 줄에는 과일 종류 SSS와 과일 개수 XXX가 주어집니다.
• 과일 종류는 STRAWBERRY, BANANA, LIME, PLUM 중 하나입니다.

출력 조건

• 종을 쳐야 하면 "YES"를, 그렇지 않으면 "NO"를 출력합니다.

📝 문제 접근 방법

문제를 풀기 위해 각 과일의 개수를 누적한 후, 어떤 과일이 정확히 5개인지 확인하는 과정을 거칩니다.

1. 입력 데이터 처리: 카드의 개수 NNN과 카드별 과일 정보를 입력받습니다.
2. 과일 개수 누적: 각 과일에 대한 개수를 누적하여 관리합니다.
3. 종을 칠 조건 확인: 모든 카드의 정보를 누적한 후, 과일의 총 개수가 정확히 5인 과일이 있는지 확인합니다.

이제 코드로 문제를 해결해 보겠습니다.

# 입력 받기
N = int(input())  # 펼쳐진 카드 개수
fruit_counts = {"STRAWBERRY": 0, "BANANA": 0, "LIME": 0, "PLUM": 0}

# 카드 정보를 받아서 과일 수 누적
for _ in range(N):
    S, X = input().split()
    X = int(X)
    fruit_counts[S] += X

# 종을 칠 조건 확인
should_ring_bell = any(count == 5 for count in fruit_counts.values())

# 결과 출력
if should_ring_bell:
    print("YES")
else:
    print("NO")

코드 설명

1. fruit_counts 딕셔너리를 통해 각 과일의 개수를 0으로 초기화합니다.
2. 각 카드를 처리하면서 S와 X의 값을 읽고, fruit_counts의 해당 과일에 X를 더합니다.
3. any(count == 5 for count in fruit_counts.values())로 과일이 정확히 5개가 된 경우를 확인합니다.
4. 조건에 따라 "YES" 또는 "NO"를 출력합니다.

입력 예시

3
STRAWBERRY 2
BANANA 3
STRAWBERRY 3

출력 예시

YES

위 입력에서는 딸기가 총 5개(2 + 3)가 되므로, 한별이는 종을 쳐야 합니다.

🧩 마무리

이번 포스팅에서는 할리갈리 게임에서 종을 쳐야 하는 시점을 자동으로 판별하는 코드를 구현해 보았습니다. 과일 개수를 누적하면서 조건을 확인하는 문제를 통해 딕셔너리와 반복문의 활용을 연습할 수 있었습니다. 앞으로도 다양한 게임과 관련된 문제로 알고리즘을 즐겁게 풀어보아요!

TODAY TIL

오늘은 모스 부호를 원래의 문자로 해독하는 프로그램을 만들어 보겠습니다. 모스 부호는 짧은 신호와 긴 신호(‘.’, ‘-’)로 이루어져 있으며, 각 문자와 숫자를 모스 부호로 나타낼 수 있습니다. 예를 들어, ‘A’는 .-로, 숫자 ‘1’은 .----로 표기됩니다.

이 문제를 해결하기 위해 단계별로 접근해 보겠습니다.

문제 이해하기

• 입력: 모스 부호로 변환한 메시지와 원래 문자열의 길이 NNN이 주어집니다. 예를 들어, 모스 부호 .... . .-.. .-.. ---가 입력으로 주어지면 우리는 이것을 HELLO로 해독해야 합니다.
• 출력: 주어진 모스 부호 메시지를 원래의 문자로 해독하여, 공백 없이 출력해야 합니다.

해결 순서

1단계: 모스 부호와 문자의 매핑 사전 만들기

모스 부호를 해독하기 위해서는 모스 부호와 알파벳(또는 숫자) 간의 변환이 필요합니다. 이를 위해 morse_code_dict라는 사전을 만들어 각 모스 부호와 해당되는 문자를 연결합니다.

morse_code_dict = {
    ".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E",
    "..-.": "F", "--.": "G", "....": "H", "..": "I", ".---": "J",
    "-.-": "K", ".-..": "L", "--": "M", "-.": "N", "---": "O",
    ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
    "..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
    "--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4",
    ".....": "5", "-....": "6", "--...": "7", "---..": "8", "----.": "9",
    "-----": "0", "--..--": ",", ".-.-.-": ".", "..--..": "?", "---...": ":",
    "-....-": "-", ".--.-.": "@"
}

2단계: 입력 받기

문제에서는 두 가지 입력이 주어집니다.

• 첫 번째 줄은 변환할 원래 문자열의 길이인 NNN (사용하지 않으므로 무시 가능)
• 두 번째 줄은 모스 부호 메시지입니다.

N = int(input())  # 문자열의 길이 (사용하지 않음)
morse_code_message = input().split()  # 공백으로 구분된 모스 부호 메시지

split() 함수를 사용하여 모스 부호 메시지를 공백 기준으로 나누어 각 모스 부호가 리스트에 저장되도록 합니다.

3단계: 모스 부호 해독하기

모스 부호 메시지에 있는 각 모스 부호를 순서대로 morse_code_dict 사전을 통해 해독하여 원래의 문자로 변환합니다.

decoded_message = ""
for code in morse_code_message:
    decoded_message += morse_code_dict[code]  # 사전에서 해당 문자 찾기

이 과정에서는 for 반복문을 사용하여 각 모스 부호를 사전에서 찾아 decoded_message에 추가합니다.

4단계: 결과 출력

해독된 문자열 decoded_message를 출력합니다.

print(decoded_message)

전체 코드

아래는 위의 단계를 모두 포함한 전체 코드입니다

# 모스 부호와 문자 매핑 사전 만들기
morse_code_dict = {
    ".-": "A", "-...": "B", "-.-.": "C", "-..": "D", ".": "E",
    "..-.": "F", "--.": "G", "....": "H", "..": "I", ".---": "J",
    "-.-": "K", ".-..": "L", "--": "M", "-.": "N", "---": "O",
    ".--.": "P", "--.-": "Q", ".-.": "R", "...": "S", "-": "T",
    "..-": "U", "...-": "V", ".--": "W", "-..-": "X", "-.--": "Y",
    "--..": "Z", ".----": "1", "..---": "2", "...--": "3", "....-": "4",
    ".....": "5", "-....": "6", "--...": "7", "---..": "8", "----.": "9",
    "-----": "0", "--..--": ",", ".-.-.-": ".", "..--..": "?", "---...": ":",
    "-....-": "-", ".--.-.": "@"
}

# 입력 받기
N = int(input())  # 문자열의 길이 (사용하지 않음)
morse_code_message = input().split()  # 공백으로 구분된 모스 부호 메시지

# 모스 부호 해독
decoded_message = ""
for code in morse_code_message:
    decoded_message += morse_code_dict[code]  # 사전에서 변환

# 결과 출력
print(decoded_message)

마무리

이제 모스 부호 메시지를 해독하는 프로그램이 완성되었습니다! 각 단계를 순서대로 따라가며 코드를 작성하니 더 쉽게 이해할 수 있었을 거라 생각합니다. 앞으로도 다양한 문제를 해결하며 코딩 실력을 키워 나가길 응원합니다!

TODAY TIL

 오늘은 파이썬에서 자주 사용하는 딕셔너리와 for문, replace를 쉽게 이해하고 활용하는 방법을 프로그래머스에 관련 문제를 풀어보면서 정리하려고 합니다. 이 글을 통해 딕셔너리의 키와 값, 그리고 이를 활용하는 방법을 알기 쉽게 설명해 보겠습니다.

문제 상황: 숫자와 영단어의 변환

코딩을 하다 보면 숫자를 영단어로 바꾸거나, 영단어를 숫자로 바꿔야 하는 상황이 생깁니다. 예를 들어 "one4seveneight" 같은 문자열이 있으면 "1478"로 바꾸고 싶을 때, 파이썬에서 딕셔너리를 활용해 쉽게 해결할 수 있습니다.

1. 딕셔너리의 이해: 키와 값

딕셔너리는 두 가지 요소로 이루어져 있습니다:

• 키 (key): 특정 값을 찾는 데 사용되는 이름입니다.
• 값 (value): 키에 연결된 실제 데이터입니다.

예를 들어, 숫자와 그에 해당하는 영단어를 딕셔너리로 표현해 보겠습니다.

number_dict = {
    "zero": "0",
    "one": "1",
    "two": "2",
    "three": "3",
    "four": "4",
    "five": "5",
    "six": "6",
    "seven": "7",
    "eight": "8",
    "nine": "9"
}

이 딕셔너리에서 키는 "zero", "one" 같은 영단어이고, 값은 "0", "1" 같은 숫자로 이루어진 문자열입니다.

2. 딕셔너리와 for문: 키와 값을 쌍으로 사용하기

 딕셔너리를 반복문 for에서 사용할 때, 키만 가져올 수도 있지만, items() 메서드를 사용하면 키와 값을 쌍으로 가져올 수 있습니다.

예를 들어, for word, digit in number_dict.items():라고 쓰면 word는 키, digit는 값이 됩니다. 따라서, number_dict의 "zero"와 "0"처럼 한 쌍씩 꺼내 올 수 있습니다.

이 구조를 활용해 문자열 속의 영단어를 숫자로 바꿀 수 있습니다.

3. replace() 함수로 변환하기

이제 replace() 함수를 활용해 봅시다. replace(찾을 문자열, 바꿀 문자열) 형태로 쓰며, 문자열에서 찾을 부분을 바꿀 부분으로 교체해 줍니다.

예를 들어 s.replace(word, digit)로 for문 안에서 영단어를 숫자로 바꾸는 작업을 할 수 있습니다.

최종 코드 예시

이제 모든 내용을 종합해서 최종 코드를 작성해 보겠습니다. 예를 들어, "one4seveneight"을 "1478"로 바꾸는 코드입니다:

def solution(s):
    # 숫자 영단어 변환표
    number_dict = {
        "zero": "0", "one": "1", "two": "2", "three": "3", "four": "4",
        "five": "5", "six": "6", "seven": "7", "eight": "8", "nine": "9"
    }

    # for문과 replace로 변환하기
    for word, digit in number_dict.items():
        s = s.replace(word, digit)

    return int(s)  # 숫자 형태로 변환 후 반환

이 코드는 for문을 통해 딕셔너리의 각 키와 값을 가져와 replace로 문자열에서 단어를 숫자로 교체한 후, 숫자로 반환합니다.

정리

• 딕셔너리는 키-값 쌍으로 구성되어 있습니다.
• **for word, digit in dict.items()**를 사용하면 키와 값을 한 쌍씩 가져올 수 있습니다.
• replace() 함수는 찾을 부분과 바꿀 부분을 인자로 받아 문자열을 교체합니다.

이 글을 통해 딕셔너리와 for문, 그리고 replace의 활용법을 잘 이해하셨길 바랍니다! 더 쉬운 설명이나 추가 질문이 있다면 언제든지 댓글로 남겨 주세요. 😊

조건에 맞는 서경(LONG_W) 값 찾기 SQL 문제 해결하기

오늘은 SQL을 이용해 특정 조건에 맞는 위도와 경도 값을 찾는 문제를 해결하는 방법을 소개하려고 합니다. STATION이라는 테이블이 주어지고, 주어진 조건에 따라 서경(LONG_W) 값을 찾는 문제를 풀어보겠습니다.

1. 테이블 설명

STATION 테이블에는 다음과 같은 열이 포함되어 있습니다:

FieldType

• ID : 고유 식별자
• CITY : 도시 이름
• STATE : 주(state) 약자
• LAT_N : 북위 (위도)
• LONG_W : 서경 (경도)

이 테이블을 이용해 특정 위도에 맞는 경도를 찾아야 합니다.

2. 문제 이해

주어진 문제는 다음과 같은 조건을 포함하고 있습니다.

• 조건: LAT_N(북위)의 최소값이 38.7780보다 큰 레코드를 찾습니다. 즉, 38.7780보다 큰 값들 중 가장 작은 북위 값에 해당하는 레코드를 찾으라는 뜻입니다.
• 결과: 찾은 레코드의 LONG_W(서경) 값을 소수점 네 자리까지 반올림하여 출력합니다.

3. 해결 방법

문제를 해결하기 위해 아래 단계대로 접근하겠습니다.

1. 조건에 맞는 최소 LAT_N 값 찾기
   LAT_N > 38.7780 조건을 만족하는 값 중에서 가장 작은 LAT_N 값을 구합니다.
2. 찾은 최소 LAT_N 값의 LONG_W 구하기
   조건에 맞는 최소 LAT_N을 가진 레코드에서 LONG_W 값을 구한 뒤, 소수점 네 번째 자리까지 반올림합니다.

4. SQL 쿼리 작성

아래는 문제를 해결하기 위한 SQL 쿼리입니다

SELECT ROUND(LONG_W, 4)
FROM STATION
WHERE LAT_N = (SELECT MIN(LAT_N) FROM STATION WHERE LAT_N > 38.7780);

5. 쿼리 설명

• 조건부 최소값 찾기
  SELECT MIN(LAT_N) FROM STATION WHERE LAT_N > 38.7780: LAT_N이 38.7780보다 큰 값들 중 가장 작은 값을 찾습니다.
• 조건에 맞는 LONG_W 선택
  WHERE LAT_N = (SELECT MIN(LAT_N) FROM STATION WHERE LAT_N > 38.7780): 위에서 구한 최소 LAT_N 값과 일치하는 레코드의 LONG_W 값을 선택합니다.
• 결과 반올림
  ROUND(LONG_W, 4): 최종 결과값을 소수점 네 자리까지 반올림합니다.

결론

이렇게 하면 조건을 만족하는 최소 북위에 해당하는 서경 값이 네 자리 반올림된 형태로 반환됩니다. 이 쿼리 형식을 익혀두면, 다양한 조건의 데이터에서 특정 값을 쉽게 추출할 수 있어 SQL 문제 풀이에 큰 도움이 될 것입니다!

서브쿼리도 어떻게 써야하는지 다시 한번 해봐야겠다.

TODAY TIL

오늘은 문자열을 특정 규칙에 따라 여러 덩어리로 나누는 문제를 해결해 보았습니다. 이 문제에서는 주어진 문자열을 기준에 따라 잘라내어, 분리된 덩어리 개수를 구해야 했습니다.

문제 설명

문자열 s가 주어졌을 때, 다음 규칙을 따라 문자열을 여러 문자열로 분해합니다.

1. 첫 글자를 읽고, 이 글자를 x로 설정합니다.
2. 문자열을 왼쪽에서 오른쪽으로 읽어나가면서, x와 x가 아닌 다른 글자들이 나온 횟수를 각각 셉니다.
3. 두 횟수가 처음으로 같아지는 순간, 지금까지 읽은 문자열을 하나의 덩어리로 분리합니다.
4. 분리한 문자열을 제외하고 남은 문자열에 대해서 같은 과정을 반복합니다.
5. 문자열이 모두 처리될 때까지 반복하며, 분리된 문자열의 개수를 반환합니다.

예시:

• 입력: "banana"
• 출력: 3 (분리된 문자열: ["ba", "na", "na"])

해결 과정

문제를 해결하기 위해 다음 단계로 접근했습니다.

1. 첫 글자 선택하기: 문자열에서 첫 글자를 x로 설정합니다.
2. 글자 수 세기: 첫 글자 x의 개수와 x가 아닌 글자의 개수를 세면서 진행합니다.
3. 덩어리 분리: 두 개의 개수가 같아지는 순간을 기준으로 덩어리를 분리합니다.
4. 남은 문자열 반복: 문자열의 끝까지 위 과정을 반복하여 남은 모든 문자열을 분리합니다.

코드 구현

아래는 이 문제를 해결하는 Python 코드입니다.

def solution(s):
    answer = 0  # 분리된 덩어리 개수
    i = 0  # 현재 위치를 나타내는 인덱스

    while i < len(s):  # 문자열의 끝까지 읽을 때까지 반복
        x = s[i]  # 첫 글자를 x로 설정
        count_x = 0  # x의 개수를 세는 변수
        count_other = 0  # x가 아닌 글자의 개수를 세는 변수

        # x와 다른 글자들을 세어가며 두 개가 같아질 때까지 진행
        while i < len(s):
            if s[i] == x:
                count_x += 1  # x 글자가 나오면 count_x 증가
            else:
                count_other += 1  # 다른 글자가 나오면 count_other 증가

            i += 1  # 다음 글자로 이동

            # x와 다른 글자의 개수가 같아지면 덩어리 분리
            if count_x == count_other:
                answer += 1  # 덩어리 하나 추가
                break  # 분리 후 다시 반복
    
        # 남은 문자열이 있으면 마지막 덩어리로 추가
        if i == len(s) and count_x != count_other:
            answer += 1
    
    return answer

코드 설명

• 첫 글자 설정: 처음 x를 설정해주고, count_x와 count_other를 초기화합니다.
• 문자 개수 세기: count_x는 x 글자, count_other는 x가 아닌 글자의 개수를 나타내며, 둘이 같아질 때마다 덩어리를 하나 추가합니다.
• 남은 문자열 처리: 문자열 끝까지 다 읽었는데도 두 개수가 다르다면 남은 문자열을 마지막 덩어리로 간주합니다.

예제 테스트

# 예제 입력
print(solution("banana"))  # 출력: 3
print(solution("abracadabra"))  # 출력: 6
print(solution("aaabbaccccabba"))  # 출력: 3

배운 점

• 문자열의 특정 규칙을 기준으로 구분해야 할 때, 문자를 카운팅하는 방법이 유용하다는 것을 알게 되었습니다.
• 분리 조건에 따라 반복문을 중간에 빠져나오거나 특정 조건을 설정하는 것이 중요함을 깨달았습니다.
• 알고리즘의 기초를 배우는게 중요하다는걸 느꼈습니다.

이 포스팅을 통해 문자열 분리 문제를 규칙적으로 해결하는 방법을 익힐 걸 공유할수 있어서 좋았습니다.

TODAY TIL

오늘의 문제는  프로그래머스에 있는 크기가 작은 부분 문자열 였는데요.

아직 알고리즘이 익숙하지 않은 초보지만 푼 내용을 정리하기 위해서 작성해 봅니다.

문제 설명
주어진 숫자 문자열 t와 p가 있을 때, t에서 p와 길이가 같은 부분 문자열을 잘라내어 숫자로 변환한 뒤, 이 숫자가 p보다 작거나 같은 경우를 찾는 문제입니다.

• 예를 들어, t = "3141592"이고 p = "271"이라면, t에서 길이가 3인 부분 문자열을 추출하여 숫자로 변환하고 271보다 작거나 같은 경우를 세어야 합니다.

입력 예시

• t = "3141592"
• p = "271"

출력 예시

• 결과: 2 (141, 159 두 개의 숫자가 271보다 작음)

문제 해결 방법

이 문제를 단계별로 쉽게 풀이해보겠습니다.

1. 부분 문자열 길이 구하기
   p의 길이와 같은 길이의 부분 문자열을 t에서 잘라낼 것입니다. 따라서, p의 길이를 미리 구해 놓습니다.
2. 반복문으로 부분 문자열 만들기
   t에서 p의 길이만큼 부분 문자열을 하나씩 잘라내야 하므로, t를 처음부터 끝까지 순회하면서 p와 같은 길이의 부분 문자열을 만듭니다.
3. 숫자 변환 후 비교하기
   잘라낸 부분 문자열을 숫자로 변환한 뒤, p와 비교합니다. 만약 p보다 작거나 같은 숫자라면, 이 부분 문자열은 조건에 맞는 것이 됩니다.
4. 개수 세기
   조건에 맞는 부분 문자열이 나올 때마다 개수를 하나씩 더합니다.
5. 최종 결과 반환하기
   반복이 끝나면 조건에 맞는 부분 문자열의 개수를 반환합니다.

코드 구현

def solution(t, p):
    length_p = len(p)  # p의 길이를 구해서 저장
    count = 0  # 조건에 맞는 부분 문자열 개수를 세기 위한 변수
    
    for i in range(len(t) - length_p + 1):  # t에서 부분 문자열을 잘라내기 위한 반복문
        substring = t[i:i + length_p]  # 부분 문자열 생성
        if int(substring) <= int(p):  # 숫자로 변환해 p와 비교
            count += 1  # 조건을 만족하면 count를 1 증가
    
    return count  # 최종 개수 반환

한 줄씩 아주 쉽게 설명하기

1. length_p = len(p)
   • p의 길이를 구해서 length_p에 저장. 이 길이만큼 t에서 잘라냄
2. count = 0
   • 조건에 맞는 숫자가 몇 개인지 세기 위해 처음에 count를 0으로 설정.
3. for i in range(len(t) - length_p + 1)
   • t에서 p와 같은 길이만큼 잘라낼 건데, 한 글자씩 오른쪽으로 이동하면서 잘라냄.
   • 예를 들어, p의 길이가 3이면 t에서 첫 글자부터 3글자씩 이동하면서 반복.
4. substring = t[i:i + length_p]
   • t의 i 위치부터 p와 같은 길이만큼 잘라내서 substring이라는 부분 문자열을 만듬.
   • 예를 들어, t = "3141592"이고 p = "271"이라면, substring이 314, 141, 415... 이렇게 돼요.
5. if int(substring) <= int(p)
   • substring과 p를 숫자로 바꿔서 비교
   • 만약 substring이 p보다 작거나 같으면 조건을 만족
6. count += 1
   • 조건을 만족하면 count를 1씩 더해요.
7. return count
   • 마지막으로 조건에 맞는 개수(count)를 결과로 내보내요.

코드 예시

출력 결과

• 예를 들어, t = "3141592"이고 p = "271"이면:
  • 314, 141, 415, 159, 592 중에서 271보다 작거나 같은 숫자는 141과 159 두 개니까, 답은 2가 됩니다.

✍️ 풀이 요약

이 문제는 주어진 문자열에서 특정 조건을 만족하는 부분 문자열을 찾아서 개수를 세는 문제입니다. p의 길이만큼 부분 문자열을 t에서 하나씩 잘라내면서, p보다 작거나 같은지를 비교하는 방식으로 간단하게 풀이할 수 있습니다.