<kimNerd />

풀이

'''
input()을 사용하면 시간 초과가 난다.
따라서 sys를 불러와, stdin.readline()을 활용한다.
'''

import sys

n = int(sys.stdin.readline())                   # 정수 n 입력 및 할당
stack = []                                      # 빈 스택 할당

for _ in range(n):                              # n번 반복
    w = list(sys.stdin.readline().split())      # w로 명령 불러오기
    command = w[0]                              # 명령어 할당
    if len(w) == 2:                             # 명령어 뒤에 정수가 있을 경우
        num = int(w[1])                         # 정수는 num에 할당

    if command == 'push':                       # 명령어가 push일 경우,
        stack.append(num)                       # stack에 해당 num 추가

    elif command == 'pop':                      # 명령어가 pop일 경우,
        if len(stack) != 0:
            print(stack.pop())                  # stack에 맨 뒤의 정수 pop() 하고 출력
        else:
            print(-1)

    elif command == 'size':                     # 명령어가 size일 경우,
        print(len(stack))                       # stack의 길이 출력

    elif command == 'empty':                    # 명령어가 empty일 경우,
        if len(stack) == 0:
            print(1)                            # 스택이 비어 있다면 1, 아니면 0 출력
        else:
            print(0)

    elif command == 'top':                      # 명령어가 top일 경우,
        if len(stack) != 0:
            print(stack[-1])                    # 스택에서 가장 높이 있는 정수 출력
        else:
            print(-1)

풀이 (실패)

# 실패
k, n = map(int, input().split())
k_list = []
c_list = []
c = 0
a_list = []

for i in range(k):
    a = int(input())
    k_list.append(a)

k_list = sorted(k_list, reverse = True)

for i in range(k):
    c += 1
    a = n // k
    if c <= n % k:
        a += 1
    c_list.append(a)

# print(k, n, k_list, c_list)

for j in range(k):
    a_list.append(k_list[j] // c_list[j])

# print(a_list)
print(min(a_list))

풀이 (성공)

k, n = map(int, input().split())
k_list = []
answer = 0

for i in range(k):
    a = int(input())
    k_list.append(a)

lt = 1
rt = max(k_list)

while lt <= rt:
    mid = (lt + rt) // 2
    a = 0
    for i in k_list:
        a += i // mid
    if a >= n:
        if mid >= answer:
            answer = mid
        lt = mid + 1
    else:
        rt = mid - 1

print(answer)

다른 사람 풀이

def count(len):
    cnt = 0
    for x in line:
        cnt += (x//len)
    return cnt


k, n = map(int, input().split())
line = []
res = 0 # 최대값 찾기
largest = 0
for i in range(k):
    tmp = int(input())
    line.append(tmp)
    largest = max(largest, tmp)

lt = 1
rt = largest

while lt <= rt:
    mid = (lt + rt) // 2
    if count(mid) >= n:
        res=mid
        lt = mid + 1
    else:
        rt = mid - 1

print(res)

풀이

# 입력: 첫 줄에 자연수 n, m, 두 번째 줄에 n개의 수가 공백을 사이에 두고 주어짐
# 출력: 첫 줄에 정렬 후 m의 값의 위치 번호를 출력

n, m = map(int, input().split())                                    # n, m 입력 및 할당
n_list = list(map(int, input().split()))                            # 숫자 리스트 입력 및 할당

n_list = sorted(n_list)                                             # n_list 오름차순 정렬

c = 0                                                               # 순서 담을 c 할당

for i in n_list:                                                    # n_list 요소 반복
    c += 1                                                          # c 1씩 증가
    if i == m:                                                      # 만약 i가 m이면
        print(c)                                                    # c 출력
        break                                                       # 반복문 종료

다른 사람 풀이

# 이분검색

'''
lt, rt
0 1 2 3 4 5 6 7
12 23 32 57 65 81 87 99

mid = (lt + rt) // 2

3 = mid

a[mid] == m

rt = mid - 1
lt = mid + 1

절반씩 좁혀 나감

1 = mid

lt, rt = 2

만약 1024개의 데이터가 있다면
512개로 줄어듦
256으로 절반으로 줄어듦
128씩 작아지면

이분검색 log n번만에 된다.
'''

n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
lt = 0
rt = n-1
while lt <= rt:
    mid = (lt + rt) // 2
    if a[mid] == m:
        print(mid + 1)
        break
    elif a[mid]>m:
        rt = mid - 1
    else:
        lt = mid + 1

풀이

'''
가로로 검사해야 하는 수: 3 * 7 = 21
세로로 검사해야 하는 수: 3 * 7 = 21
42개 검사할 수 있는 함수를 만들면 됨

[0:5]
'''

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

a = [list(map(int, input().split())) for _ in range(7)]         # 배열 값들 입력하여 할당

tmp = []                                                        # 행 슬라이싱해서 담을 빈 리스트 할당
for i in range(7):                                              # 7번 반복
    for j in range(3):                                          # 3번 반복 (이중반복)
        tmp = a[i][0+j:5+j]                                     # 5개의 요소만 슬라이싱

        if tmp[0] == tmp[4] and tmp[1] == tmp[3]:               # 회문일 때,
            cnt += 1                                            # cnt 1 증가

        if a[0+j][i] == a[4+j][i] and a[1+j][i] == a[3+j][i]:   # 세로로 회문일 때,
            cnt += 1                                            # cnt 1 증가

print(cnt)                                                      # cnt 출력

다른 사람 풀이

board = [list(map(int, input().split())) for _ in range(7)]

cnt = 0

for i in range(3):
    for j in range(7):
        tmp = board[j][i:i+5]
        if tmp == tmp[::-1]:
            cnt += 1
        for k in range(2):
            if board[i+k][j] != board[i+5-k-1][j]:
                break
        else:
            cnt += 1
print(cnt)

# 실패
# 45 합을 기준으로 만든 수도쿠
# 값이 중복되더라도 합이 45가 되는 반례가 존재함

'''
각 사각형의 합

a[0][0] a[0][1] a[0][2]
a[1][0] a[1][1] a[1][2]
a[2][0] a[2][1] a[2][2]

a[0][3] a[0][4] a[0][5]
a[1][3] a[1][4] a[1][5]
a[2][3] a[2][4] a[2][5]

a[0][6] a[0][7] a[0][8]
a[1][6] a[1][7] a[1][8]
a[2][6] a[2][7] a[2][8]

a[3][0] a[3][1] a[3][2]
a[4][0] a[4][1] a[4][2]
a[5][0] a[5][1] a[5][2]

a[3][3] a[3][4] a[3][5]
a[4][3] a[4][4] a[4][5]
a[5][3] a[5][4] a[5][5]

a[3][6] a[3][7] a[3][8]
a[4][6] a[4][7] a[4][8]
a[5][6] a[5][7] a[5][8]

a[6][0] a[6][1] a[6][2]
a[7][0] a[7][1] a[7][2]
a[8][0] a[8][1] a[8][2]

a[6][3] a[6][4] a[6][5]
a[7][3] a[7][4] a[7][5]
a[8][3] a[8][4] a[8][5]

a[6][6] a[6][7] a[6][8]
a[7][6] a[7][7] a[7][8]
a[8][6] a[8][7] a[8][8]

3개 * 3개 만큼 이중반복하면 될 듯!

'''

sudoku = [list(map(int, input().split())) for _ in range(9)]

cnt1 = 0
cnt2 = 0
cnt3 = 0

for i in range(9):
    print(sum(sudoku[i]))
    if sum(sudoku[i]) == 45:
        cnt1 = 0
    else:
        cnt1 = 1

    tmp = 0
    for j in range(9):
        tmp += sudoku[j][i]
    print(tmp)
    if tmp == 45:
        cnt2 = 0
    else:
        cnt2 = 1

for l1 in range(3):
    for l2 in range(3):
        tmp2 = 0
        tmp2 += sudoku[l1 * 3][l2 * 3]
        tmp2 += sudoku[l1 * 3][l2 * 3 + 1]
        tmp2 += sudoku[l1 * 3][l2 * 3 + 2]
        tmp2 += sudoku[l1 * 3 + 1][l2 * 3]
        tmp2 += sudoku[l1 * 3 + 1][l2 * 3 + 1]
        tmp2 += sudoku[l1 * 3 + 1][l2 * 3 + 2]
        tmp2 += sudoku[l1 * 3 + 2][l2 * 3]
        tmp2 += sudoku[l1 * 3 + 2][l2 * 3 + 1]
        tmp2 += sudoku[l1 * 3 + 2][l2 * 3 + 2]
        print(tmp2)
        if tmp2 == 45:
            cnt3 = 0
        else:
            cnt3 = 1

if cnt1 == 1 or cnt2 == 1 or cnt3 == 1:
    print('NO')
else:
    print('YES')

다른 사람 풀이

# 행을 체크하는 리스트
# 열을 체크하는 리스트
# 그룹을 체크하는 리스트를 만들어서 확인

'''
ch = [0] * 10
ch1 행
ch2 얄
ch3 그룹
ch[a[i][j]] = 1
sum(ch) != 9
잘못된 스토쿠임
'''

def check(tmp):
    for i in range(9):
        ch1 = [0] * 10
        ch2 = [0] * 10
        for j in range(9):
            ch1[a[i][j]] = 1
            ch2[a[j][i]] = 1
        if sum(ch1) != 9 or sum(ch2) != 9:
            return False
    for i in range(3):
        for j in range(3):
            ch3 = [0] * 10
            for k in range(3):
                for s in range(3):
                    ch3[a[i*3 + k][j*3 + s]] = 1
            if sum(ch3) != 9:
                return False
    return True

a = [list(map(int, input().split())) for _ in range(9)]

if check(a):
    print('YES')
else:
    print('NO')

풀이

n = int(input())                                                                # 정수 n 입력 및 할당
a = [list(map(int, input().split())) for _ in range(n)]                         # 값들 입력 받아 배열 할당
a.insert(0, [0] * (n + 2))                                                      # 맨 윗 줄에 0으로 된 행 넣기
a.append([0] * (n + 2))                                                         # 맨 아랫 줄에도 0으로 된 행 넣기
for i in range(1, n+1):                                                         # 1부터 n까지 반복
    a[i].insert(0, 0)                                                           # 각 행 첫 부분에 0 추가
    a[i].append(0)                                                              # 각 행 끝 부분에 0 추가

cnt = 0                                                                         # 봉우리 갯수 세기 위한 cnt 할당

for j in range(1, n+1):                                                         # 1부터 n까지 반복
    for k in range(1, n+1):                                                     # 이중반복문
        p = a[j][k]                                                             # 봉우리 검사를 위한 p 할당
        if p > a[j][k+1] and p > a[j][k-1] and p > a[j+1][k] and p > a[j-1][k]: # p를 상하좌우랑 비교했을 때 모두 큰 값이면
            cnt += 1                                                            # cnt를 1만큼 증가

print(cnt)                                                                      # 계산을 통해 얻은 봉우리 갯수 출력

다른 사람 풀이

dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]

n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
a.insert(0, 0 * n)
a.append([0] * n)
for x in a:
    x.insert(0, 0)
    x.append(0)

cnt = 0
for i in range(1, n+1):
    for j in range(1, n+1):
        if all(a[i][j] > a[i+dx[k]][j+dy[k]] for k in range(4)):
            cnt += 1

print(cnt)

풀이

'''
예를 들어, 2 0 3
0 1 2 3 4
3 4 0 1 2

3 -> 3 - 3 = 0
4 -> 4 - 3 = 0
2 -> 2 - 3 = -1 -> 4 == len() + (2 - 3)
1 -> 1 - 3 = -2 -> 3 == len() + (1 - 3)
0 -> 0 - 3 = -3 -> 2 == len() + (0 - 3)

한편, 2 1 3
0 1 2 3 4
2 3 4 0 1

0 -> 0 + 3 = 3
1 -> 1 + 3 = 4

2 -> 2 + 3 = 5 -> 1 = 5 - 4
3 -> 3 + 3 = 6 -> 2 = 6 - 4
4 -> 4 + 3 = 7 -> 3 = 7 - 4
'''

# 입력: 첫 줄 - N, 둘 째줄부터 N째줄까지 자연수 N개, 이후 M, M줄의 회전 명령
# 출력: 총 감의 개수

n = int(input())                                        # 정수 n 입력 및 할당
array = []                                              # 빈 array 할당
for i in range(n):                                      # n만큼 반복
    array.append(list(map(int,input().split())))        # array에 숫자 입력하여 추가

m = int(input())                                        # 정수 m 입력 및 할당
for i in range(m):                                      # m만큼 반복
    a, b, c = map(int, input().split())                 # a, b, c 입력 및 할당
    if b == 0:                                          # b가 0이면 왼쪽으로 회전
        for _ in range(c):                              # c만큼 반복
            array[a-1].append(array[a-1][0])            # 제일 왼쪽의 숫자를 제일 오른쪽에 추가
            array[a-1].pop(0)                           # 제일 왼쪽의 숫자 pop()으로 제거

    else:                                               # b가 1이면 오른쪽으로 회전
        for _ in range(c):                              # c만큼 반복
            array[a-1].insert(0, array[a-1][-1])        # 제일 오른쪽의 숫자를 제일 왼쪽에 추가
            array[a-1].pop()                            # 제일 오른쪽의 숫자 pop()으로 제거

s = 0                                                   # 시작 포인터: 0으로 할당
e = n                                                   # 끝 포인터: n으로 할당 (슬라이싱을 위해 n-1이 아닌, n)

sum_result = 0                                          # 합을 담을 sum_result 변수 0으로 할당

for j in range(n):                                      # n만큼 반복
    sum_result += sum(array[j][s:e])                    # 해당 조건의 슬라이싱된 리스트의 합을 sum_result에 더해줌
    if j < n // 2:                                      # 절반을 기준으로 위에 있는 행들의 경우,
        s += 1                                          # s는 1씩 커지고
        e -= 1                                          # e는 1씩 작아짐
    else:                                               # 절반을 기준으로 밑에 있는 행들의 경우,
        s -= 1                                          # s는 1씩 작아지고
        e += 1                                          # e는 1씩 커짐

print(sum_result)                                       # 합 출력

다른 사람 풀이

n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
m = int(input())
for i in range(m):
    h, t, k = map(int, input().split())
    if t == 0:
        for _ in range(k):
            a[h-1].append(a[h-1].pop(0))

    else:
        for _ in range(k):
            a[h-1].insert(0, a[h-1].pop())

res = 0
s = 0
e = n - 1
for i in range(n):
    for j in range(s, e+1):
        res += a[i][j]
    if i < n // 2:
        s += 1
        e -= 1
    else:
        s -= 1
        e += 1

print(res)

풀이

# 입력: 첫 줄 - N (홀수), 두 번째 줄부터 N번째 줄까지 N개의 자연수
# 출력: 수확한 총 사과 개수

'''
만약 7이면,
1 3 5 7 5 3 1

만약 9이면,
1 3 5 7 9 7 5 3 1
'''

n = int(input())                                                            # 정수 n 입력 및 할당
array = []                                                                  # 빈 array 할당
list_s = []                                                                 # list_s 할당

for i in range(n):                                                          # n만큼 반복
    array.append(list(map(int,input().split())))                            # array에 각 행의 숫자 추가

for i in range(n):                                                          # n만큼 반복
    if i <= int(n/2):                                                       # 위의 절반 줄의 경우에는
        list_s.append(sum(array[i][int(n/2)-i:int(n/2)+1+i]))               # 해당 조건만큼만 슬라이싱해서 더함
    else:                                                                   # 반대로 밑의 절반 줄의 경우에는
        list_s.append(sum(array[i][int(n/2)-(n-i-1):int(n/2)+1+(n-i-1)]))   # 해당 조건만큼만 슬라이싱해서 더함

print(sum(list_s))                                                          # 합을 구하여 출력

다른 사람 풀이

n = int(input())
a = [list(map(int, input().split())) for _ in range(n)]
res = 0

s = e = n // 2

for i in range(n):
    for j in range(s, e + 1):
        res += a[i][j]
    if i < n // 2:
        s -= 1
        e += 1
    else:
        s += 1
        e -= 1

print(res)

풀이

n = int(input())
board = []

for _ in range(n):
    tmp = list(map(int, input().split()))
    board.append(tmp)

max_sum = 0

# 가로 합 구해서 최댓값과 비교
for i in board:
    if sum(i) > max_sum:
        max_sum = sum(i)

# 세로 합 구해서 최댓값과 비교
for j in range(n):
    tmp = 0
    for k in range(n):
        tmp += board[k][j]
        if tmp > max_sum:
            max_sum = tmp

# 정방향 대각선 합 구해서 최댓값과 비교
tmp2 = 0
for l in range(n):
    tmp2 += board[l][l]
if tmp2 > max_sum:
    max_sum = tmp2

# 역방향 대각선 합 구해서 최댓값과 비교
tmp3 = 0
for m in range(n):
    tmp3 += board[m][n-1-m]
if tmp3 > max_sum:
    max_sum = tmp3

print(max_sum)

풀이 2

# 앞의 풀이와 크게 다르지 않음

# 입력: 첫 줄 - N, 두 번째부터 N번째까지 N개의 자연수
# 출력: 최대합 출력

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

array = []                                              # 숫자를 담을 빈 array 할당
list_s = []                                             # 합을 담을 list_s 할당

for i in range(n):                                      # n만큼 반복
    array.append(list(map(int,input().split())))        # 숫자 list로 변환하여 2차원 배열에 담기

for i in array:                                         # array 요소만큼 반복
    list_s.append(sum(i))                               # 각 행의 합 구하여 list_s에 추가

for i in range(n):                                      # i 만큼 반복
    tmp = 0                                             # 요소 값을 더할 tmp 할당
    for j in range(n):                                  # 이중반복문
        tmp += array[j][i]                              # 각 열의 합 구하기
    list_s.append(tmp)                                  # list_s에 추가

i = 0
tmp2 = 0
tmp3 = 0
while i < n:                                            # i가 n보다 크지 않을 때 무한 반복
    tmp2 += array[i][i]                                 # tmp2에는 정방향 대각선 합 구하기
    tmp3 += array[n-1-i][i]                             # tmp3에는 역방향 대각선 합 구하기
    i += 1
else:
    list_s.append(tmp2)                                 # list_s에 추가
    list_s.append(tmp3)                                 # list_s에 추가

print(max(list_s))                                      # list_s의 최댓값 출력

다른 사람 풀이

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

# 한 번에 2차원 배열로 만들기
a=[list(map(int, input().split())) for _ in range(n)]

# 가장 작은 값으로 최댓값 할당
largest = -2147000000

# 행과 열 합 구하기
for i in range(n):
    sum1 = sum2 = 0
    for j in range(n):
        sum1 += a[i][j]  # 행을 쭉 합하는 것
        sum2 += a[j][i]  # 열을 쭉 합하는 것

    if sum1 > largest:
        largest = sum1
    if sum2 > largest:
        largest = sum2

# 대각선 합 구하기
sum1 = sum2 = 0
for i in range(n):
    sum1 += a[i][i]
    sum2 += a[i][n-i-1]

if sum1 > largest:
    largest = sum1
if sum2 > largest:
    largest = sum2

print(largest)