이유: 지금 블로그는 글 검색이 안되기 때문

꿈이 생겼다. 바로.. 부스트캠프 AI Tech 7기에 합격하는 것.
밤 늦게 전자기학 공부하려고 도서관에 가다가 아마스빈에 들러 커피 주문하고 앉아서 폰을 하는데, 부스트캠프 AI Tech를 모집한다는 글을 보게 되었다.
군대에 있을 때, 원준이가 우테코에서 공부해보고 싶대서 부트캠프의 존재를 알게 되었다. 다만 당시 난 앱이나 웹보다는 클라우드나 인공지능을 공부하고자 했기에, 우테코가 분명 좋은 기회라고 생각은 했지만 큰 관심은 없었다.

복학 후, 형이 공부하고 있는 인공지능에 관심이 생겼고, AI 소학회에 들어갔다. 친구들이 생겼고, 자연스레 인공지능융합학과를 복수 전공하게 되었다.

다만 인공지능융합학과의 교육 과정은 만족스럽진 않았다. 이산수학, 자료구조, 컴퓨터 시스템 등의 기초 과목은 정말 도움되었지만, 정작 기계학습이나 딥러닝을 다루는 과목은 부실했다.

그래서 석사를 해야 하나 고민하던 중.. AI Tech 모집 공고를 보게 된 것이다.
독서실에 앉아 이전 기수 분들의 합격 후기를 보고 우선 프로그래머스 공부를 시작했다. 알고리즘 공부를 처음 시작했을 때, 프로그래머스 레벨 1 문제도 너무 어려워서 놀랐는데 이제는 백준에서 브루트포스까지 풀고 와서 훨씬 나을거라 생각했다. 그러나 여전히 쉽진 않았다.

위의 다섯 문제를 풀었다. 나머지는 어찌저찌 해결했는데, 점찍기는 어려워서 맞히지 못했다. AI 리포트를 받았는데, 다음과 같은 결과가 나왔다.

열심히 해야겠다 .. ^_^ 열심히 해보자!
문제 푼 거 정리하고 전자기학 공부한 다음 자러 가야겠다. 초심 잃지 말고 최선을 다해 준비해보고 싶다.

3줄 요약

1. 부스트캠프 AI Tech에서 공부해보고 싶다.
2. 50일 남아서 다행이다.
3. 영혼을 팔아서라도 가고 싶으니 배에 힘 주고 준비하겠다.

``` 내일 할 일:

• 프로그래머스 7문제 풀고 기록
• 프리코스 수강 계획 세우고 듣기
• 전자기학 8, 9장

풀이 1(틀림)

ary = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
N, B = map(int, input().split())
mod = []

for _ in range(N):
    mod.append(N % B)
    N //= B
    if N < B:
        mod.append(N)
        break

print(''.join(ary[i] for i in mod[::-1]))

아니 왜 틀렸지??

풀이 2(정답)

ary = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
N, B = map(int, input().split())
mod = []

while N > 0:
    mod.append(N % B)
    N //= B

print(''.join(ary[i] for i in mod[::-1]))

며칠 고민해봤음에도 풀이 1이 왜 틀렸는지 이해가 안돼서 결국 GPT님께 여쭤보았는데도 모르겠다. N이 왜 0보다 커야하지? 입력 조건 때문에 애초에 음수가 안되지 않나?

666은 종말을 나타내는 수라고 한다. 따라서, 많은 블록버스터 영화에서는 666이 들어간 제목을 많이 사용한다. 영화감독 숌은 세상의 종말 이라는 시리즈 영화의 감독이다. 조지 루카스는 스타워즈를 만들 때, 스타워즈 1, 스타워즈 2, 스타워즈 3, 스타워즈 4, 스타워즈 5, 스타워즈 6과 같이 이름을 지었고, 피터 잭슨은 반지의 제왕을 만들 때, 반지의 제왕 1, 반지의 제왕 2, 반지의 제왕 3과 같이 영화 제목을 지었다. 하지만 숌은 자신이 조지 루카스와 피터 잭슨을 뛰어넘는다는 것을 보여주기 위해서 영화 제목을 좀 다르게 만들기로 했다.

종말의 수란 어떤 수에 6이 적어도 3개 이상 연속으로 들어가는 수를 말한다. 제일 작은 종말의 수는 666이고, 그 다음으로 큰 수는 1666, 2666, 3666, .... 이다. 따라서, 숌은 첫 번째 영화의 제목은 "세상의 종말 666", 두 번째 영화의 제목은 "세상의 종말 1666"와 같이 이름을 지을 것이다. 일반화해서 생각하면, N번째 영화의 제목은 세상의 종말 (N번째로 작은 종말의 수) 와 같다.

숌이 만든 N번째 영화의 제목에 들어간 수를 출력하는 프로그램을 작성하시오. 숌은 이 시리즈를 항상 차례대로 만들고, 다른 영화는 만들지 않는다.

입력

첫째 줄에 N이 주어진다. N은 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 N번째 영화의 제목에 들어간 수를 출력한다.

예제 입출력

풀이 1 (정답)

N = int(input())
i = 666 # i: 반복 변수 - 종말의 수는 666부터 시작하니 i도 666으로 초기화
cnt = 0 # cnt: 종말의 수가 몇 번 나왔는지 세는 변수

while True: # 무한 반복
    if '666' in str(i): # i.e. i = 1666이면 str(i) = '1666'이므로 '666'이 포함됨. 
        cnt += 1
        if cnt == N:
            print(i)
            break
    i += 1

# 1. N을 입력받고, i와 cnt를 초기화한다.
# 2. str(i)에 '666'이 포함되었는지, 즉 i가 종말의 수인지 확인한다.
# -> 종말의 수가 맞다면 cnt를 1만큼 증가한다.
# 3. 만약 cnt가 N이라면, 즉 i가 N번째 종말의 수에 도달했다면
# -> i를 출력하고 while문을 탈출한다.
# 4. i를 입력받는다.

이 쉬운 걸... 처음 보고 생각이 뾰족한 수가 생각나지 않았는데 3시간쯤 뒤에 갑자기 떠올랐다.

다른 사람들이 푼 코드 5개 정도 보고 왔는데 내가 더 잘 푼 것 같다. 행복하다!! 브루트포스 너무 재밌다

문제

어떤 자연수 N이 있을 때, 그 자연수 N의 분해합은 N과 N을 이루는 각 자리수의 합을 의미한다. 어떤 자연수 M의 분해합이 N인 경우, M을 N의 생성자라 한다. 예를 들어, 245의 분해합은 256(=245+2+4+5)이 된다. 따라서 245는 256의 생성자가 된다. 물론, 어떤 자연수의 경우에는 생성자가 없을 수도 있다. 반대로, 생성자가 여러 개인 자연수도 있을 수 있다.

자연수 N이 주어졌을 때, N의 가장 작은 생성자를 구해내는 프로그램을 작성하시오.

입력

첫째 줄에 자연수 N(1 ≤ N ≤ 1,000,000)이 주어진다.

출력

첫째 줄에 답을 출력한다. 생성자가 없는 경우에는 0을 출력한다.

예제 입출력

풀이 1 (정답)

N = int(input())
ans = 0

for i in range(N):
    res = i
    for j in str(i):
        res += int(j)
    if res == N:
        ans = i
        break
print(ans)

어렵지 않은 문제였다. i의 각 자리수를 더하기 위해 i를 문자열로 변환한 뒤 for문을 사용했다. 다만 for문을 두 번 사용해서인지 시간이 오래 걸렸다.

풀이 2 (정답, 참고한 풀이)

N = int(input())
res = 0
ans = 0

for i in range(N):
    i_list = list(map(int, str(i)))
    res = i + sum(i_list)
    if res == N:
        ans = i
        break
print(ans)

실행 속도를 개선하고자 for문을 하나 줄이고 싶었는데, for문 없이 어떻게 각 자리수를 쪼개야 할지 몰랐다.

이때 minblog님의 코드에서 좋은 방법을 찾았다. map 함수를 사용하면 int형을 유지한 채 list로 변환할 수 있었다.

결과적으로 풀이 1에 비해 244ms가 감소하였다.

오늘의 교훈

• map 함수를 사용하면 원하는 type의 list를 만들 수 있다.

문제

ㅋㅈㄴ에서 제일 인기 있는 게임 블랙잭의 규칙은 상당히 쉽다. 카드의 합이 21을 넘지 않는 한도 내에서, 카드의 합을 최대한 크게 만드는 게임이다. 블랙잭은 ㅋㅈㄴ마다 다양한 규정이 있다. (2/21 ㅋㅈㄴ 검열 이유: 원문으로 적으면 velog 오류로 포스트가 자동으로 비공개 됨)

한국 최고의 블랙잭 고수 김정인은 새로운 블랙잭 규칙을 만들어 상근, 창영이와 게임하려고 한다.

김정인 버전의 블랙잭에서 각 카드에는 양의 정수가 쓰여 있다. 그 다음, 딜러는 N장의 카드를 모두 숫자가 보이도록 바닥에 놓는다. 그런 후에 딜러는 숫자 M을 크게 외친다.

이제 플레이어는 제한된 시간 안에 N장의 카드 중에서 3장의 카드를 골라야 한다. 블랙잭 변형 게임이기 때문에, 플레이어가 고른 카드의 합은 M을 넘지 않으면서 M과 최대한 가깝게 만들어야 한다.

N장의 카드에 써져 있는 숫자가 주어졌을 때, M을 넘지 않으면서 M에 최대한 가까운 카드 3장의 합을 구해 출력하시오.

입력

첫째 줄에 카드의 개수 N(3 ≤ N ≤ 100)과 M(10 ≤ M ≤ 300,000)이 주어진다. 둘째 줄에는 카드에 쓰여 있는 수가 주어지며, 이 값은 100,000을 넘지 않는 양의 정수이다.

합이 M을 넘지 않는 카드 3장을 찾을 수 있는 경우만 입력으로 주어진다.

출력

첫째 줄에 M을 넘지 않으면서 M에 최대한 가까운 카드 3장의 합을 출력한다.

예제 입출력

풀이 1 (정답)

N, M = map(int, input().split())
cards = list(map(int, input().split()))
sum, sum_max = 0, 0

for i in range(0, N-2):
    for j in range(i+1, N-1):
        for k in range(j+1, N):
            sum = cards[i] + cards[j] + cards[k]
            if sum > sum_max and sum <= M:
                sum_max = sum

print(sum_max)

브루트 포스로 풀었다. 특별히 좋은 생각이 떠오르지 않아서, 그냥 for문 세 개 쓰고 range를 적절히 정해주기로 했다.

난 수학 못하는 바보라서 그런지 range의 시작과 끝 인덱스를 정하는게 매번 어렵다. 그래서 예시를 들어서 생각해본다.

N = 5일 때 나올 수 있는 i, j, k를 전부 나열해본다면,

0,1,2
0,1,3
0,1,4
    0,2,3
    0,2,4
        0,3,4

1,2,3
1,2,4
    1,3,4

2,3,4

-> i는 0~N-2, j는 i+1~N-1, k는 j+1~N의 범위를 가진다.

다만 코드가 너무 지저분한데...

풀이 2 (정답)

N, M = map(int, input().split())
card = list(map(int, input().split()))
result = 0

for i in range(0, N):
    for j in range(i+1, N):
        for k in range(j+1, N):
            sum = card[i] + card[j] + card[k]
            if sum <= M:
                result = max(result, sum)
print(result)

풀이 1의 코드를 다듬었다. 놀랍게도 range의 끝 인덱스를 N으로만 정해줘도 됐다. 예를 들어 N = 5라면, i = 3일 때, j의 range는 (4, 5), k의 range는 (5, 5)가 되므로, 세 번째 for문은 실행되지 않게 되기 때문이다.

또한 sum_max 변수를 이용해 부등식을 두 번 사용하는 대신 result = max(result, sum)으로 최대합을 갱신하였다.

다만 max 함수를 사용해서인지 실행 시간은 28ms 증가하였다. 또한 합을 구하는 과정에서 sum을 변수명으로 사용하였는데, 좋지 않은 것 같다. 앞으로는 자제하도록 하겠다.

풀이 3 (참고한 풀이)

from itertools import combinations

N, M = map(int, input().split())
card = list(map(int, input().split()))
ans = 0

for i in combinations(card, 3):
    if ans < sum(i) <= M:
        ans = sum(i)

print(ans)

먹구름의 하늘님의 코드를 참고하였다. 문제를 보고 조합과 관련된 라이브러리가 있다면 좋겠다고 생각했는데, itertools가 그것이었다.

from itertools import combinations, permutations
# combinations: 조합, permutations: 순열

print(permutations(range(3), 2))
print(list(permutations(range(3), 2)))
print(combinations(range(3), 2))
print(list(combinations(range(3), 2)))

# 실행 결과
<itertools.permutations object at 0x104518810>
[(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
<itertools.combinations object at 0x104518810>
[(0, 1), (0, 2), (1, 2)]

파이썬 내장 라이브러리인 itertools는 특정 배열에 대하여 순열이나 조합을 이용한 문제를 풀 때 유용하며, 자신의 반복자를 만드는 모듈이라고 한다.

itertools에 관한 자세한 설명은 이곳을 참고하자.

오늘의 교훈

• for문에서 range의 시작, 끝 인덱스를 신중히 지정하자.
• 변수명으로 sum을 사용하지 말자.
• 순열, 조합 관련 문제에서는 itertools 라이브러리를 이용해보자.

문제

한수는 지금 (x, y)에 있다. 직사각형은 각 변이 좌표축에 평행하고, 왼쪽 아래 꼭짓점은 (0, 0), 오른쪽 위 꼭짓점은 (w, h)에 있다. 직사각형의 경계선까지 가는 거리의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 x, y, w, h가 주어진다.

출력

첫째 줄에 문제의 정답을 출력한다.

제한

1 ≤ w, h ≤ 1,000 1 ≤ x ≤ w-1 1 ≤ y ≤ h-1 x, y, w, h는 정수

예제 입출력

풀이 1 (정답)

x, y, w, h = map(int, input().split())
print(min(x, y, w-x, h-y))

직사각형을 직접 그려보면 이해하기 쉽다. 점 P(x, y)와 원점 (0, 0)의 각 거리; x-0, y-0 (=x, y) 점 P(x, y)와 끝점 (w, h)의 각 거리; w-x, h-y

네 값 중 최솟값이 경계선까지의 최소 거리이다.

문제

가로, 세로의 크기가 각각 100인 정사각형 모양의 흰색 도화지가 있다. 이 도화지 위에 가로, 세로의 크기가 각각 10인 정사각형 모양의 검은색 색종이를 색종이의 변과 도화지의 변이 평행하도록 붙인다. 이러한 방식으로 색종이를 한 장 또는 여러 장 붙인 후 색종이가 붙은 검은 영역의 넓이를 구하는 프로그램을 작성하시오.

예를 들어 흰색 도화지 위에 세 장의 검은색 색종이를 그림과 같은 모양으로 붙였다면 검은색 영역의 넓이는 260이 된다.

입력

첫째 줄에 색종이의 수가 주어진다. 이어 둘째 줄부터 한 줄에 하나씩 색종이를 붙인 위치가 주어진다. 색종이를 붙인 위치는 두 개의 자연수로 주어지는데 첫 번째 자연수는 색종이의 왼쪽 변과 도화지의 왼쪽 변 사이의 거리이고, 두 번째 자연수는 색종이의 아래쪽 변과 도화지의 아래쪽 변 사이의 거리이다. 색종이의 수는 100 이하이며, 색종이가 도화지 밖으로 나가는 경우는 없다

출력

첫째 줄에 색종이가 붙은 검은 영역의 넓이를 출력한다.

예제 입출력

이것도 초등부 문제다.

풀이 1 (정답)

mat = [[0 for col in range(100)] for row in range(100)] # 100x100짜리 행렬 만들고 0으로 초기화
result = 0

for _ in range(int(input())): # 좌표 입력
    x, y = map(int, input().split())

    for row in range(x, x+10): # 해당 x, y좌표부터 +10만큼
        for col in range(y, y+10):
            mat[row][col] = 1 # 1로 채움

for row in range(100): # 모든 행렬 값에 접근해
    for col in range(100):
        result += mat[row][col] # 1들의 합을 구함
print(result)

아이디어를 떠올리기 위해 2차원 수직선을 그려봤는데, 생각해보니 x, y축 모두 0~100의 범위를 가지고, 간격이 유리수가 아닌 정수 단위이므로 100*100짜리 표를 검은색으로 칠하는 것과 같다고 생각했다. 그렇게 떠올리니 구현은 어렵지 않았다. 생각보다 금방 풀었다.

풀이 2 (정답)

mat = [[0 for col in range(100)] for row in range(100)]
result = 0

for _ in range(int(input())):
    x, y = map(int, input().split())

    for row in range(x, x+10):
        for col in range(y, y+10):
            mat[row][col] = 1

for i in mat:
    result += sum(i)
print(result)

풀이 1에서 1의 합(=사각형의 넓이)을 구하는 부분만 바꿔보았다. for문의 개수가 하나 줄어서 좀 더 빠를 줄 알았는데 그렇진 않았다.

풀이 3 (정답, 파이리썬님 코드 일부 참고)

mat = [[0 for col in range(100)] for row in range(100)]
result = 0

for _ in range(int(input())):
    x, y = map(int, input().split())

    for row in range(x, x+10):
        for col in range(y, y+10):
            mat[row][col] = 1

for row in mat:
    result += row.count(1)
print(result)

이번에도 풀이 1의 코드에서 넓이 구하는 부분만 바꿔보았다. 1의 합이 아닌 1의 개수를 구해보았는데, 실행 시간에는 큰 차이가 없었다.

문제

아직 글을 모르는 영석이가 벽에 걸린 칠판에 자석이 붙어있는 글자들을 붙이는 장난감을 가지고 놀고 있다.

이 장난감에 있는 글자들은 영어 대문자 ‘A’부터 ‘Z’, 영어 소문자 ‘a’부터 ‘z’, 숫자 ‘0’부터 ‘9’이다. 영석이는 칠판에 글자들을 수평으로 일렬로 붙여서 단어를 만든다. 다시 그 아래쪽에 글자들을 붙여서 또 다른 단어를 만든다. 이런 식으로 다섯 개의 단어를 만든다. 아래 그림 1은 영석이가 칠판에 붙여 만든 단어들의 예이다.

A A B C D D
a f z z 
0 9 1 2 1
a 8 E W g 6
P 5 h 3 k x

<그림 1>

한 줄의 단어는 글자들을 빈칸 없이 연속으로 나열해서 최대 15개의 글자들로 이루어진다. 또한 만들어진 다섯 개의 단어들의 글자 개수는 서로 다를 수 있다.

심심해진 영석이는 칠판에 만들어진 다섯 개의 단어를 세로로 읽으려 한다. 세로로 읽을 때, 각 단어의 첫 번째 글자들을 위에서 아래로 세로로 읽는다. 다음에 두 번째 글자들을 세로로 읽는다. 이런 식으로 왼쪽에서 오른쪽으로 한 자리씩 이동 하면서 동일한 자리의 글자들을 세로로 읽어 나간다. 위의 그림 1의 다섯 번째 자리를 보면 두 번째 줄의 다섯 번째 자리의 글자는 없다. 이런 경우처럼 세로로 읽을 때 해당 자리의 글자가 없으면, 읽지 않고 그 다음 글자를 계속 읽는다. 그림 1의 다섯 번째 자리를 세로로 읽으면 D1gk로 읽는다.

그림 1에서 영석이가 세로로 읽은 순서대로 글자들을 공백 없이 출력하면 다음과 같다:

Aa0aPAf985Bz1EhCz2W3D1gkD6x

칠판에 붙여진 단어들이 주어질 때, 영석이가 세로로 읽은 순서대로 글자들을 출력하는 프로그램을 작성하시오.

입력

총 다섯줄의 입력이 주어진다. 각 줄에는 최소 1개, 최대 15개의 글자들이 빈칸 없이 연속으로 주어진다. 주어지는 글자는 영어 대문자 ‘A’부터 ‘Z’, 영어 소문자 ‘a’부터 ‘z’, 숫자 ‘0’부터 ‘9’ 중 하나이다. 각 줄의 시작과 마지막에 빈칸은 없다.

출력

영석이가 세로로 읽은 순서대로 글자들을 출력한다. 이때, 글자들을 공백 없이 연속해서 출력한다.

예제 입출력

9년 전 문제인데 초등부라니..

풀이 1 (정답)

mat = []
max_row = 0 # 입력받은 행들의 최대 길이를 저장하는 변수

for _ in range(5): # 행렬 입력
    row = input()
    mat.append(row)
    if len(row) > max_row: # 행의 최대 길이 갱신
        max_row = len(row)

for row in range(max_row):
    for col in range(5):
    # 비어있는 값을 넘기기 위해 예외처리
        try: print(mat[col][row], end='') # 행열(X) 열행(O)으로 접근
        except: continue

꽤 잘 푼 것 같다. try-except 생각한 게 기특하다.

풀이 2 (hyunhee님 풀이)

words = [input() for i in range(5)]

for j in range(15):
    for i in range(5):
        if j < len(words[i]): # j가 단어 길이보다 작으면 인덱스 범위 안에 있으므로 출력할 수 있다.
            print(words[i][j], end='')

문제 조건에 각 줄에는 최소 1개, 최대 15개의 글자들이 빈칸 없이 연속으로 주어진다고 나와있어서 행의 최대 길이를 구하지 않고 바로 행렬에 접근하신 것 같다. 코드가 정말 간결하다. 부럽다..

사실 아직 이중 for문과 반복 변수 i, j가 직관적으로 이해되지 않는다.. 능지를 상승시켜보자

문제

<그림 1>과 같이 9×9 격자판에 쓰여진 81개의 자연수 또는 0이 주어질 때, 이들 중 최댓값을 찾고 그 최댓값이 몇 행 몇 열에 위치한 수인지 구하는 프로그램을 작성하시오.

예를 들어, 다음과 같이 81개의 수가 주어지면 이들 중 최댓값은 90이고, 이 값은 5행 7열에 위치한다.

입력

첫째 줄부터 아홉 번째 줄까지 한 줄에 아홉 개씩 수가 주어진다. 주어지는 수는 100보다 작은 자연수 또는 0이다.

출력

첫째 줄에 최댓값을 출력하고, 둘째 줄에 최댓값이 위치한 행 번호와 열 번호를 빈칸을 사이에 두고 차례로 출력한다. 최댓값이 두 개 이상인 경우 그 중 한 곳의 위치를 출력한다.

예제 입출력

풀이 1 (정답)

mat = []
max_val, max_row, max_col = 0, 0, 0

for _ in range(9): # 행렬 입력 받음
    row = list(map(int, input().split()))
    mat.append(row)

for row in range(9): # 행렬의 값에 순서대로 접근
    for col in range(9):
        if mat[row][col] > max_val: # 해당 행렬값이 최댓값인지 확인
            max_val = mat[row][col] # 최댓값 갱신
            max_row = row # 최댓값의 행 인덱스 갱신
            max_col = col # 최댓값의 열 인덱스 갱신

print(max_val) # 최댓값 출력
print(max_row+1, max_col+1) # 최댓값의 행, 열 출력 (인덱스+1)

넘 쉬워잉

풀이 2 (정답, 파이리썬님 코드)

max_num = 0

for i in range(9):
    row = list(map(int, input().split())) #굳이 행렬을 저장할 필요는 없다
    if max(row) > max_num:
        max_num = max(row) #최댓값
        x = i + 1 #행
        y = row.index(max_num) + 1 #열
print(max_num)
print(x,y)

천재적이다 난 당연히 행렬 저장 후 각 행과 열에 하나씩 접근하는 방식만 생각했는데

1. 저장을 안해도 되고
2. max, index 등 기본 함수를 적절히 사용한 게 정말 파이썬스러운 코드인 것 같다.

오늘의 교훈

• 행렬 문제를 풀 때 굳이 행렬을 저장하지 않아도 되는 경우가 있다. 아울러 어떤 문제를 풀 때든 틀에 박힌 형식적인 방법 보다는, 굳이 그 과정이 필요한가 생각해보고 창의적인 방법을 생각해서 풀어보자.
• 기본 함수, 메소드를 적절히 사용해보도록 하자.

문제

N*M크기의 두 행렬 A와 B가 주어졌을 때, 두 행렬을 더하는 프로그램을 작성하시오.

입력

첫째 줄에 행렬의 크기 N 과 M이 주어진다. 둘째 줄부터 N개의 줄에 행렬 A의 원소 M개가 차례대로 주어진다. 이어서 N개의 줄에 행렬 B의 원소 M개가 차례대로 주어진다. N과 M은 100보다 작거나 같고, 행렬의 원소는 절댓값이 100보다 작거나 같은 정수이다.

출력

첫째 줄부터 N개의 줄에 행렬 A와 B를 더한 행렬을 출력한다. 행렬의 각 원소는 공백으로 구분한다.

예제 입출력

풀이 1 (정답)

N, M = map(int, input().split())
mat1, mat2 = [], []

for row in range(N):
    row = list(map(int, input().split()))
    mat1.append(row)

for row in range(N):
    row = list(map(int, input().split()))
    mat2.append(row)

for row in range(N):
    for col in range(M):
        print(mat1[row][col] + mat2[row][col], end=' ')
    print()

ImJay님의 코드를 참고했다. 2차원 배열을 사용해본 적이 없어 어려웠다.

풀이 2 (정답, 풀이 1 수정)

N, M = map(int, input().split())
mat1, mat2 = [], []

for _ in range(N):
    row = list(map(int, input().split()))
    mat1.append(row)

for _ in range(N):
    row = list(map(int, input().split()))
    mat2.append(row)

for row in range(N):
    for col in range(M):
        print(mat1[row][col] + mat2[row][col], end=' ')
    print()

풀이 1에서 mat1, mat2를 입력받는 for문에서 반복변수를 'row'로 썼는데, 다시 보니 어색해서 '_'로 고쳐보았더니 역시 잘 돌아갔다.

또한 C, Java 등의 언어로 문제를 풀 때와는 달리, Python에서는 입력받은 열 개수(M)는 행렬을 입력받는 과정에서는 큰 의미가 없다. 이는 열 데이터를 개수 제한이 없는 input().split()으로 입력받기 때문이다.

풀이 3 (정답, unpacking)

N, M = map(int, input().split())
mat1, mat2 = [], []

for _ in range(N):
    mat1.append(list(map(int, input().split())))
for _ in range(N):
    mat2.append(list(map(int, input().split())))

for row in range(N):
    mat3 = []
    for col in range(M):
        mat3.append(mat1[row][col] + mat2[row][col])
    print(*mat3)

<백준 티어별 풀이노트>를 참고하였다. 언패킹에 익숙해지고 싶은데 문제 풀 때 잘 안떠오른다. 의식해서 연습해봐야겠다.

오늘의 교훈

• 행렬을 입력받는 문제에서는 아래의 순서로 접근해보자.

  1. 우선 행렬을 빈 리스트로 선언한다. e.g. mat = []
  2. 행에 대해 입력받는다. e.g. row = list(map(int, input().split()
  3. 입력받은 행을 추가하여 행렬을 완성한다. e.g. mat.append(row)

• 행렬의 값에 반복하여 접근할 때는 이중 for문을 쓰고, for row -> for col의 순서로 접근한다.

문제

B진법 수 N이 주어진다. 이 수를 10진법으로 바꿔 출력하는 프로그램을 작성하시오. 10진법을 넘어가는 진법은 숫자로 표시할 수 없는 자리가 있다. 이런 경우에는 다음과 같이 알파벳 대문자를 사용한다. A: 10, B: 11, ..., F: 15, ..., Y: 34, Z: 35

입력

첫째 줄에 N과 B가 주어진다. (2 ≤ B ≤ 36) B진법 수 N을 10진법으로 바꾸면, 항상 10억보다 작거나 같다.

출력

첫째 줄에 B진법 수 N을 10진법으로 출력한다.

예제 입출력

풀이 1 (정답)

N, B = input().split()
alpha_dict = {}
N_list = []
result = 0

for i in range(65, 91):
    alpha_dict[chr(i)] = i-55

for n in N:
    if n.isalpha():
        N_list.append(alpha_dict[n])
    else:
        N_list.append(int(n))

for j in range(len(N)):
    result += (N_list[j] * (int(B)**(len(N)-j-1)))

print(result)

코드가 좀 난잡하다. 내가 생각한 방식은

1. N = ZZZZZ ~> N_list = ['Z','Z','Z','Z','Z']
2. N_list = ['Z','Z','Z','Z','Z'] ~> [35, 35, 35, 35, 35]
3. for i in range (len(N)): result += N_list(i) * B**(len-i)

형 변환, 인덱스 실수가 있어서 오류가 몇 번 발생했고, 금방 찾아 고쳐서 제출에 성공했다.

풀이 2 (정답, comprehension)

N, B = input().split()
result = 0

alpha_dict = {chr(i): i-55 for i in range(65, 91)}
N_list = [
    alpha_dict[n] if n.isalpha() else int(n)
    for n in N
]

for j in range(len(N)): 
    result += (N_list[j] * (int(B) ** (len(N)-j-1)))

print(result)

alpha_dict에 dictionary comprehension을 적용했다. (참고)

# dictionary comprehension
{key : value for key in range(1, 10)}

N_list에 삼항 연산을 적용했다. (참고) list comprehension에서 if-else문을 사용하려면 삼항 연산을 사용하여야 한다.

list = [
    X if X > 0 else X < 0
    for x in X
]

https://velog.io/@yje876/python%EB%B0%B1%EC%A4%80-2745-%EC%A7%84%EB%B2%95-%EB%B3%80%ED%99%98

문제

정수 N이 주어졌을 때, 소인수분해하는 프로그램을 작성하시오.

입력

첫째 줄에 정수 N (1 ≤ N ≤ 10,000,000)이 주어진다.

출력

N의 소인수분해 결과를 한 줄에 하나씩 오름차순으로 출력한다. N이 1인 경우 아무것도 출력하지 않는다.

예제 입출력

풀이 (정답, while)

N = int(input())
i = 2
while N != 1:
    if N % i == 0:
        print(i)
        N /= i
    else:
        i += 1

메모리, 시간 소모가 엄청 크지만 코드 자체는 깔끔하게 잘 짠 것 같다. for문을 사용해 작성하다가, 입력받은 정수 N을 나누는 수 i가 여러 번 사용돼야 해서 while문으로 작성했다.

당장 오늘 밤에 신시 시험인데.. 백준 풀고 있네.. 넘 재밌당

문제

자연수 M과 N이 주어질 때 M이상 N이하의 자연수 중 소수인 것을 모두 골라 이들 소수의 합과 최솟값을 찾는 프로그램을 작성하시오.

예를 들어 M=60, N=100인 경우 60이상 100이하의 자연수 중 소수는 61, 67, 71, 73, 79, 83, 89, 97 총 8개가 있으므로, 이들 소수의 합은 620이고, 최솟값은 61이 된다.

입력

입력의 첫째 줄에 M이, 둘째 줄에 N이 주어진다.

M과 N은 10,000이하의 자연수이며, M은 N보다 작거나 같다.

출력

M이상 N이하의 자연수 중 소수인 것을 모두 찾아 첫째 줄에 그 합을, 둘째 줄에 그 중 최솟값을 출력한다.

단, M이상 N이하의 자연수 중 소수가 없을 경우는 첫째 줄에 -1을 출력한다.

예제 입출력

풀이 1 (정답, not 키워드)

M = int(input())
N = int(input())
prime = []

for x in range(M, N+1):
    for i in range(2, x+1):
        if x % i == 0:
            if x == i:
                prime.append(x)
            break

if not prime: 
    print(-1)
else:
    print(sum(prime))
    print(min(prime))

소수를 확인하는 코드는 1978: 소수 찾기 글의 세 번째 코드를 가져왔다. 그리고 해당 범위에 소수가 존재하는지 확인하는 코드를 작성할 때,

if len(prime) == 0:

평소처럼 len 키워드를 사용할까 했는데, 혹시 다른 방법이 있나 싶어 검색해보던 중 이 글을 발견했고, 위 코드가 파이썬 답지 않다는 것을 알게 됐다.

if not prime

따라서 if not을 사용했다. if not data는 data가 거짓일 때, 즉 data가 비어있을 때 if 조건문에 진입한다.

다른 사람들의 풀이를 찾아봤는데, 특별히 다른 부분은 없는 것 같다.

오늘의 교훈

• if-not을 적절히 활용해보자. 특히 data가 비어있는지 확인할 때 not data를 사용하자.

문제

주어진 수 N개 중에서 소수가 몇 개인지 찾아서 출력하는 프로그램을 작성하시오.

입력

첫 줄에 수의 개수 N이 주어진다. N은 100이하이다. 다음으로 N개의 수가 주어지는데 수는 1,000 이하의 자연수이다.

출력

주어진 수들 중 소수의 개수를 출력한다.

예제 입출력

풀이 1 (정답, 함수 정의)

n = int(input()) # 입력 받긴 했으나 이후 사용하진 않았음
numbers = map(int, input().split())

prime_cnt = 0 # 입력받은 정수들(numbers) 중 소수의 개수를 저장하는 변수
def prime_check(x): # 정수 x가 소수인지 검사하는 함수
    check_cnt = 0 # 정수 x의 약수의 개수를 저장하는 변수
    global prime_cnt # 'local variable referenced before assignment' 오류 해결을 위함
    for i in range(1, x+1):
        if x % i == 0:
            check_cnt += 1
    if check_cnt == 2: # 소수: 약수가 1과 자기 자신 뿐 => 약수의 개수(check_cnt)가 2여야 함.
        prime_cnt += 1

for number in numbers:
    prime_check(number)

print(prime_cnt)

정수 1을 예외처리 해줘야 하나, 등 여러 생각을 하다가 '약수가 1과 자기 자신 뿐'이라는 소수의 정의에 충실하게 풀어보고자 하였다.

문제점은

• 코드가 길다.
• 변수 n을 사용하지 않았다.
• 불필요하게 함수를 정의한 것 같다.
• 변수를 2개 사용했는데, 1개만 사용할 수는 없을까?

풀이 2 (정답)

n = int(input())
numbers = map(int, input().split())
prime_cnt = 0

for x in numbers:
    check_cnt = 0
    for i in range(1, x+1):
        if x % i == 0: check_cnt += 1
    if check_cnt == 2: prime_cnt += 1

print(prime_cnt)

풀이 1에서 함수를 정의하는 부분을 제거하였고, 코드를 보기 쉽게 고쳤다. 다른 코드들도 찾아봤는데 웬만한 블로그 글보다 내가 더 잘 푼 것 같다.

풀이 3 ('조무래기 코딩'님 블로그 참고)

n = int(input())
numbers = map(int, input().split())
count = 0

for x in numbers:
    for i in range(2, x+1): # 소수는 약수가 1과 자기 자신 -> 2부터 검사하면 자기 자신만 약수이면 된다.
        if x % i == 0:
            if x == i:
                count += 1
            break

print(count)

더 간단명료하게 푸신 분을 찾았다. 소수 구하는 문제가 많으니 익혀둬야겠다.

오늘의 교훈

• 소수인지 판별할 때, 검사 범위(나누는 수)를 2부터 자기 자신까지로 정해도 된다. (단, 이때는 약수의 개수가 1개여야 소수이다.)
• if 중첩, if-break 등 조건문을 영리하게 사용하면 보다 깔끔한 코드를 만들 수 있다.

문제

어떤 숫자 n이 자신을 제외한 모든 약수들의 합과 같으면, 그 수를 완전수라고 한다. 예를 들어 6은 6 = 1 + 2 + 3 으로 완전수이다. n이 완전수인지 아닌지 판단해주는 프로그램을 작성하라.

입력

입력은 테스트 케이스마다 한 줄 간격으로 n이 주어진다. (2 < n < 100,000) 입력의 마지막엔 -1이 주어진다.

출력

테스트케이스 마다 한줄에 하나씩 출력해야 한다. n이 완전수라면, n을 n이 아닌 약수들의 합으로 나타내어 출력한다(예제 출력 참고). 이때, 약수들은 오름차순으로 나열해야 한다. n이 완전수가 아니라면 n is NOT perfect. 를 출력한다.

예제 입출력

풀이 1 (정답)

while True:
    n = int(input())
    if n == -1: break
    factors = [i for i in range(1, n) if n % i == 0]

    if n == sum(factors): # n이 완전수라면
        print(n, '= ', end='') # 이하 덧셈 출력
        for f in factors[0:-1]:
            print(f, end=' + ')
        print(factors[-1])
    else: 
        print(n, 'is NOT perfect.')

완전수인지 아닌지를 파악하기 위해 sum() 함수를 사용하였다.

if n == sum(factors)

어떻게 덧셈을 출력하여야 할 지가 고민이었고, 조금 난잡하게 해결하였다. 입력이 6, 출력이 '6 = 1 + 2 + 3'인 경우를 예로 든다면

print(n, '= ', end='') # 1. '6 = ' 출력
for f in factors[0:-1]: # 2. '1 + 2 + ' 출력
    print(f, end=' + ')
print(factors[-1]) # 3. '3' 출력

위의 과정으로 덧셈의 출력을 구현하였다.

풀이 2 (정답, unpacking)

while True:
    n = int(input())
    if n == -1: break
    factors = [i for i in range(1, n) if n % i == 0]

    if n == sum(factors):
        print(n, '= ', end='')
        print(*factors, sep = ' + ')
    else: 
        print(n, 'is NOT perfect.')

풀이 1의 덧셈 출력 과정의 for문을 unpacking(*)으로 대체했다. 이 글을 참고하였다.

풀이 3 (정답, join())

while True:
    n = int(input())
    if n == -1: break
    factors = [i for i in range(1, n) if n % i == 0]

    if n == sum(factors):
        print(n, ' = ', ' + '.join(str(i) for i in factors), sep='')
    else: 
        print(n, 'is NOT perfect.')

풀이 1의 덧셈 출력 과정의 for문을 join() 함수로 대체했다. 이 글을 참고하였다.

오늘의 교훈

• list 안의 내용을 전부 꺼내서 출력할 때는 unpacking(*)을 적절히 사용해보자.
• 또는 join() 함수를 사용하는 것도 좋은 방법이 될 수 있다.

문제

어떤 자연수 p와 q가 있을 때, 만일 p를 q로 나누었을 때 나머지가 0이면 q는 p의 약수이다.

6을 예로 들면

6 ÷ 1 = 6 … 0 6 ÷ 2 = 3 … 0 6 ÷ 3 = 2 … 0 6 ÷ 4 = 1 … 2 6 ÷ 5 = 1 … 1 6 ÷ 6 = 1 … 0 그래서 6의 약수는 1, 2, 3, 6, 총 네 개이다.

두 개의 자연수 N과 K가 주어졌을 때, N의 약수들 중 K번째로 작은 수를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 N과 K가 빈칸을 사이에 두고 주어진다. N은 1 이상 10,000 이하이다. K는 1 이상 N 이하이다.

출력

첫째 줄에 N의 약수들 중 K번째로 작은 수를 출력한다. 만일 N의 약수의 개수가 K개보다 적어서 K번째 약수가 존재하지 않을 경우에는 0을 출력하시오.

예제 입출력

풀이 1 (정답)

n, k = map(int, input().split())
factors = [] # 약수 배열
for i in range(1, n+1): # 약수 구하기
    if n % i == 0:
        factors.append(i)

if len(factors) < k: print(0)
else: print(factors[k-1])

index 범위 때문에 한 번 틀렸다. 정수 n이 주어졌을 때, 정수 n을 1부터 n까지 나눈 몫을 구해야 하므로 범위를 range(1, n+1) 으로 설정해주어야 한다.

풀이 2 (정답, list comprehension)

n, k = map(int, input().split())
factors = [i for i in range(1, n+1) if n % i == 0]

if len(factors) < k: print(0)
else: print(factors[k-1])

풀이 1에서 약수를 구하는 부분(3~5행)을 list comprehension을 이용해 한 줄로 줄였다.

풀이 3 (정답, try-except)

n, k = map(int, input().split())
factors = [i for i in range(1, n+1) if n % i == 0]
try: print(factors[k-1])
except: print(0)

풀이 2의 if-else문을 try-except문으로 대체하였다. 문제를 처음 볼 때 얼핏 떠올렸는데, 굳이 싶어서 안썼다가 숏코딩 첫 페이지에 있길래 작성해보았다.

오늘의 교훈

• try-except문을 자주 써보자.
• list comprehension에서 for문과 if문을 동시에 사용할 수 있다.

  [x for x in 범위 if 조건]
  # e.g.
  result = [x for x in range(1, 10) if 10 % x == 0]

문제

4 × 3 = 12이다.

이 식을 통해 다음과 같은 사실을 알 수 있다.

3은 12의 약수이고, 12는 3의 배수이다.

4도 12의 약수이고, 12는 4의 배수이다.

두 수가 주어졌을 때, 다음 3가지 중 어떤 관계인지 구하는 프로그램을 작성하시오.

첫 번째 숫자가 두 번째 숫자의 약수이다. 첫 번째 숫자가 두 번째 숫자의 배수이다. 첫 번째 숫자가 두 번째 숫자의 약수와 배수 모두 아니다. 입력 입력은 여러 테스트 케이스로 이루어져 있다. 각 테스트 케이스는 10,000이 넘지않는 두 자연수로 이루어져 있다. 마지막 줄에는 0이 2개 주어진다. 두 수가 같은 경우는 없다.

출력

각 테스트 케이스마다 첫 번째 숫자가 두 번째 숫자의 약수라면 factor를, 배수라면 multiple을, 둘 다 아니라면 neither를 출력한다.

예제 입출력

풀이 (정답)

while True:
    a, b = map(int, input().split())
    if a == 0 and b == 0: break
    elif b % a == 0: print('factor')
    elif a % b == 0: print('multiple')
    else: print('neither')

EZ

문제

예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.

입력

첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.

출력

첫째 줄부터 2×N-1번째 줄까지 차례대로 별을 출력한다.

예제 입출력

풀이 1 (정답)

n = int(input())

for i in range(1, n):
    print(' ' * (n-i), '*' * (2*i-1), sep='')
print('*' * (2*n-1))
for i in range(n-1, 0, -1):
    print(' ' * (n-i), '*' * (2*i-1), sep='')

조금 헷갈려서 종이에 그려서 풀었다. 입출력 예제인 n=5일 때의 경우를 표로 그려보았다. 대칭 관계를 이용해 풀고자 했고, 이에 for문을 뒤집어 사용했다.

풀이 2 (정답)

n = int(input())
def star(): print(' ' * (n-i) + '*' * (2*i-1))
for i in range(1, n): star()
for i in range(n, 0, -1): star()

풀이 1의 코드를 손 봤다. 코드 중복을 피하기 위해 star() 함수를 정의하였다. 굳이 정의했나 싶긴 하다. 또한 index를 보다 간단히 조정하였고, sep 파라미터 대신 + 연산자를 사용했다.

오늘의 교훈

• for문을 거꾸로 사용하려면 range(start, end, step)를 사용한다.

# e.g.
for i in range (5, 0, -1) # i = 5, 4, 3, 2, 1

문제

인하대학교 컴퓨터공학과를 졸업하기 위해서는, 전공평점이 3.3 이상이거나 졸업고사를 통과해야 한다. 그런데 아뿔싸, 치훈이는 깜빡하고 졸업고사를 응시하지 않았다는 사실을 깨달았다!

치훈이의 전공평점을 계산해주는 프로그램을 작성해보자.

전공평점은 전공과목별 (학점 × 과목평점)의 합을 학점의 총합으로 나눈 값이다.

인하대학교 컴퓨터공학과의 등급에 따른 과목평점은 다음 표와 같다.

A+ 4.5 A0 4.0 B+ 3.5 B0 3.0 C+ 2.5 C0 2.0 D+ 1.5 D0 1.0 F 0.0 P/F 과목의 경우 등급이 P또는 F로 표시되는데, 등급이 P인 과목은 계산에서 제외해야 한다.

과연 치훈이는 무사히 졸업할 수 있을까?

입력

20줄에 걸쳐 치훈이가 수강한 전공과목의 과목명, 학점, 등급이 공백으로 구분되어 주어진다.

출력

치훈이의 전공평점을 출력한다.

정답과의 절대오차 또는 상대오차가 (10^{-4}) 이하이면 정답으로 인정한다.

제한

1 ≤ 과목명의 길이 ≤ 50 과목명은 알파벳 대소문자 또는 숫자로만 이루어져 있으며, 띄어쓰기 없이 주어진다. 입력으로 주어지는 모든 과목명은 서로 다르다. 학점은 1.0,2.0,3.0,4.0중 하나이다. 등급은 A+,A0,B+,B0,C+,C0,D+,D0,F,P중 하나이다. 적어도 한 과목은 등급이 P가 아님이 보장된다.

예제 입출력

풀이 1 (정답)

sum = 0; credit_sum = 0
grade_num = {'A+':4.5,'A0':4.0,'B+':3.5,'B0':3.0,'C+':2.5,'C0':2.0,'D+':1.5,'D0':1.0,'F':0.0}

for _ in range(20):
    sub, credit, grade = input().split()
    if grade == 'P': 
        continue
    sum += float(credit) * grade_num[grade]
    credit_sum += float(credit)

print(sum/credit_sum)

8개월 전에 세 번 제출하고 전부 틀렸던 문제인데, 오늘은 쉽게 풀렸다. 'P' 등급을 받았을 때 어떻게 처리할 것인지가 관건이었다.

'P' 등급은 과목 평점의 합에 영향을 주지 않고, 총 학점에만 영향을 주므로 'P'가 나오면 continue로 넘겼고, 'P'가 아닌 등급들에 대해서는 학점×과목평점, 과목평점을 각각 sum, credit_sum에 누적해주었다.

풀이 2 (정답)

sum = csum = 0
grade_dic = {'A+':4.5,'A0':4.0,'B+':3.5,'B0':3.0,'C+':2.5,'C0':2.0,'D+':1.5,'D0':1.0,'F':0.0}

for _ in range(20):
    sub, credit, grade = input().split()
    if grade != 'P': 
        sum += float(credit) * grade_dic[grade]
        csum += float(credit)

print(sum/csum)

풀이 1을 보다 간결하게 수정하였다. if-continue문을 사용하지 않고 if와 !=를 사용해 'P' 등급을 걸러주었다.

오늘의 교훈

• if-continue문 대신 if, !=를 적절히 사용하면 보다 간결하게 코드를 작성할 수 있다.

고찰

• grade_dic과 같은 dictionary를 지정하지 않고 푸는 방법은 없을까??