Sec1: Develop Code Implementation Skills

01_K번째 약수 풀이

1) Problem

어떤 자연수 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 이상 10000 이하이다. K는 1 이상 N 이하이다.
출력설명 : 첫째 줄에 N의 약수들 중 K번째로 작은 수를 출력한다. 만일 N의 약수의 개수가 K개보다 적어서 K번째 약수가 존재하지 않을 경우에는 -1을 출력하시오.
입력예제 : 6 3
출력예제 : 3

2) Thinking

N이 약수 구하려는 수 1 ~ 10000까지 입력받기
K가 3번째로 작은 수
Ex)
N = 6
약수 : 1 2 3 6
K = 3이면 출력은 세번째로 작은 수인 3

3) My Sol#1

def divisor(N, K):
    divisors = []
    if N < 1 or 10000 < N:
        print(f'Out of range(N : 1 ~ 10000), N = {N}')
    else:
        for i in range(1, N + 1):
            if N % i == 0:
                divisors.append(i)
        if K < len(divisors):
            print(f'divisors : {divisors}', '\n', f'{K}번째로 작은 약수 : {divisors[K - 1]}', sep='')
        else:
            print(f'Number of divisors({len(divisors)}) < K({K})')

NKlist = list(map(int, input('Enter N and K : ').split()))
divisor(NKlist[0], NKlist[1])

Enter N and K : 100 10
Number of divisors(9) < K(10)

Enter N and K : 11111 1000
Out of range(N : 1 ~ 10000), N = 11111

Enter N and K : 100 5
divisors : [1, 2, 4, 5, 10, 20, 25, 50, 100]
5번째로 작은 약수 : 10

4) My Sol#2

N, K = map(int, input('N, K : ').split())
print([i for i in range(1, N + 1) if N % i == 0][K - 1])

# print([1, 2, 3, 6][2]) # 3

N, K : 6, 3
3

5) Lec Sol

n, k = map(int, input().split()
cnt = 0
for i in range(1, n + 1):
	if n % i == 0:
    	cnt += 1
    if cnt == k:
    	print(i)
        break
else:
	print(-1)

6 3
3

6) GPT Sol

N, K = map(int, input().split())
if N < 1 or N > 10000 or K < 1 or K > N:
    print(-1)
else:
    divisors = []
    for i in range(1, N + 1):
        if N % i == 0:
            divisors.append(i)
if len(divisors) < K:
    print(-1)
else:
    print(divisors, divisors[K - 1])

100 5
[1, 2, 4, 5, 10, 20, 25, 50, 100] 10

02_K번째 수

1) Problem

N개의 숫자로 이루어진 숫자열이 주어지면 해당 숫자열중에서 s번째부터 e번째 까지의 수를 오름 차순 정렬했을 때 k번째로 나타나는 숫자를 출력하는 프로그램을 작성하세요.
입력설명 :
첫 번째 줄에 테스트 케이스 T(1<=T<=10)이 주어집니다
각 케이스별
첫 번째 줄은 자연수 N(5<=N<=500), s, e, k가 차례로 주어진다. 두 번째 줄에 N개의 숫자가 차례로 주어진다
출력설명 :
각 케이스별 k번째 수를 아래 출력예제와 같이 출력하세요.

입력예제
2
6 2 5 3
5 2 7 3 8 9
15 3 10 3
4 15 8 16 6 6 17 3 10 11 18 7 14 7 15

출력예제
#1 7
#2 6

입력예제 해설 :
case 1 : 2 7 3 8의 숫자 중 오름차순 정렬 했을 때 3번째 숫자는 7이다.
case 2 : 8 16 6 6 17 3 10 11의 숫자 중 오름차순 정렬 했을 때 3번째 숫자는 6이다.

2) My Sol

T = int(input('반복 횟수 : '))
for t in range(T):
    n, s, e, k = map(int, input('| 요소 개수 n | s부터 | e까지 | k번째 | : ').split())
    a1 = list(map(int, input('n개의 요소 입력 : ').split()))
    a2 = a1[s - 1:e]
    a2.sort()
    print(f'case{t + 1} | list = {a} | 요소 개수 : {n}개 | {s}부터 {e}까지 자르기 : {a[s - 1:e]} | 오름차순 정렬 : {a1} | {k}번째 수 : {a2[k - 1]}')

반복 횟수 : 1
| 요소 개수 n | s부터 | e까지 | k번째 | : 5 2 4 2
n개의 요소 입력 : 10 50 30 100 77
case1 | list = [10, 50, 30, 100, 77] | 요소 개수 : 5개 | 2부터 4까지 자르기 : [50, 30, 100] | 오름차순 정렬 : [30, 50, 100] | 2번째 수 : 50

3) Lec Sol

T = int(input())
for t in range(T):
	n, s, e, k = map(int, input().split())
    a = list(map(int, input().split())
    a = a[s - 1:e]
    a.sort()
    print(a[k - 1])

1
5 2 4 2
10 50 30 100 77
50

4) GPT Sol

T = int(input())
for _ in range(T):
	N, s, e, k = map(int, input().split())
    a = list(map(int, input().split())
    slist = sorted(a[s - 1:e])
    print(slist[k - 1])

1
5 2 4 2
10 50 30 100 77
50

03_K번째 큰 수

1) Problem

현수는 1부터 100사이의 자연수가 적힌 N장의 카드를 가지고 있습니다
같은 숫자의 카드가 여러장 있을 수 있습니다
현수는 이 중 3장을 뽑아 각 카드에 적힌 수를 합한 값을 기록하려고 합니다
3장을 뽑을 수 있는 모든 경우를 기록합니다. 기록한 값 중 K번째로 큰 수를 출력 하는 프로그램을 작성하세요
만약 큰 수부터 만들어진 수가 25 25 23 23 22 20 19......이고 K값이 3이라면 K번째 큰 값은 22입니다

입력설명 :
첫 줄에 자연수 N(3<=N<=100)과 K(1<=K<=50) 입력되고, 그 다음 줄에 N개의 카드값이 입력 된다.
출력설명 :
첫 줄에 K번째 수를 출력합니다. K번째 수는 반드시 존재합니다.

입력예제
10 3
13 15 34 23 45 65 33 11 26 42
출력예제
143

2) Thinking

Ex. 카드 5장, 3장을 뽑았을 때의 모든 경우 중 3번째로 큰 수
카드 : 1, 2, 3, 4, 5
경우의 수는 다음과 같다

1 2 3 =6
1 2 4 =7
1 2 5 =8

1 3 4 =8
1 3 5 =9

1 4 5 =10

2 3 4 =9
2 3 5 =10

2 4 5 =11

3 4 5 =12

중복을 불허하는 집합에 추가
리스트로 형변환 후 정렬
인덱싱으로 마무리

3) Lec Sol

n, k = map(int, input().split())
a = list(map(int, input().split()))
res = set()
for i in range(n):
    for j in range(i + 1, n):
        for m in range(j + 1, n):
            res.add(a[i] + a[j] + a[m])

res = list(res)
res.sort() # sort(reverse = True)로 내림차순 정렬도 가능
print(res[-k])

5 3 
1 2 3 4 5
10

4) GPT Sol

• range 범위 설정으로 합이 중복되지 않도록 했기 때문에 리스트로 충분히 구현

N, K = map(int, input().split())
a = list(map(int, input().split()))
res = []
for i in range(N - 2): # 첫 번째 카드 : index값 0부터 ~ N-2번째 카드까지 선택
    for j in range(i + 1, N - 1): # 두 번째 카드 : index값 1부터 ~ N-1번째 카드까지 선택
        for m in range(j + 1, N): # 세 번째 카드 : index값 2부터 ~ N번째 카드까지 선택
            res.append(a[i] + a[j] + a[m])

res.sort(reverse = True)
print(res[K - 1])

5 3
1 2 3 4 5
10

04_대표값

1) 선수 지식 : 최솟값 구하기

arr = [5, 3, 7, 9, 2, 5, 2, 6]
arrMin = float('inf') # 양의 무한대
print(arrMin) # inf
for x in arr:
    if x < arrMin:
        arrMin = x
print(arrMin)

inf
2

2) 선수 지식 : 반올림

N = int(input('학생 수 : ')) # 5
alist = list(map(int, input('점수 입력 : ').split())) # 88 79 55 60 42

average = int(sum(alist) / N + 0.5)
# sum : 324
# divide : 64.8 # 반올림 전
# plus : 65.3
# int : 65 # 반올림 후
print(average) # 65

• round : round_half_even 방식, 짝수로 반올림.
  ex) 4.5 -> 4
  ex) 5.5 -> 6
  따라서 반올림 할 때, 0.5를 더하고 int형변환이 정확한 방법.
• 하지만 실제로 round 함수를 써보니 홀수로도 반올림이 잘 된다.

3) Problem

N명의 학생의 수학점수가 주어집니다
N명의 학생들의 평균(소수 첫째자리 반올림)을 구하고
N명의 학생 중 평균에 가장 가까운 학생은 몇 번째 학생인지 출력하는 프로그램을 작성하세요.
평균과 가장 가까운 점수가 여러 개일 경우 먼저 점수가 높은 학생의 번호를 답으로 하고
높은 점수를 가진 학생이 여러 명일 경우 그 중 학생번호가 빠른 학생의 번호를 답으로 합니다.

입력설명 :
첫줄에 자연수 N(5<=N<=100)이 주어지고
두 번째 줄에는 각 학생의 수학점수인 N개의 자연 수가 주어집니다
학생의 번호는 앞에서부터 1로 시작해서 N까지이다
출력설명 :
첫줄에 평균과 평균에 가장 가까운 학생의 번호를 출력한다
평균은 소수 첫째 자리에서 반올림합니다

입력예제
10
45 73 66 87 92 67 75 79 75 80
출력예제
74 7

예제설명 :
평균이 74점으로 평균과 가장 가까운 점수는 73(2번), 75(7번), 75(9번)입니다
여기서 점수가 높은 75(7번), 75(9번)이 답이 될 수 있고, 75점이 두명이므로 학생번호가 빠른 7번이 답이 됩니다.

4) Lec Sol

N = int(input('학생 수 N(5 ~ 100) : '))
alist = list(map(int, input('Scores : ').split()))
average = int(sum(alist) / N + 0.5) # 반올림 하는 법
min = 2147000000 # 정수형 크기의 가장 큰 값 2^32

for index, value in enumerate(alist):
    tmp = abs(value - average) # 점수와 평균의 차이
    if tmp < min: # 점수와 평균의 차이가 작아지기 위한 필터링
        min = tmp # 최소 차이 업데이트
        score = value # 그때의 학생 성적
        res = index + 1 # 그때의 학생이 몇번째인지
    elif tmp == min: # 최소차가 같을 때
        if value > score: # 실제 점수가 더 높은 학생이 갱신
            score = value # 그때의 학생 성적
            res = index + 1 # 그때의 학생이 몇번째인지
            
if N < 5 or N > 100:
    print('N is out of range')
else:
    print(f'Average : {average} | Represent Index : {res}')

학생 수 N(5 ~ 100) : 10
Scores : 45 73 66 87 92 67 75 79 75 80
Average : 74 | Represent Index : 7

# 분석
설명
N = 10, alist = [45, 73, 66, 87, 92, 67, 75, 79, 75, 80]
averge = 73.9 -> 74
min = 2147000000
1. for >> index = 0, value = 45
    tmp = 29 >> score = tmp(29), res = 1
2. for >> index = 1, value = 73
    tmp = 1 >> score = tmp(1), res = 2
3. for >> index = 2, value = 66
    tmp = 8 >> tmp < min X, tmp == min X
    .
    .
    .
7. for >> index = 6, value = 75
    tmp = 1 >> tmp(1) < min(1) X
    >> elif tmp == min >> value(75) > score(73)
    >> score = value = 75 >> res = 7
    .
    .
    .
9. for >> index = 8, value = 75
    tmp = 1 >> tmp(1) < min(1) X
    >> elif tmp == min >> value(75) > score(75) X

5) GPT Sol

N = int(input())
alist = list(map(int, input().split()))
average = round(sum(alist) / N)
min = float('inf') # 점수와 평균의 차이를 저장할 곳
res = 0 # 그 차이가 가장 작은 학생의 번호를 저장할 곳

for index in range(N):
    tmp = abs(alist[index] - average) # index번째 학생의 점수와 평균의 차이를 계산하여 tmp에 저장
    if tmp < min: # 최소차이일 경우
        min = tmp # 최소차이 업데이트
        res = index + 1 # 첫 번째 학생의 번호는 1이니 현재 index + 1을 저장
    elif tmp == min: # 최소차이가 같을 경우
        if alist[res - 1] < alist[index]: # (이전 번호 학생의 점수 < 현재 학생의 점수)일 경우
            res = index + 1 # 점수가 더 높은 학생으로 업데이트
            # 만약 점수가 같은 상황에서 번호가 빠른 학생이 정답이지만
            # #번호가 빠른 학생부터 처리를 하기 때문에 나중 학생이 점수가 크지 않는 이상 업데이트는 되지 않고 자동으로 번호가 빠른 학생이 정답이 된다.
print(average, res)

10
45 73 66 87 92 67 75 79 75 80
74 7

05_정다면체

1) Problem

두 개의 정 N면체와 정 M면체의 두 개의 주사위를 던져서
나올 수 있는 눈의 합 중 가장 확률이 높은 숫자를 출력하는 프로그램을 작성하세요.
정답이 여러 개일 경우 오름차순으로 출력합니다.

입력설명 :
첫 번째 줄에는 자연수 N과 M이 주어집니다. N과 M은 4, 6, 8, 12, 20 중의 하나입니다.
출력설명 :
첫 번째 줄에 답을 출력합니다.

입력예제
4 6
출력예제
5 6 7

2) My Sol

N, M = map(int, input('N면체 | M면체 : ').split())
cnt = [0] * (N + M + 1)
max = -2147000000
for i in range(1, N + 1):
    for j in range(1, M + 1):
        cnt[i + j] += 1
for i in range(1, N + M + 1):
    if cnt[i] > max:
        max = cnt[i]
for i in range(1, N + M + 1):
    if cnt[i] == max:
        if N not in [4, 6, 8, 12, 20] or M not in [4, 6, 8, 12, 20]:
            print('N or M is not 4, 6, 8, 12 or 20')
            break
        print(i, end = ' ')

N면체 | M면체 : 4 6
5 6 7 

3) Lec Sol

N, M = map(int, input('N면체 | M면체 : ').split())
cnt = [0] * (N + M + 3)
max = -2147000000
for i in range(1, N + 1):
    for j in range(1, M + 1):
        cnt[i + j] += 1
for i in range(N + M + 1):
    if cnt[i] > max:
        max = cnt[i]
for i in range(N + M + 1):
    if cnt[i] == max:
        print(i, end = ' ')

N면체 | M면체 : 4 6
5 6 7 

# 분석
N = 4, M = 6
cnt = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
1. for i(1 ~ 4) >> for j(1 ~ 6) : 4면체는 나올 숫자가 i(1~4), 6면체는 j(1~6)
>> cnt = [0, 0, 1, 2, 3, 4, 4, 4, 3, 2, 1]
>> 요소 값들은 주사위 두개를 던져 나오는 두수의 합이 나오는 경우의 수
>> ex1. cnt[2] = 1 : 2가 나오는 경우의 수가 (1, 1)로 1개의 경우가 있다
>> ex2. cnt[3] = 2 : 3이 나오는 경우의 수가 (1, 2), (2, 1)로 2개의 경우가 있다

2. for i(1 ~ 10) >>
i=1, cnt[1], 0 > max(-2147000000) >> max=0
i=2, cnt[2], 1 > max(0) >> max=1
i=3, cnt[3], 2 > max(1) >> max=2
i=4, cnt[4], 3 > max(2) >> max=3
i=5, cnt[5], 4 > max(3) >> max=4
i=6, cnt[6], 4 > max(4) x
.
.
.
i=10, cnt[10], 1 > max(4) x

3. for i(1 ~ 10) >>
i=1, cnt[1], 0 == max(4) x
i=2, cnt[2], 1 == max(4) x
.
.
.
i=5, cnt[5], 4 == max(4) >> print(i) > 5
i=6, cnt[6], 4 == max(4) >> print(i) > 6
i=7, cnt[7], 4 == max(4) >> print(i) > 7
i=8, cnt[8], 3 == max(4) x
.
.
.
i=10, cnt[10], 1 == max(4) x

>> 출력은 5 6 7

4) GPT Sol

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

for i in range(1, N + 1):
    for j in range(1, M + 1):
        sum_list.append(i + j) # 더한 결과를 계속 append, 당연히 중복됨

from collections import Counter
count = Counter(sum_list) # dict 형태로 '합: 나온 횟수' count에 저장
max_count = max(count.values()) # count라는 dict의 value값 중에 최댓값을 max_count에 저장

for key, value in count.items(): # count라는 dict의 items를 가져오면서 최댓값과 같은 value를 가진 key를 출력
    if value == max_count:
        print(key, end=' ')
# 4 6
# 5 6 7

06_자릿수의 합

1) Problem

N개의 자연수가 입력되면 각 자연수의 자릿수의 합을 구하고
그 합이 최대인 자연수를 출력 하는 프로그램을 작성하세요
각 자연수의 자릿수의 합을 구하는 함수를 def digit_sum(x)를 꼭 작성해서 프로그래밍 하세요.

입력설명 :
첫 줄에 자연수의 개수 N(3<=N<=100)이 주어지고
그 다음 줄에 N개의 자연수가 주어진다. 각 자연수의 크기는 10000000를 넘지 않는다.
출력설명 :
자릿수의 합이 최대인 자연수를 출력한다
자릿수의 합이 같을 경우 입력순으로 먼저인 숫자 를 출력합니다.

입력예제
3
125 15232 97
출력예제
97

2) Thinking

자연수 개수 입력받기
리스트에 자연수 입력받기
최댓값 저장할 변수 선언

리스트에서 숫자 하나씩 불러와서 자릿수 계산 후(함수 이용) 현재 최댓값보다 큰지 비교
크다면 최댓값으로 업데이트
불러온 그 숫자를 정답으로 업데이트

3) Lec Sol

def digit_sum(x): # 숫자의 자릿수 합 구하기
    sum = 0
    while x > 0:
        sum += x % 10
        x = x // 10
    return sum

N = int(input()) # 자연수 개수 입력받기
nlist = list(map(int, input().split())) # 개수만큼 자연수 입력받기
max = -2147000000 # 최댓값 업데이트할 변수 선언
for i in nlist: # 숫자 하나씩 불러오기
    sum_list = digit_sum(i) # 자릿수 합 리턴받기
    if sum_list > max: # 합이 최댓값보다 크면
        max = sum_list # 그 합을 최댓값으로 업데이트
        res = i # 그때의 원래 숫자 업데이트
print(res)

4) GPT Sol

def digit_sum(x):
    sum = 0
    for digit in str(x):
        sum += int(digit)
    return sum

N = int(input())
nlist = list(map(int, input().split()))
max = 0
res = 0

for i in nlist:
    sum_list = digit_sum(i)
    if sum_list > max: # 자릿수의 합이 기록보다 커질 때만 답을 업데이트하며, 순서대로 처리하기 때문에
        # 자릿수의 합이 기록과 같을 경우에는 업데이트 되지 않고 이전의 기록이 답으로 유지된다.
        max = sum_list
        res = i
print(res)

3
111 101 102
111

# 분석
N = 3, nlist = [125, 15232, 97], max = -2147000000
for k in nlist >>
k = 125 >> sumlist = digit_sum(125)
>> sum = 0, for i in str(125)
>> i = '1' >> sum += int('1') >> sum = 1
>> i = '2' >> sum += int('2') >> sum = 3
>> i = '5' >> sum += int('5') >> sum = 8
>> return 8

>> sumlist = 8
>> if sumlist(8) > max(-2147000000)
>> max = sumlist(8), res = k(125)

k = 15232 >> sumlist = digit_sum(15232)
>> sum = 0, for i in str(15232)
>> i = '1' >> sum += int('1') >> sum = 1
>> i = '5' >> sum += int('5') >> sum = 6
>> i = '2' >> sum += int('2') >> sum = 8
>> i = '3' >> sum += int('3') >> sum = 11
>> i = '2' >> sum += int('2') >> sum = 13
>> return 13

>> sumlist = 13
>> if sumlist(13) > max(8)
>> max = sumlist(13), res = k(15232)

k = 97 >> sumlist = digit_num(97)
>> sum = 0, for i in str(97)
>> i = '9' >> sum += int('9') >> sum = 9
>> i = '7' >> sum += int('7') >> sum = 16
>> return 16

>> sumlist = 16
>> if sumlist(16) > max(13)
>> max = sumlist(16), res = k(97)

>> print(res) >> 97

07_소수, 에라토스테네스 체

1) Problem

자연수 N이 입력되면 1부터 N까지의 소수의 개수를 출력하는 프로그램을 작성하세요
만약 20이 입력되면 1부터 20까지의 소수는 2, 3, 5, 7, 11, 13, 17, 19로 총 8개입니다
제한시간은 1초입니다.

입력설명 :
첫 줄에 자연수의 개수 N(2<=N<=200000)이 주어집니다.
출력설명 :
첫 줄에 소수의 개수를 출력합니다.

입력예제
20
출력예제
8

2) Lec Sol

N = int(input('N까지의 소수 구하기, N : '))
ch = [0] * (N + 1)
cnt = 0
for i in range(2, N + 1):
    if ch[i] == 0:
        cnt += 1
        for j in range(i, N + 1, i):
            ch[j] = 1
print(f'소수의 개수 : {cnt}')

N까지의 소수 구하기, N : 20
소수의 개수 : 8

분석
N = 20, ch = [0] * (21) = ['00000 00000 00000 00000 0'], cnt = 0
for i(2 ~ 20)
>> i = 2 >> if ch[2] == 0 >> cnt += 1 >> cnt = 1
>> for j(2 ~ 20) by 2 >> ch[2, 4, 6, 8, 10, 12, 14, 16, 18, 20] = 1
>> ch = ['00101 01010 10101 01010 1']

>> i = 3 >> if ch[3] == 0 >> cnt += 1 >> cnt = 2
>> for j(3 ~ 20) by 3 >> ch[3, 6, 9, 12, 15, 18] = 1
>> ch = ['00111 01011 10101 11010 1']

>> i = 4 >> ch[4] == 1
>> i = 5 >> ch[5] == 0 >> cnt += 1 >> cnt = 3
>> for j(5 ~ 20) by 5 >> ch[5, 10, 15, 20] = 1
>> ch = ['00111 11011 10101 11010 1']

>> i = 6 >> ch[6] == 1
>> i = 7 >> ch[7] == 0 >> cnt += 1 >> cnt = 4
>> for j(7 ~ 20) by 7 >> ch[7, 14] = 1
>> ch = ['00111 11111 10101 11010 1']

>> i = 8, 9, 10 >> ch[8, 9, 10] == 1
>> i = 11 >> ch[11] == 0 >> cnt += 1 >> cnt = 5
>> for j(11, 20) by 11 >> ch[11] = 1
>> ch = ['00111 11111 11101 11010 1']

>> i = 12 >> ch[12] == 1
>> i = 13 >> ch[13] == 0 >> cnt += 1 >> cnt = 6
>> for j(13, 20) by 13 >> ch[13] = 1
>> ch = ['00111 11111 11111 11010 1']

>> i = 14, 15, 16 >> ch[14, 15, 16] == 1
>> i = 17 >> ch[17] == 0 >> cnt += 1 >> cnt = 7
>> for j(17, 20) by 17 >> ch[17] = 1
>> ch = ['00111 11111 11111 11110 1']

>> i = 18 >> ch[18] == 1
>> i = 19 >> ch[19] == 0 >> cnt += 1 >> cnt = 8
>> for j(19, 20) by 19 >> ch[19] = 1
>> ch = ['00111 11111 11111 11111 1']

>> i = 20 >> ch[20] == 1

>> print(cnt) >> 8

3) GPT Sol

N = int(input()) # 자연수 입력받기
cnt = 0 # 소수의 개수를 저장할 변수 선언

for num in range(2, N + 1): # 2부터 N까지의 자연수에 대해 소수인지 판별 시작
    is_prime = True # Boolean 값을 저장할 변수 선언, 다음 for문을 만족하지 못하면 소수이므로 True로 선언한 것.
    for i in range(2, num): # num=2일 때는 for문 실행 안함, 따라서 앞서 True할당했기 때문에 cnt=1
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        cnt += 1
print(cnt)
# 10
# 4

08_뒤집은 소수

1) Problem

N개의 자연수가 입력되면 각 자연수를 뒤집은 후 그 뒤집은 수가 소수이면 그 수를 출력하는 프로그램을 작성하세요
예를 들어 32를 뒤집으면 23이고, 23은 소수이다
그러면 23을 출력 한다
단 910를 뒤집으면 19로 숫자화해야 한다
첫 자리부터의 연속된 0은 무시한다.
뒤집는 함수인 def reverse(x) 와 소수인지를 확인하는 함수 def isPrime(x)를 반드시 작성하여 프로그래밍한다.

입력설명 :
첫 줄에 자연수의 개수 N(3<=N<=100)이 주어지고
그 다음 줄에 N개의 자연수가 주어진다
각 자연수의 크기는 100000를 넘지 않는다.
출력설명 :
첫 줄에 뒤집은 소수를 출력합니다.
출력순서는 입력된 순서대로 출력합니다.

입력예제
5
32 55 62 3700 250
출력예제
23 73

2) Thinking

숫자를 뒤집는 함수를 정의
숫자가 소수인지 판단하는 함수 정의
두 함수 모두 만족했을 때 그 뒤집힌 수를 출력

3) Lec Sol

def reverse(x):
    res = 0
    while x > 0:
        t = x % 10
        res = res * 10 + t
        x = x // 10
    return res

def isPrime(x):
    if x == 1:
        return False
    for i in range(2, x // 2 + 1):
        if x % i == 0:
            return False
    else:
        return True

N = int(input())
nlist = list(map(int, input().split()))

for i in nlist:
    tmp = reverse(i)
    if isPrime(tmp):
        print(tmp)
# 3
# 13 23 89
# 31

# 분석
N = 5
nlist = [32, 55, 62, 3700, 250]
for x in nlist
    tmp = reverse(32)
        >> res = 0, while 32 > 0
            >> t = 32 % 10 = 2
            >> res = 0 * 10 + 2 = 2
            >> x = 32 // 10 = 3
        >> while 3 > 0
            >> t = 3 % 10 = 3
            >> res = 2 * 10 + 3
            >> x = 3 // 10 = 0
        >> while 0 > 0
        >> return 23
    >> tmp = 23
    if isPrime(23)
        23 != 1
        for i in range(2, 12) >> i(2 ~ 11)
            >> 23 % 2 != 0
            >> 23 % 3 != 0
            >> 23 % 4 != 0
            .
            .
            .
            >> 23 % 11 != 0
        else return True
        print(23)
    
    tmp = reverse(55)
        >> res = 0, while 55 > 0
            >> t = 55 % 10 = 5
            >> res = 0 * 10 + 5 = 5
            >> x = 55 // 10 = 5
        >> while 5 > 0
            >> t = 5 % 10 = 5
            >> res = 5 * 10 + 5 = 55
            >> x = 5 // 10 = 0
        >> while 0 > 0
        >> return 55
    >> tmp = 55
    if isPrime(55)
        55 != 1
        for i in range(2, 28) >> i(2 ~ 27)
            >> 55 % 2 != 0
            >> 55 % 3 != 0
            >> 55 % 4 != 0
            >> 55 % 5 == 0
            >> return False
        
    tmp = reverse(62)
        >> res = 0, while 62 > 0
            >> t = 62 % 10 = 2
            >> res = 0 * 10 + 2 = 2
            >> x = 62 // 10 = 6
        >> while 6 > 0
            >> t = 6 % 10 = 6
            >> res = 2 * 10 + 6 = 26
            >> x = 6 // 10 = 0
        >> while 0 > 0
        >> return 26
    >> tmp = 26
    if isPrime(26)
        26 != 1
        for i in range(2, 14) >> i(2 ~ 13)
            >> 26 % 2 == 0
            >> return False
        
    tmp = reverse(3700)
        >> res = 0, while 3700 > 0
            >> t = 3700 % 10 = 0
            >> res = 0 * 10 + 0 = 0
            >> x = 3700 // 10 = 370
        >> while 370 > 0
            >> t = 370 % 10 = 0
            >> res = 0 * 10 + 0 = 0
            >> x = 370 // 10 = 37
        >> while 37 > 0
            >> t = 37 % 10 = 7
            >> res = 0 * 10 + 7 = 7
            >> x = 37 // 10 = 3
        >> while 3 > 0
            >> t = 3 % 10 = 3
            >> res = 7 * 10 + 3 = 73
            >> x = 3 // 10 = 0
        >> while 0 > 0
        >> return 73
    >> tmp = 73
    if isPrime(73)
        73 != 1
        for i in range(2, 37) >> i(2 ~ 36)
            >> 73 % 2 != 0
            >> 73 % 3 != 0
            >> 73 % 4 != 0
            .
            .
            .
            >> 73 % 36 != 0
        else return True
        print(73)
    
    tmp = reverse(250)
        >> res = 0, while 250 > 0
            >> t = 250 % 10 = 0
            >> res = 0 * 10 + 0 = 0
            >> x = 250 // 10 = 25
        >> while 25 > 0
            >> t = 25 % 10 = 5
            >> res = 0 * 10 + 5 = 5
            >> x = 25 // 10 = 2
        >> while 2 > 0
            >> t = 2 % 10 = 2
            >> res = 5 * 10 + 2 = 52
            >> x = 2 // 10 = 0
        >> while 0 > 0
        >> return 52
    >> tmp = 52
    if isPrime(52)
        52 != 1
        for i in range(2, 27) >> i(2 ~ 26)
            >> 52 % 2 == 0
            >> return False

09_주사위 게임

1) Problem

1에서부터 6까지의 눈을 가진 3개의 주사위를 던져서 다음과 같은 규칙에 따라 상금을 받는 게임이 있다.

규칙1. 같은 눈이 3개가 나오면 10000원 + (같은 눈) 1000원의 상금을 받게 된다.
규칙2. 같은 눈이 2개만 나오는 경우에는 1000원 + (같은 눈) 100원의 상금을 받게 된다.
규칙3. 모두 다른 눈이 나오는 경우에는 (그 중 가장 큰 눈) * 100원의 상금을 받게 된다.

예를 들어, 3개의 눈 3, 3, 6이 주어지면 상금은 1000 + 3 100으로 계산되어 1300원을 받게 된다.
또, 3개의 눈이 2, 2, 2로 주어지면 10000 + 2 1000으로 계산되어 12000원을 받게 된다.
3개의 눈이 6, 2, 5로 주어지면 그 중 가장 큰 값이 6이므로 6 * 100으로 계산되어 600원을 상금으로 받게 된다.
N명이 주사위 게임에 참여하였을 때, 가장 많은 상금을 받은 사람의 상금을 출력하는 프로그램을 작성하시오.

입력설명 :
첫째 줄에는 참여하는 사람 수 N(2 ~ 1000)이 주어지고,
그 다음 줄부터 N개의 줄에 사람들이 주사위를 던진 3개의 눈이 빈칸을 사이에 두고 각각 주어진다.

출력설명 :
첫째 줄에 가장 많은 상금을 받은 사람의 상금을 출력한다.

입력예제 1
3
3 3 6
2 2 2
6 2 5

출력예제 1
12000

2) Thinking

참여자 수 입력받기
주사위 눈 입력받기
사람마다 상금 계산
상금 계산하는 과정은 조건 별로 분류
1. 주사위 눈이 다 같을때
2. 두개만 같을 때
3. 이외의 상황 = 상금 계산에 가장 큰 눈이 뭔지 알아야함 : sort로 오름차순 정렬하여 c가 가장 큰 눈이 되게 만들기
상금이 최댓값보다 크면 업데이트

3) Lec Sol

N = int(input())
res = 0
for i in range(N):
    tmp = input().split()
    tmp.sort()
    a, b, c = map(int, tmp) # int화 되어 순서대로 a, b, c에 mapping
    if a == b and b == c:
        m = 10000 + a * 1000
    elif a == b or b == c:
        m = 1000 + b * 100
    elif a == c:
        m = 1000 + a * 100
    else:
        m = 100 * c
    if m > res:
        res = m
print(res)

3
3 3 6
2 2 2 
6 2 5
12000

4) GPT Sol

# 'int' object is not callable error : 예약어를 변수명으로 사용했기 때문. ex) sum, min, max 등
# del max 명령어로 오류를 발생시킨 변수를 삭제하고 실행하면 된다.

N = int(input())

def calculate_prize(dice):
    if dice[0] == dice[1] == dice[2]:
        return 10000 + dice[0] * 1000
    elif dice[0] == dice[1] or dice[0] == dice[2] or dice[1] == dice[2]:
        if dice[0] == dice[1]:
            return 1000 + dice[0] * 100
        elif dice[0] == dice[2]:
            return 1000 + dice[0] * 100
        else:
            return 1000 + dice[1] * 100
    else:
        return max(dice) * 100

prizes = []
for _ in range(N):
    dice = list(map(int, input().split()))
    prize = calculate_prize(dice)
    prizes.append(prize)

print(max(prizes))

3
3 3 6
2 2 2 
6 2 5
12000

10_점수 계산

1) Problem

OX 문제는 맞거나 틀린 두 경우의 답을 가지는 문제를 말한다.
여러 개의 OX 문제로 만들어진 시험에서 연속적으로 답을 맞히는 경우에는
가산점을 주기 위해서 다음과 같이 점수 계산을 하기로 하였다.
1번 문제가 맞는 경우에는 1점으로 계산한다.
앞의 문제에 대해서는 답을 틀리다가 답이 맞는 처음 문제는 1점으로 계산한다.
또한, 연속으로 문제의 답이 맞는 경우에서 두 번째 문제는 2점, 세 번째 문제는 3점, ..., K번째 문제는 K점으로 계산한다.
틀린 문제는 0점으로 계산한다.
예를 들어, 아래와 같이 10 개의 OX 문제에서 답이 맞은 문제의 경우에는 1로 표시하고,
틀린 경우에는 0으로 표시하였을 때, 점수 계산은 아래 표와 같이 계산되어, 총 점수는 1 + 1 + 2 + 3 + 1 + 2 = 10점이다.

채점 결과 >> O X O O O X X O O X
점수 계산 >> 1 0 1 2 3 0 0 1 2 0 >> 1 + 1 + 2 + 3 + 1 + 2 = 10점

입력설명 :
첫째 줄에 문제의 개수 N (1 ≤ N ≤ 100)이 주어진다.
둘째 줄에는 N개 문제의 채점 결과를 나타내는 0 혹은 1이 빈칸을 사이에 두고 주어진다.
0은 문제의 답이 틀린 경우이고, 1은 문제의 답이 맞는 경우이다.

출력설명 :
첫째 줄에 입력에서 주어진 채점 결과에 대하여 가산점을 고려한 총 점수를 출력한다.

입력예제 1
10
1 0 1 1 1 0 0 1 1 0

출력예제 1
10

2) Thinking

정답일 때는 점수를 누적한다
또한 연속 정답의 가능성을 두고 가중치를 1증가시켜 다음 문제도 맞았을 경우 2점을 얻는다.
정답이 아닐 경우 가중치를 0으로 초기화한다.

3) Lec Sol

N = int(input())
alist = list(map(int, input().split()))
score_sum = 0
weight = 0 # 가중치

for x in alist:
    if x == 1:
        cnt += 1
        score_sum += cnt
    else:
        cnt = 0
print(score_sum)

10
1 0 1 1 1 0 0 1 1 0
10