Jinho Tech

우선 False가 100개 달려있는 리스트를 생성한다. 

그 후 앉고 싶어 하는 자리가 False인 경우에는 True로 바꿔주고 앉고 싶어 하는 자리가 True라면 거절당한 상황이므로

cnt를 올려주면 된다.

N = int(input())
li = [False] * 100
p = list(map(int, input().split()))
cnt = 0

for n in p:
    if li[n-1] == False:
        li[n-1] = True
    else:
        cnt += 1
        
print(cnt)

기본적으로 파일의 개수가 N개면 클러스터가 N개가 필요하다.

허나 파일의 크기가 0인 경우는 클러스터가 필요하지 않으므로 -1

파일의 크기가 클러스터의 크기보다 클 경우에는 파일의 크기에 클러스터의 크기를 나눈 몫 만큼 더해줘야 한다.

EX) 파일의 크기: [1200, 0], 클러스터의 크기: 512

cnt = 2(파일의 개수) 

-> cnt = cnt + (1200-1) // 512 - 1 = cnt + 2 - 1 = cnt + 1 = 3(결과값)

N = int(input())
li = list(map(int, input().split()))
S = int(input())
cnt = N

for s in li:
    if s > S:
        cnt += (s-1)//S
    elif s == 0:
        cnt -= 1
print(S*cnt)

아래는 처음 풀이 코드이다. 정답이긴 하지만 코드가 쓸데없이 길어서 짜면서 답답함을 느꼈다.

def easy(n):
    s = 0
    num, cnt = 1, 1
    while(1):
        for _ in range(num):
            if cnt == n+1:
                break
            s += num
            cnt += 1
        num += 1
        if cnt == n+1:
            break
    return s

A, B = map(int, input().split())
print(easy(B) - easy(A-1))

아래는 최종 풀이 코드이다.

위의 과정을 리스트의 합을 사용해 간단하게 구현했다.

A, B = map(int, input().split())
li = []
for i in range(1, 46):
    li += [i]*i
print(sum(li[A-1:B]))

그냥 말 그대로 "문제의 정답"을 출력하면 되는 문제다. 

백준씨는 어쩌다 이런 문제를 올렸을까...

print("문제의 정답")

A, B 리스트를 받을 때 각각 오름차순, 내림차순으로 정렬한 후 각 요소들의 곱의 합을 구하면 된다.

EX) A = [1,1,1,6,0], B = [2,7,8,3,1] 

A 오름차순 정렬 -> [0,1,1,1,6]

B 내림차순 정렬 -> [8,7,3,2,1]

곱의 합 = 0*8 + 1*7 + 1*3 + 1*2 + 6*1 = 0 + 7 + 3 + 2 + 6 = 18

n = int(input())
A = sorted(list(map(int, input().split())), reverse=True)
B = sorted(list(map(int, input().split())))
S = 0

for i in range(n):
    S += A[i]*B[i]
print(S)

에라토스테네스의 체 문제이다. 소수를 찾는 방법 중에서 이 방법은 상당히 빠른 편인 것 같다.

n1, n2= map(int, input().split())
li = [1]*(n2+1)
for i in range(2, int((n2+1)**0.5) + 1):
    if li[i] == 1:
        for j in range(i+i, n2+1, i):
            li[j] = 0
for i in range(n1, n2+1):
    if li[i] == 1 and i > 1:
        print(i)

EX) 12월 25일 

s = sum(li[:11]) + 25 = 334 + 25 = 359

d[359%7] = d[2] = 'TUE'

li = [31,28,31,30,31,30,31,31,30,31,30]
x, y = map(int, input().split())
d = ['SUN','MON','TUE','WED','THU','FRI','SAT']
s = sum(li[:x-1]) + y
print(d[s%7])

두 단어의 알파벳 개수들의 차이의 합을 구하면 된다.

s1 = input()
s2 = input()
ans = 0
a, b = [0]*26, [0]*26

for i in range(len(s1)):
    a[ord(s1[i])-97] += 1
for i in range(len(s2)):
    b[ord(s2[i])-97] += 1
for i in range(26):
    ans += abs(a[i]-b[i])
print(ans)

단순 구현 문제이다. 그냥 조건에 맞게 반복문을 돌려주자.

N = int(input())
w = int(input())
li = [[0 for i in range(N)] for j in range(N)]
n = 1
    
x = y = N // 2
check = 2 
li[x][y] = n
i = 0
j = 0
while li[0][0] != N**2:
    x -= 1
    for i in range(check):
        n += 1
        li[x][y+i] = n
        if n == w:
            ans = [x+1, y+i+1]
    y += i
    for i in range(1, check+1):
        n += 1
        li[x+i][y] = n
        if n == w:
            ans = [x+i+1, y+1]
    x += i
    for i in range(1, check+1):
        n += 1
        li[x][y-i] = n
        if n == w:
            ans = [x+1, y-i+1]
    y -= i
    for i in range(1, check+1):
        n += 1
        li[x-i][y] = n
        if n == w:
            ans = [x-i+1, y+1]
    x -= i
    check += 2

for i in range(N):
    for j in range(N):
        print(li[i][j], end = ' ')
    print()
print(*ans)

기본적인 다이나믹 프로그래밍 문제이다.

n = int(input())
li = list(map(int, input().split()))
for i in range(1, n):
    li[i] = max(li[i], li[i]+li[i-1])
print(max(li))

기본적인 다이나믹 프로그래밍 문제이다.

N = 1 -> 1개, N = 2 -> 2개, N = 3 -> 3개, N = 4 -> 5개, N = 5 -> 8개...

규칙을 보면 1, 2, 3, 5, 8, 13 ...인데 피보나치 수열이다.

a, b = 1, 1
for i in range(int(input())):
    a, b = b%15746, (a+b)%15746
print(a)

스택 문제이다.

처음에 문제를 이해를 못해서 시간이 많이 걸렸다.

import sys

n = int(sys.stdin.readline())
li = []
stack = []
result = []
index = 0
for i in range(n):
    li.append(int(sys.stdin.readline()))

for i in range(1, n + 1):
    stack.append(i)
    result.append('+')
    while len(stack) > 0 and index < n and stack[-1] == li[index]:
        index += 1
        stack.pop(-1)
        result.append('-')

if len(stack) == 0:
    for op in result:
        print(op)
else:
    print('NO')

입력이 n이라고 하자. n보다 작은 수는 몫이 0이지만 나머지는 0일 수가 없기 때문에 제외하고,

n의 제곱보다 큰 수는 몫이 n 보다 커져서 나머지와 같을 수가 없기 때문에 제외한다.

남은 범위에서 나머지와 몫이 같은 수를 찾으면 된다.

EX) n = 3 -> 1, 2, 3은 몫은 0이지만 나머지가 0보다 크기 때문에 같을 수가 없고,

10, 11, 12...는 몫은 3보다 큰데 나머지는 3보다 클 수가 없다.

결과적으로 4(3+1) ~ 9(3**2)의 범위에서 나머지와 몫이 같은 수를 찾아주면 된다.

n = int(input())
s = 0
for i in range(n+1, n**2, n+1):
    s += i
print(s)

그냥 수학 문제이다.

간단한 조건에서 연립방정식을 세우고 첫 번째 값을 찾다 보면 아래의 방식이 이해가 될 것이다.

n = int(input())
s = 0
li = []
for i in range(n):
    li.append(int(input()))  
    s += li[i] * (-1)**i
a = s // 2

print(a)
for i in range(n-1):
    a = li[i] - a
    print(a)

단순한 방식

입력보다 커지기 전까지 1, 2, 3, 4, 5... 를 계속 더하다가 마지막으로 더해진 값을 출력해주면 된다.

1부터 n까지 수의 합 = n * (n+1) // 2

n = int(input())
i = 1
while i * (i+1) // 2 <= n:
    i += 1
print(i-1)

이분 탐색

마찬가지로 1부터 n까지 수의 합 = n * (n+1) // 2 인 점을 이용하면 쉽게 해결할 수 있다.

n = int(input())
s, e = 1, n
while s <= e:
    m = (s + e) // 2
    print(s, e, m)
    if m * (m+1) // 2 > n:
        e = m - 1
    else:
        ans = m
        s = m + 1
print(ans)