Jinho Tech

단순 수학 문제이다. 각각 비율에 맞게 출력해주면 된다.

import math as m

n, a, b = map(int, input().split())
q = m.sqrt(n**2 / (a**2 + b**2))
print(int(q*a), int(q*b))

완전 수학(특정 규칙을 찾아야 되는?)문제이다.

표를 그려보고 패턴을 찾다보면 이 코드가 이해가 될 것이다.

n = int(input())
i = 1
while(n > 0):
    n -= i
    i += 1
i -= 1
n1 = n+i
n2 = i -n1 + 1
if i % 2 == 1:
    print('{0}/{1}'.format(n2, n1))
else:
    print('{0}/{1}'.format(n1, n2))

우선 입력으로 들어오는 단어들을 리스트에 추가한다. 단 같은 단어가 여러 번 입력된 경우에는 추가 안 함.

 그 후 사전 순으로 정렬하고 lambda를 사용해 단어 길이 순으로 정렬해주면 된다.

li = []
for _ in range(int(input())):
    word = input()
    if word not in li:
        li.append(word)
li.sort()
li.sort(key=lambda x : len(x))
for word in li:
    print(word)

모든 알파벳을 대문자로 바꾼 후에 개수를 새면 쉽다.

word = input().upper()
li = [0]*26
for l in word:
    li[ord(l)-ord('A')] += 1
if li.count(max(li)) > 1:
    print('?')
else:
    print(chr(li.index(max(li))+65))

split을 사용해서 입력을 분리하고 그 길이를 출력하면 된다.

print(len(input().split()))

제일 작은 수부터 시작해서 약수가 3개 이상이 될 때까지 계속 반복문을 돌리면 된다.

li = list(map(int, input().split()))

n = min(li)
while 1:
    cnt = 0
    for i in li:
        if n % i == 0:
            cnt += 1
    if cnt > 2:
        break
    n += 1
print(n)

순서에 맞게 줄을 세워주면 된다.

n = int(input())
li = list(map(int, input().split()))
ans = [0]*n
for i in range(n):
    cnt = 0
    for j in range(n):
        if ans[j] != 0 and i+1 > ans[j]:
            continue
        if cnt == li[i]:
            ans[j] = i+1
            break
        cnt += 1
print(*ans)

10보다 작다면 10을 곱하고 10보다 큰 수라면 앞 자리에 10을 곱하고 뒷 자리 수를 더하면 된다.

이 과정을 원래 숫자가 나올 때가지 반복한다.

n = input()
check = n
cnt = 0
while(True):
    if len(n) == 1:
        n = str(int(n)*10 + int(n))
    else:
        n = str(int(n[1])*10 + int(str(int(n[0])+int(n[1]))[-1]))
    cnt += 1
    if n == check:
        break
print(cnt)

단순 구현 문제이다. 그냥 반복문 두번 써서 틀린 경우를 확인해주면 된다.

ans = 0
for i in range(8):
    li = list(input())    
    for j in range(8):
        if (i % 2) and (j % 2) and li[j] == 'F':
            ans += 1
        elif (i % 2 == 0) and (j % 2 == 0) and li[j] == 'F':
            ans += 1
print(ans)

단순 수학 문제이다. 반복문 안에서 64를 계속 나누면서 저장하지 않고 그냥 리스트를 사용해서 풀었다.

EX) n = 23

64 X -> 32 X -> 16 -> OK

8  X ->  4 -> OK,

2 -> OK

1 -> OK

16 + 4 + 2 + 1 = 23으로 총 4개의 막대기를 사용한다.

n = int(input())
li = [64,32,16,8,4,2,1]
ans = 0

for i in li:
    while n-i >= 0:
        n -= i
        ans += 1
print(ans)

x, y, w-x, h-y 중 제일 작은 값을 선택하면 된다.

x, y, w, h = map(int, input().split())
print(min(w-x, h-y, x, y))

본인이 전자공학과라 그런지 조금 반가웠다. 

그냥 사전을 하나 만들어 놓고 사용했다. 처음 2개는 str으로 합치고 마지막에 int로 바꿔서 곱해주면 된다.

dic = {'black': [0,1], 'brown': [1,10], 'red': [2,100], 'orange': [3,1000], 'yellow': [4,10000],
     'green': [5,100000], 'blue': [6,1000000], 'violet': [7,10000000], 'grey': [8,100000000],
     'white': [9,1000000000]}
li = []

for i in range(3):
    li.append(input())
print(int(str(dic[li[0]][0]) + str(dic[li[1]][0])) * dic[li[2]][1])

N의 마지막 두 자리를 0으로 바꾸고 F로 나눠질 때까지 N에 1을 더하는 방식으로 풀었다.

N, F = list(input()), int(input())
N[-2:] = ['0']*2
N = int(''.join(N))
while N % F != 0:
    N += 1
    
print(str(N)[-2:])

완전 수학 문제다. 패턴을 파악하면 되는데 말로 설명하기 조금 번거롭다.

t를 구할 때 R에는 2를 곱하고 C는 그냥 더하는 이유를 생각해보면 풀이가 떠오를 것이라고 생각한다.

이해가 안 된다면 R, C, t, r, c, carry, n을 계속 계산해보면 코드가 이해가 잘 될 것이다.

N, r, c = map(int, input().split())
n = 4 ** N
ans = 0
for i in range(N):
    R = r//(2**(N-1))
    C = c//(2**(N-1))
    t = 2*R + C
    r -= 2**(N-1) * R
    c -= 2**(N-1) * C

    carry = 4 ** (N-1) * t
    n //= 4
    N -= 1
    ans += carry
print(ans)

2자리 이하의 수는 전부 한수이므로 입력 그대로 출력해주면 된다.

3자리 이상의 수부터는 100부터 끝까지 한수가 몇 개 있는지 확인하고 마지막에 99를 더해주면 된다. 

n = int(input())
if n < 100:
    print(n)
else:
    cnt = 0
    for i in range(100, n+1):
        st = str(i)
        d = int(st[0]) - int(st[1])
        ok = 1
        for j in range(1, len(st)-1):
            if int(st[j]) - int(st[j+1]) != d:
                ok = 0
                break
        if ok:
            cnt += 1
    print(cnt+99)