Jinho Tech

단순 구현 문제이다. Python3로 제출했더니 시간 초과가 나와서 PyPy3로 제출했다.

이게 처음에 헷갈릴 수도 있는 게 i=1, j=2, x=2, y=3이라고 했을 때

(1,2), (1,3), (2,1), (2,2), (2,3)의 합을 구하는 게 아니라 (1, 2), (1, 3), (2,2), (2,3)의 합을 구해야 된다.

N, M = map(int, input().split())
li = [list(map(int, input().split())) for _ in range(N)]
for _ in range(int(input())):
    i, j, x, y = map(int, input().split())
    n, m = i, j
    res = 0
    while 1:
        if m > y:
            n += 1
            m = j
        res += li[n-1][m-1]
        if n == x and m == y:
            break
        m += 1
    print(res)

단순 구현 문제이다. 처음엔 숫자들의 합을 구할 때 sum을 사용했는데 -> t = sum(li[i:j+1])

시간 초과가 나왔다. sum을 사용하지 않고 그냥 하나씩 더하면서 합을 구했더니 통과되었다.

Python3로 제출하면 시간 초과가 나와서 PyPy3로 제출했다.  

N, M = map(int, input().split())
li = list(map(int, input().split()))
cnt = 0
for i in range(N):
    t = 0
    for j in range(i, N):
        t += li[j]
        if t > M:
            break
        elif t == M:
            cnt += 1
print(cnt)

단순 수학 문제이다. 최대공약수를 구해주는 재귀 함수는 기억해두는 것이 좋을 것 같다. 

def gcd(a, b):
    if b == 0:
        return a
    a, b = b, a%b 
    return gcd(a, b)

n1, d1 = map(int, input().split())
n2, d2 = map(int, input().split())
n = n1*d2 + d1*n2
d = d1*d2
g = gcd(max(n,d), min(n,d))
print(n//g, d//g)

단순 수학 문제이다.

위의 조건을 만족해야 되는데, 수학적으로 확실한 증명은 못하지만

내 생각엔 곱이 최대가 되는 정수의 조합은 [S//K] * K에 각 요소 S%k개에다 1을 더한 것이다.

실제로 이런 식으로 구현하니 통과됐다!

EX) S = 10, K = 3 -> [S//K]*3 = [3]*3 = [3, 3, 3]

S%K = 1 -> [3+1, 3, 3] -> 4*3*3 = 36

아래는 이해를 돕기 위해 풀어쓴 코드이다.

s, k = map(int, input().split())
li = [s//k for _ in range(k)]
for i in range(s%k):
    li[i] += 1
res = 1
for n in li:
    res *= n
print(res)

그냥 짧게 짠 코드

s, k = map(int, input().split())
print((s//k)**(k-s%k) * (s//k+1)**(s%k))

재밌는 정렬 문제이다.

입력받을 때 리스트에 [문자열의 길이, 숫자의 합, 문자열]와 같은 방식으로 저장해주면 

lambda를 사용해서 매우 쉽게 정렬해줄 수 있다. 

def num(s):
    res = 0
    for c in s:
        if '0' <= c <= '9':
            res += int(c)
    return res

N = int(input())
li = []
for _ in range(N):
    s = input()
    li.append([len(s), num(s) , s])
li.sort(key=lambda x:x[2])
li.sort(key=lambda x:x[1])
li.sort(key=lambda x:x[0])
for t in li:
    print(t[-1])

좀 더 깔끔하게 짠 코드

def num(s):
    return sum([int(c) for c in s if '0' <= c <= '9'])

N = int(input())
li = []
for _ in range(N):
    s = input()
    li.append([len(s), num(s) , s])
li.sort(key=lambda x:(x[0], x[1], x[2]))
for t in li:
    print(t[-1])

단순 문자열 문제이다. 

for _ in range(int(input())):
    li = input().split()
    for s in li:
        print(s[::-1], end=' ')
    print()

단순 문자열 정렬이다. 

while 1:
    s = input()
    if s == "END":
        break
    print(s[::-1])

단순 문자열 문제이다.

s = input()
res = ''
for c in s:
    if 'a' <= c <= 'z':
        res += chr((ord(c)+13) if c <= 'm' else ord(c)-13)
    elif 'A' <= c <= 'Z':
        res += chr((ord(c)+13) if c <= 'M' else ord(c)-13)
    else:
        res += c
print(res)

단순 문자열 문제이다. 

lambda를 사용해서 5개의 문자열 중 제일 긴 문자열의 길이를 찾아봤다.

li = [input() for _ in range(5)]
i = 0
max_len = max(map(lambda x:len(x), li))
while i < max_len:
    for j in range(5):
        if i+1 > len(li[j]):
            continue
        print(li[j][i], end='')
    i += 1
print()

단순 정렬 문제이다. stdin.readline으로 입력을 받아야 된다. 아니면 시간 초과가 나온다.

import sys

N = int(input())
li = [int(sys.stdin.readline()) for _ in range(N)]
for n in sorted(li):
    print(n)

단순 수학 문제이다.

while 1:
    t = list(map(int, input().split()))
    if t == [0]:
        break
    for i in range(t[0]//4):
        li = [2*i+1, 2*i+2, t[0]-2*i-1, t[0]-2*i]
        if t[1] in li:
            li.remove(t[1])
            print(*li)

단순 사칙연산 문제이다.

for case in range(int(input())):
    li = sorted(map(int, input().split()))
    print(f"Case #{case+1}: ", end='')
    if li[0]+li[1] <= li[2]:
        print("invalid!")
    elif li[0] == li[1] == li[2]:
        print("equilateral")
    elif li[0]==li[1] or li[1]==li[2] or li[2]==li[0]:
        print("isosceles")
    else:
        print("scalene")

단순 구현 문제이다.

for _ in range(int(input())):
    li1 = list(map(float, input().split()))
    li2 = list(map(float, input().split()))
    a = li1[0]*li2[1] + li1[1]*li2[2] + li1[2]*li2[0]
    g = li2[0]*li1[1] + li2[1]*li1[2] + li2[2]*li1[0]
    if a == g:
        print('=')
    elif a > g:
        print("ADAM")
    else:
        print("GOSIA")

단순 정렬 문제인 줄 알고 sorted를 사용했는데 바로 메모리 초과가 나왔다.

입력으로 들어온 숫자를 카운트한 후에 제일 작은 수부터 순서대로 그 개수만큼 출력해주면 되는데,

문제 조건을 보면 1부터 10000까지의 수가 들어와서 그거에 맞게 리스트를 할당해줘야 한다.

10000보다 크게 잡으면 메모리 초과가 나올 수도 있으니 주의하자!  

from sys import stdin

N = int(stdin.readline())
li = [0]*10000
for _ in range(N):
    li[int(stdin.readline())-1] += 1
for i in range(10000):
    for j in range(li[i]):
        print(i+1)

구현 문제이다.

0 ~ i-1번째 사람들 중에서 i번째 사람보다 키가 큰 사람들 중 제일 작은 사람의 위치를 찾아야 한다.

for j in range(i):
	if li[j] > li[i] and li[j] < m:

이 두 줄이 핵심인 것 같다.

for _ in range(int(input())):
    a = list(map(int, input().split()))
    case, li = a[0], a[1:]
    res = 0
    for i in range(1, 20):
        m, m_idx = max(li)+1, i
        for j in range(i):
            if li[j] > li[i] and li[j] < m:
                m = li[j]
                m_idx = j
        if m_idx != i:
            li = li[:m_idx] + [li[i]] + li[m_idx:i] + li[i+1:]
            res += i-m_idx
    print(case, res)