<kimNerd />

풀이 (시간 초과)

# 입력: 첫째 줄 - N, M, 둘째 줄 - 수열 나열
# 출력: 합이 M이 되는 경우의 수 출력

n, m = map(int, input().split())        
list_n = list(map(int, input().split()))
a = 0

for i in range(n):
    for j in range(i+1, n+1):
        if sum(list_n[i:j]) == m:
            a += 1

print(a)

다른 사람 풀이

# 연속적인 부분 수열의 합이 m과 같은 경우 출력
# 포인터 각각 할당 lt, rt

n, m = map(int, input().split())
a = list(map(int, input().split()))
lt = 0                              # 포인터 lt 할당
rt = 1                              # 포인터 rt 할당
tot = a[0]                          # tot 초기값: a[0]
cnt = 0                             # 개수 세기 위한 cnt 할당

while True:                         # break 되기 전까지 반복
    if tot < m:                     # 합이 m보다 작을 경우
        if rt < n:                  # rt가 n보다 작을 경우
            tot += a[rt]            # tot에 a[rt] 값 더해줌
            rt += 1                 # rt 포인터 1만큼 증가
        else:                       # rt가 n보다 크거나 같으면
            break                   # 반복문 종료

    elif tot == m:                  # 만약 합이 m과 같으면
        cnt += 1                    # cnt 1 증가
        tot -= a[lt]                # tot에서 a[lt] 값 빼줌
        lt += 1                     # lt 1 증가

    else:                           # 만약 합이 m보다 크면
        tot -= a[lt]                # cnt 증가 없이 a[lt] 값 빼줌
        lt += 1                     # lt 1 증가

print(cnt)                          # cnt 출력

풀이

# 입력: N, N개의 리스트 원소, M, M개의 리스트 원소
# 출력: 오름차순으로 정렬된 리스트 출력

n = int(input())                            # 정수 n 할당
list_n = list(map(int, input().split()))    # 리스트 list_n 입력 및 할당
m = int(input())                            # 정수 m 할당
list_m = list(map(int, input().split()))    # 리스트 list_m 입력 및 할당

sum = [*list_n, *list_m]                    # 두 리스트 언패킹하여 다시 리스트로 묶어줌
sum = sorted(sum)                           # sorted()를 통해 오름차순 정렬
print(*sum, sep = ' ')                      # 언패킹하여 공백 하나 기준으로 값들 출력

다른 사람 풀이

# sort() 함수는 시간복잡도가 nlogn
# 이를 n으로 줄이는 방법

n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))

p1 = p2 = 0
c = []
while p1 < n and p2 < m:
    if a[p1] <= b[p2]:
        c.append(a[p1])
        p1 += 1
    else:
        c.append(b[p2])
        p2 += 1

if p1 < n:
    c = c + a[p1:]
if p2 < m:
    c = c + b[p2:]

for x in c:
    print(x, end = ' ')

풀이

# 입력: 10개의 줄에 걸쳐, 한 줄에 하나씩 10개의 구간 ai, bi
# 출력: 마지막 카드들의 배치를 한 줄에 출력

# 예를 들어, 5부터 10까지 슬라이싱해서 역순으로 만들려면
# card[10-1:5-2:-1]
# 첫 번째는 포함하기 때문에 인덱스의 -1 차만 빼면 됨
# 두 번째는 포함하지 않기 때문에 인덱스의 -1 차와 -1을 추가로 빼줘야 함

# 그리고 추가로 그 앞 뒤에 있는 인덱스는 그대로 가지고 가면 될 것 같음
# 그렇게 해서 다시 리스트 세 개를 합쳐주면 될 것 같음


card = '1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20'.split()

i = 0

while i < 10:
    i += 1
    a, b = map(int, input().split())
    if a >= 2: # a가 2보다 크거나 같을 때,
        tmp = [card[:a-1], card[b-1:a-2:-1], card[b:]] # 임시 리스트에 바뀐 순서대로 저장
        card = sum(tmp, []) # 초기값을 []로 줘서, 리스트끼리 더하기가 가능하게 함
    else: # a가 1일 때,
        tmp = [card[b-1::-1], card[b:]]
        card = sum(tmp, [])
else:
    print(*card, sep = ' ') # 리스트 압축 풀고, 공백으로 구분해서 출력

다른 사람 풀이

a = list(range(21)) # 자동으로 0부터 20까지 리스트가 생김
for _ in range(10): # i 대신 _를 적게 되면 변수 없이 범위만큼 반복하게 됨
    s, e = map(int, input().split())
    for i in range((e-s+1)//2):
        a[s+i], a[e-i] = a[e-i], a[s+i]

a.pop(0)

for x in a:
    print(x, end = ' ')

풀이

# 입력: 문자열 주어짐
# 출력: 첫째 줄 - 자연수 출력; 둘째 줄 - 약수의 개수 출력

from math import sqrt

numbers = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0']

w = input()                # 문자열 w 입력 및 할당
w = list(w)                # 문자열 리스트로 변환
a = []                     # 숫자만 담을 빈 리스트 a 할당

for i in w:                # 리스트 w의 각 요소 반복
    if i in numbers:       # i가 numbers 안의 요소에 해당한다면
        a.append(i)        # 이를 a에 추가

a = int(''.join(a))        # join()을 통해 각 요소를 묶어 정수형으로 변환

cnt = 0                    # 개수 세기 위한 cnt 할당

for i in range(1, a + 1):  # a만큼 반복
    if a % i == 0:         # a가 i로 나눠진다면 = 약수
        cnt += 1           # cnt 1 추가

print(a)                   # a 출력
print(cnt)                 # 약수의 개수 cnt 출력

다른 사람 풀이

s = input()
res = 0
for x in s:
    if x.isdecimal():
        res = res * 10 + int(x)
print(res)
cnt = 0
for i in range(1, res + 1):
    if res % i == 0:
        cnt += 1
print(cnt)

풀이

# 입력 : 첫째 줄 - 단어 갯수 n
# 입력 : 둘째 줄부터 n개의 단어
# 출력 : 회문문자열이면 YES, 아니면 NO

n = int(input())                            # 정수 n 입력 및 할당

for j in range(n):                          # n만큼 반복
    w = input().lower()                     # 입력 받은 값 lower()로 모두 소문자로 바꿈
    w = list(w)                             # 입력 받은 문자열 리스트로 변환
    cnt = 0                                 # 개수 세기 위한 cnt 할당

    if len(w) % 2 == 0:                     # 만약 입력한 문자 길이가 짝수면
        for i in range(int(len(w)/2)):      # w 길이의 절반만큼 반복
            if w[i] == w[len(w)-1-i]:       # 만약 앞 글자와 끝 글자가 같다면
                cnt += 1                    # 갯수 1개 추가
    else:                                   # 만약 입력한 문자 길이가 홀수면
        for i in range(int(len(w)/2-0.5)):  # w 길이 - 0.5만큼 반복
            if w[i] == w[len(w)-1-i]:       # 만약 앞 글자와 끝 글자가 같다면
                cnt += 1                    # 갯수 1개 추가

    if len(w) % 2 == 0:                     # 만약 짝수면
        if cnt == len(w) / 2:               # cnt가 문자 길이 절반과 같다면
            print(f'#{j+1} YES')            # YES 출력
        else:                               # 아니면
            print(f'#{j+1} NO')             # NO 출력
    else:                                   # 만약 홀수면
        if cnt == len(w) / 2 - 0.5:         # cnt가 문자 길이 절반 - 0.5와 같다면
            print(f'#{j+1} YES')            # YES 출력
        else:                               # 아니면
            print(f'#{j+1} NO')             # NO 출력

다른 사람 풀이 (1)

# 회문문자열

# s[j] == s[-1-j] 로 접근할 수 있음

n = int(input())
for i in range(n):
    s = input()
    s = s.upper() # 문자를 대문자화
    size = len(s) # s의 길이
    for j in range(size//2):
        if s[j] != s [-1-j]:
            print('#%d NO' % (i+1))
            break
    else:
        print('#%d YES' % (i+1))

다른 사람 풀이 (2)

# 회문문자열 짧은 풀이

n = int(input())
for i in range(n):
    s = input()
    s = s.upper()
    if s == s[::-1]:
        print('#%d YES' % (i + 1))
    else:
        print('#%d NO' % (i + 1))

풀이

# 입력 : 첫째 줄 - 문제 갯수, n
# 입력 : 둘째 줄 - 문제 갯수에 해당하는 채점 결과 0 / 1
# 출력 : 가산점 고려한 총 점수 출력

n = int(input())                        # 정수 n 할당
t = list(map(int, input().split()))     # t에 각 채점 결과 리스트로 할당
a = 0                                   # 누적될 때 가산점을 담을 정수 a 할당; 초기값: 0
d = 0                                   # 총 점수를 담을 정수 d 할당; 초기값: 0

for i in t:                             # t 요소 반복
    if i == 1:                          # i가 1이면
        d += (1 + a)                    # d에 1 + a만큼 추가 (처음에는 a가 0이니 1만큼 추가됨)
        a += 1                          # a에 1 추가
    else:                               # i가 1이 아니면
        a = 0                           # a는 0으로 초기화

print(d)                                # d 출력

다른 사람 풀이

# 점수 계산

n = int(input())
a = list(map(int, input().split()))

sum = 0
cnt = 0
for x in a: # a에 있는 값들 마다
    if x == 1: # 만약 x가 1이라면
        cnt += 1 # 가산점 1점 추가
        sum += cnt # 가산점이 곧 점수에 추가
    else: # 그렇지 않다면
        cnt = 0 # 가산점은 0으로 초기화

print(sum)

풀이

# 입력 : 첫째 줄 - 참여하는 사람 수 n = test case 갯수
# 입력 : 다음 줄 - n개의 줄에 사람들이 던진 주사위 3개의 눈
# 출력 : 가장 많은 상금을 받은 사람의 상금을 출력

n = int(input())                            # 정수 n 할당
m = []                                      # 빈 리스트 m 할당

for i in range(n):                          # n만큼 반복
    d = list(map(int, input().split()))     # d에 각 눈 입력하여 할당
    if d.count(d[0]) == 3:                  # d[0]의 갯수가 3이면 = 모든 눈이 같으면
        m.append(int(10000 + d[0] * 1000))  # 규칙 1로 계산한 상금 m에 추가
    elif d.count(d[0]) == 2:                # d[0]의 갯수가 2이면 = 첫번째 눈과 두번째 혹은 세번째 눈이 같으면
        m.append(int(1000 + d[0] * 100))    # 규칙 2로 계산한 상금 m에 추가
    elif d.count(d[1]) == 2:                # d[1]의 갯수가 2이면 = 두번째 눈과 세번째 눈이 같으면
        m.append(int(1000 + d[1] * 100))    # 규칙 2로 계산한 상금 m에 추가
    else:                                   # 세 주사위의 눈이 모두 다르면
        m.append(int(max(d) * 100))         # 규칙 3으로 계산한 상금 m에 추가


print(max(m))                               # m에 추가된 상금의 최댓값 출력

다른 사람풀이

# 주사위 게임

n = int(input())
res = 0
for i in range(n):
    tmp = input().split() # 띄워쓰기 기준에 맞춰서 리스트에 요소 추가
    tmp.sort() # 오름차순 정렬
    a, b, c = map(int, tmp) # 해당 값들 정수로 변환
    if a == b and b == c: # a, b, c 모두 같을 때,
        money = 10000 + a * 1000
    elif a == b or a== c: # a와 b 혹은 a와 c가 같을 때,
        money = 1000 + (a * 100)
    elif b == c: # b와 c가 같을 때,
        money = 1000 + (b * 100)
    else: # 이 밖에, 서로 모두 다를 때
        money = c * 100 # 오름차순 정렬해서, 가장 높은 값은 c임
    if money > res: # 해당 값이 다른 값들보다 클 때, res에 할당해서 찾음
        res = money
print(res)

풀이

# 입력 : 첫 째 줄 자연수 개수 n, 그 다음 줄 n개의 자연수
# 출력 : 뒤집은 소수 입력된 순서대로 출력

from math import sqrt                               # math 패키지에서 sqrt 모듈 불러오기


def reverse(x):                                     # reverse() 함수 정의
    rev_num = 0                                     # 변수 rev_num 할당
    rev_list = []                                   # 빈 리스트 rev_list 할당
    for i in range(len(x), 0, -1):                  # x의 길이부터, 1까지 역순으로 반복
        rev_list.append(x[i-1])                     # rev_list에 x의 i 인덱스 값 추가
    rev_num = int("".join(rev_list))                # 리스트의 요소 합쳐서 정수화하여 rev_num에 할당
    return rev_num                                  # rev_num 반환

def isPrime(x):                                     # isPrime() 함수 정의
    cnt = 0                                         # 개수를 세는 cnt 할당
    for i in range(2, int(sqrt(x))+2):              # 2부터 sqrt(x) + 1까지 반복
        if x == 1:                                  # 만약 x가 1이면,
            cnt += 1                                # cnt에 1을 더해줌
        if x % i == 0 and x != i:                   # 만약 x가 i와 다르면서, x를 i로 나눈 나머지가 0일 경우,
            cnt += 1                                # cnt에 1을 더해줌
            break                                   # break
    if cnt == 0:                                    # 소수라면
        a_list.append(x)                            # a_list에 x를 추가



n = int(input())                                    # 입력할 자연수 개수 n개
num_list = list(map(list, input().split()))         # 각 입력된 자연수를 각각 리스트로 저장
a_list = []                                         # 정답을 담을 빈 리스트 a_list 할당

for i in num_list:                                  # num_list의 요소 반복
    isPrime(reverse(i))                             # i마다 reverse() 함수 선 실행후, isPrime() 함수 실행

print(*a_list, end = " ")                           # a_list 언패킹하여, 공백 하나를 기준으로 출력

다른 사람 풀이

# 뒤집은 소수

def reverse(x):
    res = 0 # 뒤집은 숫자 초기 값

    # x가 0보다 클 동안 계속 반복,
    # x가 0이 되거나 음수가 되면 반복 멈춤
    while x > 0:
        t = x % 10 # x를 10으로 나눈 나머지 - 1의 자리 숫자
        res = res * 10 + t # t를 더해주고, 기존의 res 값은 * 10
        x = x // 10 # x는 10으로 나눈 몫 - 1의 자리 숫자 빼고 나머지
    return res

def isPrime(x):
    if x == 1: # x가 1이면
        return False # False 출력 - 소수가 아님
    for i in range(2, x//2+1): # 2부터 x를 2로 나눈 몫까지,
        if x % i == 0: # x가 해당 i로 나눠 떨어지면
            return False # False 출력 - 소수가 아님
    else:
        return True # 그게 아니면 True 출력 - 소수임


n = int(input())
a = list(map(int, input().split()))
for x in a :
    tmp = reverse(x)
    if isPrime(tmp):
        print(tmp, end = ' ')

풀이 (시간 초과)

# 입력: 첫 줄 - 자연수의 개수 n
# 출력: 소수의 개수 출력

from math import sqrt               # math 패키지에서 제곱근 구하는 sqrt 모듈 불러오기

n = int(input())                    # 정수 n 입력 및 할당

cnt = [0] * (n+1)                   # n+1개 만큼의 0을 담는 리스트 cnt 할당

for i in range(2, int(sqrt(n))+1):  # 2부터 n의 제곱근 + 1까지 반복
    for j in range(2, n+1):         # 2부터 n까지 반복
        if i != j and j % i == 0:   # i와 j가 서로 다르면서, i를 j로 나눈 나머지가 0일 때,
            cnt[j] = 1              # cnt[j]의 값을 1로 변경
print(cnt.count(0)-2)               # cnt의 0의 갯수 - 2를 출력 (cnt[0]과 cnt[1]은 0과 1이기 때문에 빼줘야 함)

다른 사람 풀이

# 소수(에라토스테네스의 체)

n = int(input())                        # 정수 n 입력 및 할당
ch = [0] * (n+1)                        # n+1개 만큼의 0을 담는 리스트 ch 할당
cnt = 0                                 # 갯수 세기 위한 cnt 할당

for i in range(2, n+1):                 # 2부터 n까지 반복
    if ch[i] == 0:                      # ch[i] 가 0일 때,
        cnt += 1                        # cnt 1 더해주기
        for j in range(i, n+1, i):      # i부터 n까지 i의 간격으로 (배수들을 확인할 수 있음)
            ch[j] = 1                   # 배수에 해당하는 j일 경우, 1로 ch[j] 값 변환

print(cnt)                              # cnt 값 출력