Jinho Tech

n = int(input())
for i in range(n, 0, -1):
    print('*'*i)

파이썬은 str도 곱할 수 있다.

n = int(input())
for i in range(1, n+1):
    print(" " * (n-i) + "*" * i)

반복문을 처음 공부할 때 나오는 별 찍기 문제이다.

다른 언어의 경우에는 별 찍기 문제의 난이도가 올라가면 많이 귀찮아질 수도 있는데

파이썬은 비교적 엄청 간단하게 구현할 수 있다.

for i in range (1, int(input())+1):
    print ("*"*i)

조합의 개수를 구하는 문제이다.

nCm에서 m*2가 n보다 큰 경우에는 nCn-m으로 바꿔줘서 계산을 줄여줘야 한다.

n, m = map(int, input().split())

if m*2 > n:
    m = n-m
a = 1
for i in range(m):
    a *= max(1, (n-i))
b = 1
for i in range(1, m+1):
    b *= i
print(a//b)

아래 같은 방식으로 노가다로 풀 수도 있지만 수학으로 쉽게 풀 수 있는 문제다.

a, b = map(int, input().split())
a, b = min(a, b), max(a, b)

def f(n):
    return (n*(n+1))//2

if a == b:
    print(a)
elif a <= 0 and b >= 0:
    print(f(b) - f(-a))
elif b <= 0:
    print(-(f(-a) - f(-b-1)))
else:
    print(f(b) - f(a-1))

수학이 참 좋은게 코드가 저렇게 짧아진다.

a, b = map(int, input().split())
a, b = min(a, b), max(a, b)
n = b - a
ans = ((n+1)*(n+2*a)) // 2

print(ans)

간단한 수학 문제이다.

처음에는 1 다음에는 6 그다음에는 12, 18, 24... 마다 층이 늘어난다는 점을 파악하면 쉽게 풀 수 있다.

EX) 13

13 - 1 = 12 -> 12 - 6 = 6 -> 6 - 12 = -6 -> 반복문 끝 -> 3 출력

n = int(input())
i = 1
while(n>1):
    n -= 6*i
    i += 1
print(i)

sum(map(int, list(str(i))))을 사용해 각 숫자들의 합을 구했다.

이 문제는 반복문에 따라 성능이 엄청 달라진다. 

1 ~ N 반복문 -> 1672ms

N//2 ~ N 반복문 -> 868ms

N - 9*len(str(N)[1:]) ~ N 반복문 -> 60ms

거의 27.8배 정도 성능이 향상되었다.

N = int(input())
ans = 0

for i in range(N-9*len(str(N)[1:]), N):
    s = i + sum(map(int, list(str(i))))
    if s == N:
        ans = i
        break

print(ans)

k개의 로프를 사용할 때 들어 올릴 수 있는 중량은

버틸 수 있는 중량이 제일 작은 로프의 최대 중량 * k라는 점이 핵심이다. 

EX) 15, 10 로프 2개를 사용할 경우

최대 10 * 2 = 20인데 이유는 15가 10보다 큰 중량을 버틸 수 있더라도 로프에 걸리는 중량은 똑같기 때문에 10을 기준으로 최대 중량이 정해지기 때문이다.

N = int(input())
li = sorted([int(input()) for _ in range(N)], reverse=True)
ans = 0
for i in range(N):
    ans = max(ans, li[i]*(i+1))
print(ans)

단순한 수학 문제이다. 

N*M 크기의 초콜릿이 있다고 하자.

처음에 행(N) 기준으로 자르면 (N-1)번 자르게 되고 (1*M) 크기의 초콜릿들이 N개 생긴다.

(1*M) 크기의 초콜릿은 열(M) 기준으로 자르면 (M-1)번 자르게 되는데 N개 있으므로 N번 반복해야 한다.

위의 과정을 정리하면 (N*M) 크기의 초콜릿은 총 (N-1) + (M-1)*N = N - 1 + M*N -N = M*N - 1번 자르게 된다.

N, M = map(int, input().split())
print(N*M-1)

통계를 복습해볼수 있는 쉬운 문제지만 sys를 통해 입력을 빠르게 받지 않으면 시간초과가 뜬다. 

# 시간초과 때문에 정답률이 낮은 것 같다.

1. 산술평균 : N개의 수들의 합을 N으로 나눈 값
2. 중앙값 : N개의 수들을 증가하는 순서로 나열했을 경우 그 중앙에 위치하는 값
3. 최빈값 : N개의 수들 중 가장 많이 나타나는 값
4. 범위 : N개의 수들 중 최댓값과 최솟값의 차이

from collections import Counter
import sys

li = []
for _ in range(int(input())):
    li.append(int(sys.stdin.readline()))
li.sort()
ave = round(sum(li)/len(li)) # 산술평균
if len(li) % 2 == 1:
    median = li[len(li)//2]
else:
    median = round((li[len(li)//2-1] + li[len(li)//2])/2) # 중앙값
cnt = Counter(li)
cnt_sort = cnt.most_common()
max_cnt = cnt_sort[0][1]
max_cnt_li = []
for c in cnt_sort:
    if c[1] == max_cnt:
        max_cnt_li.append(c[0])
if len(max_cnt_li) > 1:
    mode = max_cnt_li[1] 
else:
    mode = max_cnt_li[0] # 최빈값
li_range = max(li)-min(li) # 범위
print(ave)
print(median)
print(mode)
print(li_range)

if X % 3 == 0: 
    X //= 3 
elif x % 2 == 0: 
    X //= 2 
else: 
    X -= 1~~~~

단순하게 위와 같은 방식으로 풀면 틀린다. 예를 들어 10 같은 경우 10 -> 5 -> 4 -> 2 -> 1 보다 빠른 

10 -> 9 -> 3 -> 1이 있기 때문이다.

2 또는 3으로 나누어 떨어지는 수더라도 그 수에 1을 빼준 값도 같이 다음 단계로 넘겨주는 식으로 해결했다.

X = int(input())
cnt = 0
li = [X]

while(1 not in li):
    t = []
    for x in li:
        if x % 3 == 0:
            t.append(x//3)
        elif x % 2 == 0:
            t.append(x//2)
        t.append(x-1)
    li = t
    cnt += 1
print(cnt)

길이가 1인 수는 9개 있고. (1, 2, 3... 9) 길이가 2인 수는 90개 있고, 길이가 3인 수는 900개가 있다. 

길이가 n인 수는 총 9 * 10**(n-1) + 9개 있다는 점을 감안해서 풀면 쉽다.

N = int(input())
n = 9
a = 1
ans = 0

while(N != 0):
    if N - n > 0:
        ans += a*n
        N -= n
        n = n*10
        a += 1
    else:
        ans += a*N
        break
    
print(ans)

입력을 그냥 받으면 시간 초과가 걸린다. sys를 통해 빠르게 입력을 받아주자.

import sys

n = int(input())
s = 0
for _ in range(n):
    s += int(sys.stdin.readline())
print(s-n+1)

소수 관련 문제는 아리토스테네스의 체 방식을 사용하면 효율적으로 풀 수 있다. 

종종 보게 될 알고리즘이니 기억해두면 좋을 것 같다.

n = int(input())
li = list(map(int, input().split()))
t_li = [1]*(max(li)+1)
for i in range(2, max(li)//2 + 1):
    if t_li[i] == 1:
        for j in range(i+i, max(li)+1, i):
            t_li[j] = 0
prime = []
for i in range(2, len(t_li)):
    if t_li[i] == 1:
        prime.append(i)
cnt = 0
for n in li:
    if n in prime:
        cnt += 1
print(cnt)

math.sqrt를 통해 제곱근을 구할 때 완접제곱수라면 결괏값의 맨 끝은 항상 0이 나오는데

이 점을 활용해서 문제를 풀었다.

EX) math.sqrt(4) = 2.0

import math

li = []
for i in range(int(input()), int(input())+1):
    if str(math.sqrt(i))[-1] == '0':
        li.append(i)
if len(li) > 0:
    print(sum(li))
    print(li[0])
else:
    print(-1)