Jinho Tech

count 함수를 사용하면 원하는 str에 원하는 문자가 몇 개 들어있는지 쉽게 확인할 수 있다.

ans = 0
n, d = map(int, input().split())
for i in range(1, n+1):
    ans += str(i).count(str(d))
print(ans)

단순 구현 문제이다.

li = [] 
for _ in range(6):  
    li.append(int(input())) 
li1 = sorted(li[:4]) 
li2 = li[4:] 
print(sum(li1[1:]) + max(li2))

입력을 10 단위로 슬라이싱 하고 순서대로 출력해주면 된다.

s = input()
for i in range(len(s)//10 + 1):
    print(s[10*i:10*(i+1)])

파이썬 내장함수 sorted는 문자열들이 담긴 리스트를 사전순으로 정렬해준다.

word = input()
l = len(word)
li = []
for i in range(l):
    li.append(word[i:])
li = sorted(li)
for i in range(l):
    print(li[i])

에라토스네테스의 체를 사용해 소수만 찾아 풀 수도 있지만 시간이 넉넉해서 그냥 반복문 하나만 사용해서 풀었다.

EX) n = 72

1) 72 % 2 = 0 -> 2 출력 -> n = 72//2 = 36

2) 36 % 2 = 0 -> 2 출력 -> n = 36//2 = 18

3) 18 % 2 = 0 -> 2 출력 -> n = 18//2 = 9

4) 9 % 3 = 0 -> 3 출력 -> n = 9//3 = 3

5) 3 % 3 = 0 -> 3 출력 -> n = 3//3 = 1 -> n이 1이므로 반복문 종료

n = int(input())
while(n != 1):
    for i in range(2, n+1):
        if n % i == 0:
            print(i)
            n = n //i
            break

lambda를 사용해 나이순으로 리스트를 정렬해주면 된다.

li.sort(key=lambda x : x[0])는 리스트를 첫 번째 값 기준으로 정렬하겠다는 뜻이다.

lambda는 정렬 관련해서 정말 유용하게 사용할 수 있다.

예를 들면 리스트를 길이순으로 정렬하는 기능을 구현하기가 어려운 건 아니지만 조금 귀찮아질 수도 있는데, lambda를 사용하면 li.sort(key=lambda x : len(x)) 한 줄로 구현할 수 있다.

li = []
for _ in range(int(input())):
    age, name = input().split()
    li.append([int(age), name])
li.sort(key=lambda x : x[0])
for i in li:
    print(*i)

우선 각 알파벳의 개수를 저장할 크기가 26이고 요소들이 전부 0이 리스트를 생성한다.

EX) li[0] = a의 개수, li[1] = b의 개수

그 후 li[ord(c)-ord('a')] += 1을 통해 알파벳을 리스트의 인덱스로 바꿔주고 그 인덱스의 리스트 값에 1을 더해준다.

EX) 입력: ac

li = [0, 0, 0, ...0]

-> li[ord('a') - ord('a')] += 1 -> li[0] += 1

-> li[ord('c') - ord('a')] += 1 -> li[2] += 1

-> li = [1, 0, 1, 0, ...]

li = [0]*26
for c in input():
      li[ord(c)-ord('a')] += 1
print(*li)

기본적인 스택 문제이다.

입력이 0이 아니면 스택에 추가하고 입력이 0이면 제일 마지막에 추가한 수를 스택에서 제거한다.

마지막에 스택에 들어있는 수들의 합을 출력해주면 된다.

import sys 

li = []
for _ in range(int(sys.stdin.readline())):
    n = int(sys.stdin.readline())
    if n == 0:
        li.pop()
    else:
        li.append(n)
print(sum(li))

시간 초과 때문에 꽤 많이 틀렸다. 최대한 효율적으로 답을 구해야 한다.

핵심은 x%N == y%N을 만족하는 x, y가 있는지 확인하는 것이다. 

처음에는 이해가 잘 안됬었는데, 생각해보면 x에다 M을 더하면 똑같이 x다. 사실상 x는 고정해두고 y가 조건에 맞는지만 확인하면 된다는 것이다. x를 N으로 나눈 나머지가 y를 N으로 나눈 나머지와 같을 때까지 x에 M을 계속 더해주면 된다.

x%N == y 가 아니라 x%N == y%N인 이유는 x가 N으로 딱 나누어졌을 경우에 나머지가 0이기 때문이다.

x가 M*N보다 커졌는데도 해를 찾지 못했다면 유효하지 못한 표현이므로 -1을 출력한다.

EX) M = 10, N = 12, x = 3, y = 9

1) 3%12 != 9%12

2) 13%12 != 9%12

3) 23%12 != 9%12

4) 33%12 = 9%12 = 9

for _ in range(int(input())):
    M, N, x, y = map(int, input().split())
    f = 1
    while(x <= M*N):
        if x%N == y%N:
            print(x)
            f = 0
            break
        x += M
    if f:
        print(-1)

아스키코드를 사용하면 쉽게 풀 수 있다. 

알파벳의 아스키코드에서 3을 뺀 값이 A의 아스키코드보다 작다면(A, B, C의 경우) 26을 더해주면 된다.

li = list(input())
for i in range(len(li)):
    k = ord(li[i]) - 3
    if k < ord('A'):
        k += 26
    li[i] = chr(k)
print(''.join(li))

조건에 맞게 반복문을 사용해서 출력해주면 되는 노가다 문제이다.

for _ in range(int(input())):
    n = int(input())
    if n < 3:
        for i in range(n):
            print('#'*n)
        print()
    else:
        print('#'*n)
        for i in range(n-2):
            print('#' + 'J'*(n-2) + '#')
        print('#'*n, '\n')

1부터 10000까지 리스트에 추가하고 1부터 10000까지의 수들을 생성자라 생각하고 생성했을 때

나오는 수를 리스트에서 빼주면 된다.

EX) 생성자가 1이라고 했을 때 생성되는 수는 2다. 즉 2는 생성자가 있는 수이므로 리스트에서 제거된다.

li = [i for i in range(1, 10001)]
for i in range(1, 10000):
    s = i
    for j in str(i):
        s += int(j)
    if s in li:
        li.remove(s)
for n in li:
    print(n)

각 테스트마다 평균을 넘는 학생들의 비율을 출력해주면 된다. 

for _ in range(int(input())):
    li = list(map(int, input().split()))
    n = li[0]
    g_li = li[1:]
    average = sum(g_li)/n
    cnt = 0
    for g in g_li:
        if g > average:
            cnt += 1
    print('%.3f' %(cnt/n*100)+ '%')

아래는 numpy array를 사용한 코드이다. 위의 코드보다 성능이 좀 더 좋을 것 같다.

백준에서는 numpy가 import가 안되는지 런타임 에러가 나온다.

import numpy as np
for _ in range(int(input())):
    li = np.array(list(map(int, input().split())))
    ave = sum(li[1:])/li[0]
    print('%.3f' %(len(li[li > ave])/li[0]*100)+ '%')

기약 분수는 분자와 분모에 분자와 분모의 최대공약수를 나누면 만들어진다.

def gcd(a, b):
    while(b != 0):
        n = a%b
        a = b
        b = n
    return a

n = int(input())
li = list(map(int, input().split()))
for i in range(1, n):
    g = gcd(li[0], li[i])
    print('{0}/{1}'.format(li[0]//g, li[i]//g))

간단한 규칙 찾기 문제이다.

N = int(input())
n = N + 2
ans = 1 * n

for i in range(2, N+1):
    ans += i * n
print(ans)