레이커 갓생일기

문제

점수계산

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

 1 0 1 1 1 0 0 1 1 0

시험문제의 채점 결과가 주어졌을 때, 총 점수를 계산하는 프로그램을 작성하시오.

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

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

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

▣ 출력예제 1
10

내 풀이

# 내 풀이
n = int(input())
a = list(map(int, input().split()))
sum = 0
cnt = 1
for i in range(n):
    if a[i] == 1 :
        #print(i+1, "번쨰 점수 더할 cnt 는", cnt)
        sum += cnt
        cnt += 1

    else:
        cnt = 1
        #print(i+1, "번쨰 점수 cnt 는", cnt)
print(sum)

점수

강사님 풀이

# 강사님 풀이
n = int(input())
a = list(map(int, input().split()))

sum = 0
cnt = 0
for x in a:
    if x == 1:
        cnt += 1
        sum += cnt
    else:
        cnt = 0
print(sum)

문제

주사위 게임

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

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

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

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

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

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

▣ 출력예제 1
12000

내 풀이

# 내 풀이
n = int(input())
maxNum = 0
for i in range(n):
    arr = list(map(int,input().split()))
    prize_money = 0

    if arr[0] == arr[1]:
        num = arr[0]
        if arr[1] == arr[2]:
            prize_money = 10000 + num * 1000
        else:
            prize_money = 1000 + num * 100
    elif arr[1] == arr[2]:
        num = arr[1]
        if arr[1] == arr[0]:
            prize_money = 10000 + num * 1000
        else:
             prize_money = 1000 + num * 100           
    elif arr[2] == arr[0]:
        num = arr[2]
        if arr[2] == arr[1]:
            prize_money = 10000 + num * 1000
        else:
            prize_money = 1000 + num * 100
    else:
        prize_money = max(arr) * 100
    #print(prize_money)
    if prize_money > maxNum:
        maxNum = prize_money
print(maxNum)

점수

강사님 풀이

# 강사님 풀이
n = int(input())
res = 0
for i in range(n):
    tmp = input().split() # 문자형으로, ['1', '2', '3'] 저장
    tmp.sort() # 눈이 다르면 큰수 찾아야하므로 정렬
    a, b, c = map(int, tmp) # c 가 가장 큰 수
    #print(a, b, c)
    if a == b and b == c: # 가장 좋은 조건을 가장 먼저 if 로 씀
        money = 10000 + a * 1000
    elif a == b or a == c:
        money = 1000 + (a * 100)
    elif b == c:
        money = 1000 + (b * 100)
    else:
        money = c * 100
    if money > res:
        res = money
print(res)

# 가장 좋은 조건을 먼저 if 로 작성

# a == b 와 a ==  c 일땐 공통인 값은 a 로 쓰면 되고 , b == c 일땐 공통인 값은 b 로 쓰면 되므로 두 경우를 따로 작성

문제

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

▣ 입력설명
첫 줄에 자연수의 개수 N(3<=N<=100)이 주어지고, 그 다음 줄에 N개의 자연수가 주어진다.
각 자연수의 크기는 100,000를 넘지 않는다.

▣ 출력설명
첫 줄에 뒤집은 소수를 출력합니다. 출력순서는 입력된 순서대로 출력합니다.

▣ 입력예제 1
5
32 55 62 3700 250

▣ 출력예제 1
23 73

내 풀이

# 내 풀이
def reverse(x):
    sum = 0
    mul = 100000
    while x > 0:
        mul /= 10
        sum += x % 10 * mul
        x = x // 10
    return int(sum/mul)

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

n = input()
nums = list(map(int, input().split()))

for x in nums:
    rev = reverse(x)
    if isPrime(rev):
        print(rev, end=" ")

점수

강사님 풀이

# 강사님 풀이
n = input()
a = list(map(int, input().split()))

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): # + 1 해줘야 절반'까지' 돈다
        if x % i == 0:
            return False
    else:
        return True

for x in a:
    tmp = reverse(x)
    if isPrime(tmp):
        print(tmp, end=" ")

<reverse>
# 125 % 10 == 5 끝자리 구해짐

# res = res * 10 + 끝자리 를 반복하면 한자리씩 올라가면서 누적된다

<isPrime>

# 16 에서 1, 16 을 제외한 약수는 8 까지 존재한다
# 16 의 약수 : 1 2 4 8 16
# 그러므로 절반인 8 까지만 돌면 그 뒤로는 자신을 제외한  약수가 없다
# 즉 8 까지 나눠지는 수가 없으면 소수이다

문제

소수(에라토스테네스 체)

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

▣ 입력설명
첫 줄에 자연수의 개수 N(2<=N<=200,000)이 주어집니다.

▣ 출력설명
첫 줄에 소수의 개수를 출력합니다.

▣ 입력예제 1
20

▣ 출력예제 1
8

내 풀이

# 내 풀이
n = int(input()) # N
# 소수 : 나눠지는 수가 1 과 자신뿐, 1 은 소수 아님
count = 0
for x in range(2, n+1): # 2 부터 N 까지
    for i in range(2, x):
        if x % i == 0:
            break
    else:
        count += 1
print(count)

점수

강사님 풀이

n = int(input()) # 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): # i 부터 i 씩 증가 = i 의 배수
            ch[j] = 1
print(cnt)

# 에라토스테네스 체

# 2를 카운트하고, 2의 배수는 모두 지우기, 3을 카운트하고, 3의 배수는 모두 지우기 ...

문제

자릿수의 합

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

▣ 입력설명
첫 줄에 자연수의 개수 N(3<=N<=100)이 주어지고, 그 다음 줄에 N개의 자연수가 주어진다.
각 자연수의 크기는 10,000,000를 넘지 않는다.

▣ 출력설명
자릿수의 합이 최대인 자연수를 출력한다. 자릿수의 합이 같을 경우 입력순으로 먼저인 숫자
를 출력합니다.

▣ 입력예제 1
3
125 15232 97

▣ 출력예제 1
97

내 풀이

# 내 풀이
def digit_sum(x):
    sum = 0
    init = 1000000
    for i in range(7):
        if(x // init > 0):
            sum += (x//init)
            x = x % init
        init /= 10
    return sum

n = input()
num = list(map(int, input().split()))

max = 0
index = -1
for i, x in enumerate(num):
    result = digit_sum(x)
    if result > max:
        max = result
        end = x  

print(end)

점수

강사님 풀이

# 강사님 풀이
#import sys
#sys.stdin = open("input.txt", "r")
n = input()
a = list(map(int, input().split()))

def digit_sum(x):
    sum=0
    while x > 0 :
        sum += x % 10 # 끝자리수가 나온다 125 % 10 == 5
        x = x // 10 # 마지막 자리 를 없앤다 125 // 10 == 12
    return sum

max = - 2147000000
for x in a:
    tot = digit_sum(x)
    if tot > max:
        max = tot
        res = x
print(res)

# 125 % 10 == 5

# 125 // 10 == 12

# 끝자리부터 더하면 된다

# 또다른 풀이

# 파이썬에선 이런 풀이도 가능
def digit_sum1(x):
    sum = 0
    for i in str(x): # x 를 문자열처리, i 는 각 자리 문자 하나를 받음
        sum += int(i)
    return sum

max = -2147000000 # 4바이트 정수형 최소 숫자

for x in a:
    tot = digit_sum1(x)
    if tot > max:
        max = tot
        res = x
print(res)

# 각 자리를 문자열로 받고 반복문으로 한자리씩 구해서 더하기

문제

정다면체

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

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

▣ 출력설명
첫 번째 줄에 답을 출력합니다.

▣ 입력예제 1
4 6

▣ 출력예제 1
5 6 7

내 풀이

# 내 코드
n, m = map(int, input().split())
#print(n, m)
maxNum = n + m
sum = []
# 주사위 모든 경우의 수
count = [0 for i in range(maxNum)]
for i in range(n):
    for j in range(m):
        sum.append((i+1) + (j+1))
        
#print(sum)
#print(len(sum)) # 4 * 6

# 카운트하기
for i in range(maxNum):
    for j in range(len(sum)):
        if sum[j]== i + 1:
            count[i] += 1

#print(count)

# 가장 큰 수 고르기 (가장 많은 확률)
minIndex = -1
maxIndex = -1
maxNum = 0
for i, x in enumerate(count):
    if x > maxNum:
        maxNum = x
        minIndex = i
    if x == maxNum:
        maxIndex = i
#print(maxNum)
#print(minIndex)
#print(maxIndex)

# 그 경우의 index 구하기
for i in range (minIndex + 1, maxIndex + 2): #인덱스조정
    print(i, end=" ")

점수

강사님 풀이

# 강사님 코드
#import sys
#sys.stdin=open("input,txt", "r")
n, m = map(int, input().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명의 학생의 수학점수가 주어집니다. N명의 학생들의 평균(소수 첫째자리 반올림)을 구하고,
N명의 학생 중 평균에 가장 가까운 학생은 몇 번째 학생인지 출력하는 프로그램을 작성하세
요.

평균과 가장 가까운 점수가 여러 개일 경우 먼저 점수가 높은 학생의 번호를 답으로 하고, 높
은 점수를 가진 학생이 여러 명일 경우 그 중 학생번호가 빠른 학생의 번호를 답으로 합니다.

▣ 입력설명
첫줄에 자연수 N(5<=N<=100)이 주어지고, 두 번째 줄에는 각 학생의 수학점수인 N개의 자연
수가 주어집니다. 학생의 번호는 앞에서부터 1로 시작해서 N까지이다.

▣ 출력설명
첫줄에 평균과 평균에 가장 가까운 학생의 번호를 출력한다.
평균은 소수 첫째 자리에서 반올림합니다.

▣ 입력예제 1
10
45 73 66 87 92 67 75 79 75 80

▣ 출력예제 1
74 7

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

내 풀이

# 내 풀이
n = int(input())
arr = list(map(int,input().split()))
sum = 0
# 평균 구하기
for x in arr :
    sum += x
avg = round(sum/n)

#print(avg)
# 차이 구하기
diffArr = []
for i in range(n):
    diffArr.append(abs(avg-arr[i]))

#print(diffArr)
# 절대값의 최소값 구하기
arrMin = float('inf')
index = -1
for i in range(n):
    if diffArr[i] < arrMin:
        arrMin = diffArr[i]
        index = i
#print(arrMin)
#print(-arrMin)
#print(index)

#절대값이 최소값인 것 찾기
result = 0
for i in range(n):
    if diffArr[i] == -arrMin:
        result = i + 1
        break
else:
    result = index + 1

#print(result)

print(avg, result)

점수

강사님 풀이

#import sys
#sys.stdin=open("input.txt", "r")
n = int(input())
a = list(map(int,input().split()))
min = 2147000000

#평균 구하기
ave = round(sum(a)/n) # sum 은 리스트의 모든 값 합해

#평균과 가까운 값 탐색
for idx, x in enumerate(a): # a 리스트의 값 (0,a[0]) 이 반환 idx = 0, x = a[0] 이 됨
    tmp = abs(x-ave)
    if tmp < min :
        min = tmp
        score = x # 차이의 절대값이 가장 작은 값일때 점수를 저장
        res = idx + 1 # 그때의 학생번호 
    elif tmp == min : # 같은
        if x > score : # 현재 점수가 저번에 저장된 점수보다 크면
            score = x
            res = idx + 1
print(ave,res)

# 절대값이 작은 값일땐 계속 작은값을 넣는식, 절대값이 같은 값일땐 큰값을 넣음
# 73 75 73 75 일때, 평균이 74
# 처음에 x 가 73일때 1이 min 이 된다, tmp 는 1
# 다음에 x 가 75알때 tmp 가 1 이므로 elif 에서 75 > score인 73 이므로 75가 score 가 됨
# 다음에 x 가 73일때 tmp 가 1 이므로 elif 에서 73 > score인 75 false 이므로 넘어감
# 다음에 x 가 75일때 tmp 가 1 이므로 elif 에서 75 > score인 75 false 이므로 넘어감
# 답은 가장 앞에 있는 75

# enumerate 활용

# 최대값, 최소값 구하기

# 대표값 문제 오류 수정, 반올림 round_half_up 하기

# 대표값 문제 오류 수정
# 우리가 아는 반올림은 round_half_up 방식 ( 5 이상 올림 )
# Python 의 round 는 round_half_even 방식을 택한다

# round_half_even 방식
a = 4.500
print(round(a)) # 4
# 정확히 하프 지점에 있으면 짝수(even)값으로 근사값 해줌
# ex) 4 와 5 의 하프지점에 있으므로 4로 간다

a = 4.5111 # 정확한 하프가 아니면 올라간다
print(round(a)) # 5

a = 5.5000
print(round(a)) # 6 (짝수로 간다)

a = 66.5
print(round(a)) # 66

# 소수 첫째자리에서 무조건 반올림 하는 법

a = 66.5
a = a + 0.5
# 66.5 여도 0.5 더하면 67, 66.6 이어도 0.5 더하면 67.1 로 자리올림 일어남
a=int(a) # 소수점 없어짐, 내림됨
print(a) # 처음의 a 에서 반올림한 67이 출력

# 66.4 이면 0.5 더해도 66.9 -> 66 이므로 올림안됨, 맞음

문제

K번째 큰 수

현수는 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번째 수는 반드시 존재합니다.

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

▣ 출력예제 1
143

내 풀이

# 80 점, 타임리밋
#import sys
#sys.stdin = open("index.txt", "rt")
n, k = map(int, input().split())
cards = list(map(int, input().split()))
sum = 0
li = []
for x in range(n):
    for y in range(n):
            for z in range(n):
                     if x != y and y != z and x != z:
                         sum = cards[x]+cards[y]+cards[z]
                         if sum not in li:
                             li.append(sum)
li.sort(reverse = True)
print(li[k-1])

점수

강사님 풀이

# 강사님 코드
#import sys
#sys.stdin = open("index.txt", "rt")
n, k = map(int, input().split())
a = list(map(int, input().split()))
res = set() #중복불가능한 자료구조 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) # set 은 sort 기능 없으므로 리스트로 바꾸기
res.sort(reverse=True)
print(res[k-1])

# set 자료구조 : 중복 없음
# j 는 i+1 부터, m 은 j+1 부터 돌아야 중복되지 않고 모든 카드 뽑을 수 있다

# 모두 0 부터 돌면 중복된다

문제

K번째 수

N개의 숫자로 이루어진 숫자열이 주어지면 해당 숫자열중에서 s번째부터 e번째 까지의 수를
오름 차순 정렬했을 때 k번째로 나타나는 숫자를 출력하는 프로그램을 작성하세요.

▣ 입력설명
첫 번째 줄에 테스트 케이스 T(1<=T<=10)이 주어집니다.
각 케이스별
첫 번째 줄은 자연수 N(5<=N<=500), s, e, k가 차례로 주어진다.
두 번째 줄에 N개의 숫자가 차례로 주어진다.

▣ 출력설명
각 케이스별 k번째 수를 아래 출력예제와 같이 출력하세요.

▣ 입력예제 1
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
#1 7
#2 6

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

내 풀이

#import sys
#sys.stdin=open("input.txt", "rt")

T = int(input()) # 테케 개수

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

점수

강사님 풀이

import sys
sys.stdin=open("input.txt", "rt")

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("#%d %d" %(t+1, a[k-1]))

# 같은 풀이이다

문제

K번째 약수

어떤 자연수 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번째 약수가 존재하지 않을 경우에는 -1을 출력하시오.

▣ 입력예제 1
6 3

▣ 출력예제 1
3

내 풀이

# 파일 입출력 위한 두줄
#import sys
#sys.stdin=open("input.txt", "rt")

# N의 약수들 중 K번째로 작은 수를 출력
n, k = map(int, input().split())
s = 0 # 약수 발견하면 +1씩 하기

for i in range(1, n+1):
    if n % i == 0:
        s = s+1
        if s == k:
            break
else:
    i = -1
print(i)

점수

강사님 풀이

#강사님 풀이
#import sys
#sys.stdin=open("input.txt", "rt")

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)

# 같은 풀이이다