<kimNerd />

풀이

# 입력 : 첫째 줄 - 단어 갯수 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 값 출력

풀이

# 입력: n개 자연수
# 출력: 합이 최대인 자연수

sum_x = []                                       # 합을 담을 빈 리스트 sum_x 할당

def digit_sum(x):                                # 함수 digit_sum 정의
    for i in x:                                  # x에 i 요소 반복
        sum_x.append(sum(map(int, str(i))))      # i를 문자열 변환하여 각 자릿수를 나눈 뒤 합을 구해 sum_x에 추가
    print(num_list[sum_x.index(max(sum_x))])     # 합이 최댓값이 되는 sum_x의 index를 구해, num_list에서 해당 index 값 출력

n = int(input())                                 # 정수 n 할당
num_list = list(map(int, input().split()))       # num_list에 각 자연수 할당
digit_sum(num_list)                              # 함수 digit_sum 실행

다른 사람 풀이 1

# 자릿수의 합

n = int(input())

a = list(map(int, input().split()))
def digit_sum(x):
    sum = 0
    while x > 0:
        sum += x%10
        x = x // 10
    return sum

max = -2147000000

for x in a:
    tot = digit_sum(x)
    if tot > max:
        max = tot
        res = x

print(res)

다른 사람 풀이 2

# 자릿수의 합

n = int(input())

a = list(map(int, input().split()))
def digit_sum(x):
    sum = 0
    for i in str(x):
        sum += int(i)
    return sum

max = -2147000000

for x in a:
    tot = digit_sum(x)
    if tot > max:
        max = tot
        res = x

print(res)

풀이

# 입력: 첫째 줄 - n, m (4, 6, 8, 12, 20 중 하나)

# 출력: 답 출력

n, m = map(int, input().split())        # 정수 n, m 입력하여 할당

list = []                               # 빈 리스트 list 할당

for i in range(1, n+1):                 # 1부터 n까지 반복
    for j in range(1, m+1):             # 1부터 m까지 이중 반복
        list.append(i+j)                # i+j를 리스트에 추가

cnt_list = []                           # 갯수 담는 빈 리스트 cnt_list 할당

for i in range(2, n+m):                 # 2부터 n+m-1까지 반복
    cnt_list.append(list.count(i))      # cnt_list에 각 i에 해당하는 list의 요소 갯수 카운트하여 추가

max_value = max(cnt_list)               # cnt_list의 최댓값 max_value에 할당

a_list = []                             # 정답을 담을 빈 리스트 a_list 할당

for i in range(len(cnt_list)):          # cnt_list의 길이만큼 반복
    if cnt_list[i] == max_value:        # cnt_list의 각 요소가 최댓값과 일치한다면
        a_list.append(i+2)              # i+2를 a_list에 추가 (i+2를 하는 이유는 cnt_list의 인덱스 0이 합 2의 갯수를 의미하기 때문)


print(*a_list, sep = ' ')               # a_list 언패킹하여, 공백 하나 간격으로 출력

다른 사람 풀이

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

# 넉넉하게 잡아서
# 리스트의 크기가 n+m+3 만큼 생김
cnt = [0]*(n+m+3)

max = -2147000000

# 1부터 n까지 돈다.
# 1부터 m까지 돈다.
for i in range(1, n+1):
    for j in range(1, m+1):
        cnt[i+j] += 1

# n + m까지 돈다.
for i in range(n+m+1):
    if cnt[i] > max:
        max = cnt[i]

# n + m까지 돈다.
# 최대값과 같은 칼럼들 찾아내기
# i 출력
# end = ' '로 한 칸 띄워서 옆에 출력
for i in range(n+m+1):
    if cnt[i] == max:
        print(i, end = ' ')

풀이

# 입력: 첫째 줄 - 학생 수 n
# 입력: 둘째 줄 - 각 학생 수학점수

# 출력: 평균 및 평균에 가장 가까운 학생의 번호 출력
# 출력: 평균은 소수 첫째 자리에서 반올림 '73.9 -> 74'

n = int(input())                                    # 정수 n 입력하여 할당
m_score = list(map(int, input().split()))           # m_score에 각 학생의 수학 점수 입력하여 리스트로 할당

average = round((sum(m_score) / len(m_score)))      # 평균 출력: sum()으로 합 구하고 m_score의 길이를 len()으로 구하여 나눔; round()로 반올림

min = abs(m_score[0] - average)                     # 최솟값 초기값 설정: 첫 번째 학생의 수학 점수 - 평균 점수
stu = 0                                             # 학생 번호 초기값 설정: 0

for i in range(1, len(m_score)):                    # 1부터 n만큼 반복; len(m_score) 대신 n을 사용해도 괜찮음
    if abs(m_score[i] - average) < min:             # i번째 학생의 수학 점수 - 평균 점수의 절대값이 최솟값보다 작을 경우
        min = abs(m_score[i] - average)             # 해당 값을 최소값으로 할당
        stu = i                                     # 학생 번호도 i로 할당

print(average, stu+1)                               # 평균과 학생 번호 출력 (stu는 인덱스 번호기 때문에 +1 해줘야 함)

다른 사람 풀이

# 대표값

n = int(input())
a = list(map(int, input().split()))
ave = round(sum(a)/n)
min = 2147000000
for idx, x in enumerate(a):
    tmp = abs(x-ave)
    if tmp < min:
        min = tmp
        score = x
        res = idx + 1
    elif tmp == min:
        if x > score:
            score = x
            res = idx + 1

print(ave, res)

풀이

'''
[자료구조와 알고리즘 입문]

K번째 큰 수

현수는 1부터 100사이의 자연수가 적힌 N장의 카드를 가지고 있습니다.
같은 숫자의 카드가 여러장 있을 수 있습니다.
현수는 이 중 3장을 뽑아 각 카드에 적힌 수를 합한 값을 기록하려고 합니다.
3장을 뽑을 수 있는 모든 경우를 기록합니다.
기록한 값 중 K번째로 큰 수를 출력하는 프로그램을 작성하세요.

25, 25, 23, 23, 22, 20, 19... K값이 3이라면 K번째 큰 값은 22
'''

# 입력: 첫째 줄 n, k
# 입력: 둘째 줄 n개의 카드값 입력

# 출력: k번째 수 출력

from itertools import combinations                              # itertools 패키지에서 combinations 모듈 불러오기

n, k = map(int, input().split())                                # n, k 정수 할당
n_list = input().split()                                        # n_list에 숫자 입력하여 리스트로 할당

data = combinations(n_list, 3)                                  # combinations() 함수 통해, n_list의 요소 3개씩 묶은 조합 data에 할당
a_list = []                                                     # 정답을 담을 a_list 빈 리스트 할당

for i in data:                                                  # data의 각 요소 i 반복
    a_list.append(sum((int(i[0]), int(i[1]), int(i[2]))))       # 각 요소의 합 더하여 a_list에 할당

tmp = set(a_list)                                               # a_list를 set 자료구조로 변환하여 tmp에 할당
a_list2 = list(tmp)                                             # a_list2는 기존의 list를 set으로 변환했다가 다시 list로 변환한 것
a_list2.sort(reverse=True)                                      # a_list2 내림차순 정렬

print(a_list2[k-1])                                             # a_list2의 k-1 인덱스의 값 출력

다른 사람 풀이

# K번째 큰 수

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

# 중복을 제거하는 자료구조
res = set()

# 중복 방지
# 삼중 반복문
# set은 append()가 아닌 add()

for i in range(n):
    for j in range(i+1, n):
        for m in range(j+1, n):
            res.add(a[i]+a[j]+a[m])

# set은 sort()가 없음
# list로 바꿔서 정렬해줘야 함
# sort(reverse=True) 내림차순 정렬
res = list(res)
res.sort(reverse=True)
print(res[k-1])