Jinho Tech

단순 사칙연산 문제이다.

e, f, c = map(int, input().split())
n = (e+f)//c + (e+f)%c
res = (e+f)//c
while n//c:
    res += n//c
    n = n//c + n%c
print(res)

단순 구현 문제이다.

for _ in range(int(input())):
    s = input()
    n = str(int(s) + int(s[::-1]))
    print("YES" if n == n[::-1] else "NO")

단순 사칙연산 문제이다.

a, b, c = map(int, input().split())
i, j, k = map(int, input().split())
t = min(a/i, b/j, c/k)
print(a-i*t, b-j*t, c-k*t)

단순 사칙연산 문제이다. round 함수는 사사오입 원칙을 따라서 정확하게 반올림되지 않을 때가 있다.

EX) round(3.275, 2) = 3.27 

그래서 그냥 10**-10을 더해주는 꼼수를 부렸다.

원래는 반올림 함수를 직접 구현하는 게 맞는데 귀찮아서 이렇게 풀었다.

d = {"A+": 4.3, "A0": 4.0, "A-": 3.7, "B+": 3.3, "B0": 3.0, 
     "B-": 2.7, "C+": 2.3, "C0": 2.0, "C-": 1.7, "D+": 1.3, 
     "D0": 1.0, "D-": 0.7, "F": 0.0}
N = t = 0
for _ in range(int(input())):
    s, n, g = input().split()
    n = int(n) 
    N += n
    t += n*d[g]
print("%.2f" % (round(t/N + 10**-10, 2)))

단순 수학 문제이다.

li = sorted([int(input()) for _ in range(5)])
print(sum(li)//5)
print(li[2])

단순 구현 문제이다. 처음엔 아래 코드처럼 풀고

H, W = map(int, input().split())
res = []
for _ in range(H):
    s = input()    
    li = []
    c_idx = -1
    for i in range(W):
        if s[i] == 'c':
            li.append(0)
            c_idx = i
        elif c_idx == -1:
            li.append(-1)
        else:
            li.append(i-c_idx)
    res.append(li)
for a in res:
    print(*a)

마지막에 이렇게 고쳤다. 둘 다 통과됐다.

H, W = map(int, input().split())
for _ in range(H):
    s = input()    
    c_idx = -1
    for i in range(W):
        if s[i] == 'c':
            c_idx = i
            print(0, end=' ')
        elif c_idx == -1:
            print(-1, end=' ')
        else:
            print(i-c_idx, end=' ')
    print()

정렬 문제이다.

N = int(input())
li = sorted(list(map(int, input().split())), reverse=True)
t = [li[i]-(N-i-1) for i in range(N)]
res = N + max(t) + 1
print(res)

단순하지는 않은 정렬 문제이다. 뭔가 따로 처리해줘야 할 점이 많았던 것 같다.

if li[i-1][1:] != li[i][1:]:
            cnt = i+1

위 코드가 핵심 부분인 것 같다. 

N, K = map(int, input().split())
li = [list(map(int, input().split())) for _ in range(N)]
li.sort(key=lambda x:(x[1],x[2],x[3]), reverse=True)
cnt = 1
if li[0][0] == K:
    print(1)
else:
    for i in range(1, N):
        if li[i][0] == K:
            print(cnt if li[i-1][1:] == li[i][1:] else i+1)
        if li[i-1][1:] != li[i][1:]:
            cnt = i+1

단순 구현 문제이다.

for case in range(int(input())):
    words = [input() for _ in range(int(input()))]
    print(f"Scenario #{case+1}:")
    for _ in range(int(input())):
        li = list(map(int, input().split()))
        k, li = li[0], li[1:]
        res = ''.join([words[i] for i in li])
        print(res)
    print()

단순 정렬 문제이다.

for case in range(int(input())):
    t = list(map(int, input().split()))
    n, li = t[0], sorted(t[1:])
    Min = li[0]; Max = li[-1]
    g = max([li[i+1]-li[i] for i in range(n-1)])
    print("Class", case+1)
    print(f"Max {Max}, Min {Min}, Largest gap {g}")

단순 정렬 문제이다. 파이썬 짱!

li = []
for _ in range(int(input())):
    n, d, m, y = input().split()
    li.append([n, int(d), int(m), int(y)])
li.sort(key=lambda x:(x[3],x[2],x[1]))
print(li[-1][0])
print(li[0][0])

단순 수학 문제이다. 수열의 첫 번째 값만 찾으면 뒤는 쉽다.

1) a-b = a+c - (b+c) = li[0][2]-li[1][2] 

2) a = (a+b + a-b)/2 = (li[0][1] + li[0][2]-li[1][2])/2 

3) b = a+b - a = li[0][1] - a, c = a+c - a = li[0][2] - a, ... 

그리고 N = 2일 때는 그냥 따로 처리해주는 게 맞는 것 같다. 

EX) N = 2, 입력 [[2, 0], [0, 2]] -> 1 1 출력

N = int(input())
li = [list(map(int, input().split())) for _ in range(N)]
if N == 2:
    print(1, 1)
else:
    res = [(li[0][1] + li[0][2]-li[1][2])//2]
    for i in range(1, N):
        res.append(li[0][i]-res[0])
    print(*res)

단순 문자열 문제이다. 약간 꼼수를 썼는데,

반지 문자열을 2배 해버린 다음에 그 안에 찾고자 하는 문자열이 있는지 확인하는 방식으로 풀었다. 

이렇게 하면 반지가 시작과 끝이 연결된 형태라는 점을 고려하지 않고 쉽게 풀 수 있다.

t = input()
cnt = 0
for _ in range(int(input())):
    s = input()
    if t in s*2:
        cnt += 1
print(cnt)

`두 포인터 문제이다. 다른 방식으로 풀면 시간초과가 나와서 두 포인터를 써서 풀어야 된다.

N = int(input())
cnt = 0
s, e = 0, 1
t = 1
while e <= N and s <= e:
    if t == N:
        e += 1
        t = t - s + e
        s += 1
        cnt += 1
    elif t < N:
        e += 1
        t += e
    else:
        t -= s
        s += 1
print(cnt)

브루트포스 알고리즘 문제이다. 쓸데없이 어렵게 푼 것 같기도 하다.

N, M = map(int, input().split())
li = [input() for _ in range(N)]
s, dis = '', 0
for j in range(M):
    d = {}
    for i in range(N):
        d[li[i][j]] = d.get(li[i][j], 0) + 1
    d_li = sorted([[k, v] for k, v in d.items()])
    d_li.sort(key=lambda x:x[0])
    d_li.sort(key=lambda x:x[1], reverse=True)
    s += d_li[0][0]
    dis += N-d_li[0][1]
print(s)
print(dis)