Jinho Tech

단순 사칙연산 문제이다. 11522번 Sum Kind of Problem과 비슷한 문제이다.

for _ in range(int(input())):
    N = int(input())
    s1 = N*(N+1)//2
    s2 = int((N*2)*(N/2))
    s3 = int((N*2+2)*(N/2))
    print(s1, s2, s3)

단순 사칙연산 문제이다.

for _ in range(int(input())):
    li = list(map(int, input().split()))
    s = [li[i] + li[i+4] for i in range(4)]
    res = max(s[0], 1) + max(s[1], 1)*5 + max(s[2], 0)*2 + s[3]*2
    print(res)

단순 수학 문제이다.

A, B, C = map(int, input().split())
print(A^B if C%2 else A)

단순 사칙연산 문제이다.

N = int(input())
li = [input() for _ in range(N)]
res = sum([int(s[:-1])**int(s[-1]) for s in li])
print(res)

단순 수학 문제이다. 

L, D = int(input()), int(input())
X = int(input())
for i in range(L, D+1):
    if sum(map(int, list(str(i)))) == X:
        print(i)
        break
for i in range(D, L-1, -1):
    if sum(map(int, list(str(i)))) == X:
        print(i)
        break

단순 구현 문제이다. 제일 큰 숫자를 제외하고, 남은 숫자들의 합을 출력해주면 된다.

n = int(input())
li = sorted(list(map(int, input().split())))
print(sum(li[:-1]))

단순 수학 문제이다.

for _ in range(int(input())):
    k, N = map(int, input().split())
    s1 = N*(N+1)//2
    s2 = int((N*2)*(N/2))
    s3 = int((N*2+2)*(N/2))
    print(k, s1, s2, s3)

이 문제는 리스트를 sum함수를 써서 더하면 시간 초과가 나와서 사용하면 안 된다.

N, K = map(int, input().split())
li = list(map(int, input().split()))
t = sum(li[:K])
ans = t
for i in range(K, N):
    t += li[i]
    t -= li[i-K]
    ans = max(ans, t)
print(ans)

에라토스테네스의 체를 사용해야 하는 소수 문제이다. 9020번 골드바흐의 추측 문제와 비슷한 문제인데 

시간 초과 관련해서 더 훨씬 힘든 것 같다.

핵심은 1000000 까지의 소수를 미리 다 찾아놓고 while문을 돌리는 것이다. 안 그러면 시간 초과가 나온다. 

import sys

li = [1]*(1000001)
for i in range(2, int(1000001**0.5) + 1):
    if li[i] == 1:
        for j in range(i+i, 1000001, i):
            li[j] = 0

while 1:
    n = int(sys.stdin.readline())
    if n == 0:
        break
    a = b = 0
    for i in range(2, n//2+1):
        if li[i] == 1 and li[n-i] == 1:
            a, b = i, n-i
            break
    if a+b:
        print(f"{n} = {a} + {b}")
    else:
        print("Goldbach's conjecture is wrong.")

브루트포스 알고리즘 문제이다. combinations를 사용해서 모든 조합을 다 확인하는 방식으로 최솟값을 찾았다.

from itertools import combinations

N = int(input())
arr = [list(map(int, input().split(" "))) for _ in range(N)]
coms = [combinations(arr, i) for i in range(1, N+1)]
ans = 1000000000
for com in coms:
    for t in com:
        S, B = 1, 0
        for s, b in t:
            S *= s
            B += b
        ans = min(ans, abs(S-B))
print(ans)

브루트포스 알고리즘 문제이다. 뒤에 글자를 자유롭게 붙일 수 있으므로,

글자를 붙인 만큼 앞에 글자를 고려하지 않고 펠린드롬인지 확인해주면 된다.   

s = input()
for i in range(len(s)):
    t = s[i:]
    if len(t) == 1 or t == t[::-1]:
        print(len(s)+i)
        break

자료 구조 문제인데 그냥 집합을 사용해서 풀었다. 리스트로 풀어도 통과될 것 같다.

import sys

s = set()
for _ in range(int(sys.stdin.readline())):
    name, t = sys.stdin.readline().split()
    if t == "enter":
        s.add(name)
    elif t == "leave":
        s.remove(name)
for a in sorted(s, reverse=True):
    print(a)

기본적인 스택 문제이다.

내가 스택 맨 처음 공부할 때 봤던 것이 후위 표기식 구현 코드였는데 이렇게 문제로 보니 반갑다!

li = list(input())
op = {'(': 0, '+':1, '-': 1, '*': 2, '/': 2, ')': 3}
stack, output = [], []
for c in li:
    if c not in op:
        output.append(c)
    elif c == '(':
        stack.append(c)    
    elif c == ')':
        while stack and stack[-1] != '(':
            output.append(stack.pop())
        stack.pop()
    else:
        while stack and op[stack[-1]] >= op[c]:
            output.append(stack.pop())
        stack.append(c)
while stack:
    output.append(stack.pop())
print(''.join(output))

17298번 오큰수 문제와 거의 동일한 스택 문제이다. 오큰수는 앞에서부터 확인하면서 스택을 쌓아다면

이 문제는 뒤에서 부터 확인하면서 스택을 쌓으면 된다. PyPy3로 제출해야 통과된다.

from collections import deque

N = int(input())
h = deque(map(int, input().split()))
stack = deque()
res = [0]*N
for i in range(N-1, -1, -1):
    while stack and h[stack[-1]] < h[i]:
        res[stack.pop()] = i+1
    stack.append(i)
print(*res)

기본적인 스택 문제이다. 딱 작년만 해도 이 문제를 못 풀었었는데 이제는 쉽게 풀 수 있게 되었다. 굿!! 

from collections import deque

s = input()
stack = deque()
res = 0
for c in s:
    if c == '(':
        stack.append(c)
    else:
        if stack[-1] == '(':
            stack.pop()
            stack.append(1)
        else:
            t = 0
            while stack[-1] != '(':
                t += stack.pop()
            stack.pop()
            stack.append(t)
            res += t+1
print(res)