[IM대비]

[SWEA]
간단한 369게임

N = int(input())
for i in range(1, N+1):
    flag = False
    if '3' in str(i) or '6' in str(i) or '9' in str(i):
        flag = True

    for j in str(i):
        if '3' in j or '6' in j or '9' in j:
            print('-', end='')
        elif not flag:
            print(j, end='')
    print('', end = ' ')

퍼펙트 셔플 ❤️

T = int(input())
for tc in range(1, T+1):
    N = int(input())
    card = list(input().split())
 
    if N % 2 == 0:
        c1 = card[:N//2]
        c2 = card[N//2:]
    else:
        c1 = card[:N//2+1]
        c2 = card[N//2+1:]
 
    result = []
 
    while c1 or c2:
        if c1:
            result.append(c1.pop(0))
        if c2:
            result.append(c2.pop(0))
 
    print(f'#{tc}', *result)

풍선팡3

T = int(input())
for tc in range(1, T+1):
    n = int(input())
    balloon = [list(map(int, input().split())) for _ in range(n)]

    dx = [-1, 0, 1, 0]
    dy = [0, 1, 0, -1]
    result_list = []
    for i in range(n):
        for j in range(n):
            result = balloon[i][j]
            for k in range(4):
                nx, ny = i + dx[k], j + dy[k]
                for _ in range(balloon[i][j]):
                    if 0 <= nx < n and 0 <= ny < n:
                        result += balloon[nx][ny]
                    nx += dx[k]
                    ny += dy[k]
            result_list.append(result)

    print(f'#{tc}', max(result_list)-min(result_list))

정곤이의 단조증가하는 수

T = int(input())
for tc in range(1, T + 1):
    N = int(input())
    arr = list(map(int, input().split()))
    multi_lst = []
    danjo = []
 
    for i in range(N - 1):
        for j in range(i + 1, N):
            multi_lst.append(arr[i] * arr[j])
 
    for k in multi_lst:
        K = str(k)
        result = True
 
        for j in range(0, len(K) - 1):
            if K[j] > K[j + 1]:
                result = False
 
        if result:
            danjo.append(k)
 
    if len(danjo) == 0:
        print(f'#{tc}', -1)
    else:
        print(f'#{tc}', max(danjo))

오목 판정 ❤️

def check():
    #오른쪽, 아래, 오른쪽 아래 대각선, 왼쪽 아래 대각선
    dx = [0,1,1,1]
    dy = [1,0,1,-1]
 
    for i in range(N):
        for j in range(N):
            if board[i][j] == 'o':
                for dir in range(4):
                    nx, ny = i, j
                    cnt = 0
 
                    while 0 <= nx < N and 0 <= ny < N and board[nx][ny] == 'o':
                        cnt += 1
                        nx += dx[dir]
                        ny += dy[dir]
 
                    if cnt >= 5:
                        return 'YES'
 
    return 'NO'
 
 
T = int(input())
for tc in range(1, T+1):
    N = int(input())
    board = [list(input()) for _ in range(N)]
 
    print(f'#{tc}', check())

원재의 메모리 복구하기

T = int(input())
for tc in range(1, T+1):
    n = list(input())
    result = 0
    origin = [0] * len(n)
     
    for i in range(len(origin)):
        if int(n[i]) != origin[i]:
            for j in range(i, len(origin)):
                origin[j] = int(n[i])
            result += 1
         
        else:
            continue
     
    print(f'#{tc} {result}')

농작물 수확하기 ❤️

T = int(input())
for tc in range(1, T+1):
    n = int(input())
    farm = [list(map(int, input())) for _ in range(n)]
 
    total = 0
    mid = (n-1) // 2
    for i in range(n):
        if i <= mid:
            total += sum(farm[i][mid-i:mid+1+i])
        else:
            total += sum(farm[i][i-mid:mid-i])
 
    print(f'#{tc} {total}')

어디에 단어가 들어갈 수 있을까

T = int(input())
for tc in range(1, T+1):
    n, k = map(int, input().split())
    puzzle = [list(map(int, input().split())) for _ in range(n)]
 
    result = 0
    for i in range(n):
        row_cnt = 0
        for j in range(n):
            if puzzle[i][j] == 1:
                row_cnt += 1
            if puzzle[i][j] == 0 or j == n - 1:
                if row_cnt == k:
                    result += 1
                row_cnt = 0
 
    for i in range(n):
        col_cnt = 0
        for j in range(n):
            if puzzle[j][i] == 1:
                col_cnt += 1
 
            if puzzle[j][i] == 0 or j == n - 1:
                if col_cnt == k:
                    result += 1
                col_cnt = 0
 
    print(f'#{tc} {result}')

삼성시의 버스노선 ❤️

T = int(input())  # 테스트 케이스 개수
for test_case in range(1, T + 1):
    N = int(input())
    bus_station = [0] * 5001
    for i in range(N):
        Ai, Bi = map(int, input().split())
        for i in range(Ai, Bi + 1):
            bus_station[i] += 1
 
    P = int(input())
    result = [0] * (P + 1)
    for i in range(1, P + 1):
        result[i] = bus_station[int(input())]
 
    print(f'#{test_case}', *result[1:])

파리퇴치3 ❤️

def catch_pari(x, y, dx, dy):
    global mx_val
    total = arr[y][x]
    for i in range(4):
        for j in range(1, M):
            nx = x + dx[i] * j
            ny = y + dy[i] * j
 
            if nx < 0 or ny < 0 or N <= nx or N <= ny: #범위 넘는 건 고려 x
                continue
            else:
                total += arr[ny][nx]
 
    if mx_val < total:
        mx_val = total
 
    return
 
T = int(input())
for tc in range(1, T+1):
    N, M = map(int, input().split())
    arr = [list(map(int, input().split())) for _ in range(N)]
 
    # + 모양
    dx = [-1,1,0,0]
    dy = [0,0,-1,1]
 
    # x 모양
    dx2 = [-1,1,-1,1]
    dy2 = [-1,1,1,-1]
 
    mx_val = 0
    for i in range(N):
        for j in range(N):
            catch_pari(i, j, dx, dy)
            catch_pari(i, j, dx2, dy2)
 
    print(f'#{tc} {mx_val}')

세제곱근을 찾아라

T = int(input())
for tc in range(1, T+1):
    N = int(input())
    start = 1
    end = N
    result = -1
  
    while start <= end:
        mid = (start + end) // 2
  
        if N == mid ** 3:
            result = mid
            break
        elif N < mid ** 3:
            end = mid -1
        else:
            start = mid + 1
  
    print(f'#{tc} {result}')

쇠막대기 자르기

T = int(input())
for tc in range(1,T+1):
    lst = input() # 쇠 막대기 & 레이저 정보 입력
    result = 0 # 잘린 막대기 개수
    cnt = 0 # 쌓여있는 막대기 개수
  
    for i in range(len(lst)):
        if lst[i] == '(':  #막대기 추가
            cnt += 1
        else:  # ')'
            cnt -= 1
            if lst[i-1] == '(':  # 레이저
                result += cnt
            else:  # 막대기 끝
                result += 1
  
    print(f'#{tc} {result}')

스도쿠 검증

T = int(input())
for tc in range(1, T+1):
    sudoku = [list(map(int, input().split())) for _ in range(9)]
    result = 1
    for i in range(9):
        row_check = [0] * 10 #행 검사
        col_check = [0] * 10 #열 검사
        for j in range(9):
            row_check[sudoku[i][j]] += 1
            if row_check[sudoku[i][j]] == 2:
                result = 0
            col_check[sudoku[j][i]] += 1
            if col_check[sudoku[j][i]] == 2:
                result = 0
  
    for a in range(0, 9, 3):
        for b in range(0, 9, 3):
            three_check = [0] * 10
            for x in range(3):
                for y in range(3):
                    three_check[sudoku[a+x][b+y]] += 1
                    if three_check[sudoku[a+x][b+y]] == 2:
                        result = 0
  
  
    print(f'#{tc} {result}')

진기의 최고급 붕어빵

T = int(input())
for tc in range(1, T+1):
    N, M, K = map(int, input().split())
    arrive = list(map(int, input().split()))
    arrive.sort()
  
    flag = 'Possible'
    for i in range(N):
        fish = arrive[i] // M * K - (i+1)
  
        if fish < 0:
            flag = 'Impossible'
  
    print(f'#{tc} {flag}')

백만장자 프로젝트

T = int(input()) #테스트 케이스 개수 입력
for tc in range(1, T+1):
    N = int(input())
    cost_lst = list(map(int, input().split()))
      
    mx = cost_lst[-1] #마지막 원소를 임시 최대값으로 설정
    total = 0 #최대 이익을 저장할 변수
      
    for i in range(N-2, -1, -1): #뒤에서 두번째 원소부터 첫 원소까지 거꾸로 순회하면서,
        if cost_lst[i] >= mx:
            mx = cost_lst[i]
        else:
            total += mx - cost_lst[i]
      

화물 도크

T = int(input())
for tc in range(1, T+1):
    N = int(input())
    time = [list(map(int, input().split())) for _ in range(N)]
    time.sort(key = lambda x: x[1], reverse=True)

    ans = 1
    end = time.pop()[1]

    while time:
        s, e = time.pop()
        if end <= s:
            end = e
            ans += 1

    print(f'#{tc} {ans}')

컨테이너 운반

for tc in range(1, int(input()) + 1):
    n, m = map(int, input().split())
    containers = list(map(int, input().split()))
    trucks = list(map(int, input().split()))

    containers.sort(reverse=True)
    trucks.sort(reverse=True)

    c, t = 0, 0
    total = 0

    while c < n and t < m:
        if trucks[t] >= containers[c]:
            total += containers[c]
            t += 1
        c += 1

    print(f'#{tc} {total}')

전자카트

def calc(path):
    total = energy[0][path[0]-1] + energy[path[-1]-1][0]
    for i in range(len(path)-1):
        total += energy[path[i] - 1][path[i + 1] - 1]
 
    possible_lst.append(total)
 
def move(x):
    if x == N-1:
        calc(path)
        return
 
    for i in range(2, N+1):
        if used[i] == True:
            continue
        used[i] = True
        path.append(i)
        move(x+1)
        path.pop()
        used[i] = False
 
T = int(input())
for tc in range(1, T+1):
    N = int(input())
    energy = [list(map(int, input().split())) for _ in range(N)]
    path = []
    used = [False for _ in range(N + 1)]
    possible_lst = []
    move(0)
 
    print(f'#{tc}', min(possible_lst))

Magnetic

T = 10
for tc in range(1, T+1):
    N = int(input())
    table = [list(map(int, input().split())) for _ in range(N)]
    cnt = 0
    for i in range(N):
        red_flag = False
        for j in range(N):
            if table[j][i] == 1:
                red_flag = True
            if table[j][i] == 2 and red_flag:
                cnt += 1
                red_flag = False
 
    print(f'#{tc}', cnt)

미로1

from collections import deque
 
def bfs(x, y):
    q.append((x, y))
    visited[x][y] = True
 
    while q:
        x, y = q.popleft()
        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]
 
            if x < 0 or y < 0 or nx >= N or ny >= N or visited[nx][ny] or maze[nx][ny] == 1:
                continue
 
            if maze[nx][ny] == 3:
                return True
 
            visited[nx][ny] = True
            q.append((nx, ny))
 
    return False
 
 
N = 16
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]
 
for _ in range(10):
    q = deque()
    tc = int(input())
    maze = [list(map(int, input().rstrip())) for _ in range(N)]
    visited = [[False] * N for _ in range(N)]
     
    for i in range(N):
        for j in range(N):
            if maze[i][j] == 2:
                x = i
                y = j
                break
 
    result = bfs(x, y)
 
    print(f'#{tc} {int(result)}')

자기 방으로 돌아가기

T = int(input())
for tc in range(1, T+1):
    N = int(input())
    room = [list(map(int, input().split())) for _ in range(N)] # [ [출발지점, 도착지점] ]
 
    cnt_lst = [0] * 202
    for r in room:
        if r[0] < r[1]:
            start = (r[0] + 1) // 2
            end = (r[1] + 1) // 2
        else:
            start = (r[1] + 1) // 2
            end = (r[0] + 1) // 2
 
        for i in range(start, end+1):
            cnt_lst[i] += 1
 
    result = max(cnt_lst)
    print(f'#{tc} {result}')

재밌는 오셀로 게임

T = int(input())
dir = [(0, 1), (1, 0), (-1, 0), (0, -1), (1, 1), (-1, 1), (1, -1), (-1, -1)] #상하좌우, 대각선 8방향
 
for tc in range(1, T+1):
    n, m = map(int, input().split()) #n: 한 변의 길이, m: 돌을 놓는 횟수
    board = [[0] * n for _ in range(n)] #n*n 보드판 0으로 초기화
 
    #초기 바둑돌 세팅
    board[n//2][n//2] = 2 #W
    board[n//2-1][n//2-1] = 2 #W
    board[n//2-1][n//2] = 1 #B
    board[n//2][n//2-1] = 1 #B
 
    for _ in range(m):
        x, y, color = map(int, input().split())
        x, y = x-1, y-1 #index값이므로 -1씩 해줌
 
        data = []
 
        for i in range(8):
            dx, dy = dir[i]
            nx = x + dx
            ny = y + dy
 
            while True:
                if not (0 <= nx < n and 0 <= ny < n): #board 범위를 벗어나는 경우, data 리스트 초기화해주고 break
                    data = []
                    break
                if board[nx][ny] == 0: #빈 칸일 경우, data 리스트 초기화해주고 break
                    data = []
                    break
                if board[nx][ny] == color: #현재 돌과 같은 색의 돌일 경우 break
                    break
                else: #현재 돌과 다른 색의 돌일 경우 data 리스트에 (nx, ny) append
                    data.append((nx, ny))
                nx, ny = nx + dx, ny + dy #다음 인접한 칸 확인
 
            # 같은 색의 돌로 바꾸기
            for tx, ty in data:
                if color == 1:
                    board[tx][ty] = 1
                elif color == 2:
                    board[tx][ty] = 2
 
        board[x][y] = color
 
    ww, bb = 0, 0
 
    for i in range(n):
        ww += board[i].count(2)
        bb += board[i].count(1)
 
    print(f'#{tc} {bb} {ww}')

View

T = 10
  
for tc in range(1, T + 1):
    N = int(input())
    buildings = list(map(int, input().split()))
  
    cnt = 0
    for i in range(2, N - 2):
        me_height = buildings[i]
        mx_other_height = max(buildings[i-2], buildings[i-1], buildings[i+1], buildings[i+2])
        if me_height > mx_other_height:
            cnt += me_height - mx_other_height
  
    print(f'#{tc} {cnt}')

Flatten

for test_case in range(1, 11):
    M = int(input())
    boxes = list(map(int, input().split()))
 
    for _ in range(M):
        boxes.sort()
        #최고점과 최저점의 높이 차가 1 이하라면, 반복을 중지
        if boxes[-1] - boxes[0] <= 1:
            break
        boxes[-1] -= 1
        boxes[0] += 1
 
    print(f'#{test_case} {max(boxes) - min(boxes)}')

달팽이 숫자

di = [0, 1, 0, -1]
dj = [1, 0, -1, 0]
 
T = int(input())
 
for test_case in range(1, T+1):
    N = int(input())
    lst = [[0]*N for _ in range(N)]
 
    cnt = 1 
    i, j = 0, 0 
    dr = 0 
 
    while True:
        lst[i][j] = cnt
 
        if cnt == N * N:
            break
        ni = i + di[dr]
        nj = j + dj[dr]
 
        if 0 > ni or N <= ni or 0 > nj or N <= nj or lst[ni][nj] != 0:
            dr = (dr + 1) % 4
            continue
 
        i, j = ni, nj
        cnt += 1
     
    print(f'#{test_case}')
    for i in range(N):
        print(*lst[i])

Sum

for test_case in range(1,11):
    input()
    lst = [list(map(int,input().split())) for _ in range(100)]
    
    sum = [0]*202
    for i in range(100): 
        sum[200] += lst[i][i]       # 대각선1
        sum[201] += lst[i][99-i]    # 대각선2
        for j in range(100):
            sum[i] += lst[i][j]     # 가로
            sum[i+100] += lst[j][i] # 세로

    print(f'#{test_case} {max(sum)}')

전기 버스

T = int(input())
 
# K = 한번 충전으로 최대한 이동할 수 있는 정류장 수
# 0번 정류장부터 N번 정류장까지
# M = 충전기가 설치된 정류장 수
 
for test_case in range(1, T+1):
    K, N, M = list(map(int, input().split()))
    charge_station = list(map(int, input().split())) # 충전기가 설치된 정류장 번호들
 
    cnt = 0
    current = 0
     
    while current + K < N:
        found_station = False
        for i in range(K, 0, -1):
            if current + i in charge_station:
                current += i
                cnt += 1
                found_station = True
                break
             
        if found_station == False:
            cnt = 0
            break
         

ladder1

for test_case in range(1, 11):
    tc = int(input())
    arr = [list(map(int, input().split())) for _ in range(100)]
    i, j = 99, arr[99].index(2)
    path = [[0] * 100 for _ in range(100)]
 
    while i != 0:
        path[i][j] = 1
        if j - 1 >= 0 and arr[i][j-1] and path[i][j-1] == 0:
            j -= 1
            continue
        elif j + 1 <= 99 and arr[i][j+1] and path[i][j+1] == 0:
            j += 1
            continue
        else:
            i -= 1
 
        result = j
 
    print(f'#{tc} {result}')

ladder2

T = 10
for _ in range(T):
    tc = int(input())
    N = 100
    ladder = [list(map(int, input().split())) for _ in range(N)]
 
    mn = float('inf')
    result = 0
    for i in range(N):
        if ladder[0][i] == 1:  #시작지점 찾기
            x, y = 0, i
            cnt = 0
            while x < 99:
                x += 1
                cnt += 1
                if y > 0 and ladder[x][y-1] == 1:
                    while y > 0 and ladder[x][y-1] == 1:
                        y -= 1
                        cnt += 1
                elif y < 99 and ladder[x][y+1] == 1:
                    while y < 99 and ladder[x][y+1] == 1:
                        y += 1
                        cnt += 1
 
            if mn > cnt:
                mn = cnt
                result = i
 
    print(f'#{tc} {result}')

영준이의 카드 카운팅

for tc in range(1, int(input())+1):
    card = input()
    check = []
    card_set = {'S': 13, 'D': 13, 'H': 13, 'C': 13}
 
    for i in range(0, len(card), 3):
        check.append(card[i:i+3])
 
    if len(check) != len(set(check)):
        print(f'#{tc} ERROR')
 
    else:
        for i in range(0, len(card)-2, 3):
            num = card_set[card[i]] - 1
            card_set[card[i]] = num
 
        print(f'#{tc}', end=' ')
        print(*card_set.values())

숫자배열 회전

T = int(input())
for test_case in range(1, T+1):
    N = int(input())
    lst = [list(map(int, input().split())) for _ in range(N)]
  
    lst_90 = [[0]*N for _ in range(N)]
    lst_180 = [[0] * N for _ in range(N)]
    lst_270 = [[0] * N for _ in range(N)]
  
    for i in range(N):
        for j in range(N):
            lst_90[i][j] = lst[N-1-j][i]
  
    for i in range(N):
        for j in range(N):
            lst_180[i][j] = lst_90[N-1-j][i]
  
    for i in range(N):
        for j in range(N):
            lst_270[i][j] = lst_180[N-1-j][i]
  
    print(f'#{test_case} ')
    for i in range(N):
        for x in range(N):
            print(lst_90[i][x], end='')
        print(end=' ')
        for y in range(N):
            print(lst_180[i][y], end='')
        print(end=' ')
        for z in range(N):
            print(lst_270[i][z], end='')
        print()

회문2

import sys
sys.stdin = open('input.txt', 'r')

def palindrome(m, arr):
    for i in range(100):
        for j in range(0, 100-m+1):
            if arr[i][j] == arr[i][j+m-1]:
                for k in range(1, m//2):
                    if arr[i][j+k] != arr[i][j+m-1-k]:
                        break
                else:
                    return True

        for j in range(0, 100-m+1):
            if arr[j][i] == arr[j+m-1][i]:
                for k in range(1, m//2):
                    if arr[j+k][i] != arr[j+m-1-k][i]:
                        break
                else:
                    return True

    return False

T = 10
for _ in range(T):
    tc = int(input())
    arr = [list(input()) for _ in range(100)]

    for m in range(100, -1, -1):
        if palindrome(m, arr):
            print(f'#{tc} {m}')
            break

수의 새로운 연산

dct = {}
r_dct = {}
i, j = 1, 1
for n in range(1, 50000):
    dct[n] = (i, j)
    r_dct[(i, j)] = n
    i, j = i-1, j+1
    if i < 1:
        i, j = j, 1

T = int(input())
for tc in range(1, T+1):
    p, q = map(int, input().split())

    pi, pj = dct[p] # 1. p, q값의 좌표로 변환
    qi, qj = dct[q]

    ans = r_dct[(pi+qi, pj+qj)] # 2. 좌표를 값으로 변환
    print(f'#{tc} {ans}')

러시아 국기같은 깃발

#3중 for문을 어떻게 쓸까 ??!?!
T = int(input())
for tc in range(1, T+1):
    n, m = map(int, input().split())
    arr = [list(input()) for _ in range(n)]

    mn = n * m

    cnt = 0
    for w in range(0, n-2): #white
        for i in range(0, m):
            if arr[w][i] != 'W':
                cnt += 1

        cnt2 = 0
        for b in range(w+1, n-1): #blue
            for i in range(0, m):
                if arr[b][i] != 'B':
                    cnt2 += 1

            cnt3 = 0
            for r in range(b+1, n): #red
                for i in range(0, m):
                    if arr[r][i] != 'R':
                        cnt3 += 1

            total = cnt + cnt2 + cnt3

            if mn > total:
                mn = total

    print(f'#{tc} {mn}')

[백준]
2798 블랙잭

N, M = map(int, input().split())
card_input = list(input().split())

sum = 0

sum_lst = []

for i in range(N):
    for j in range(N):
        for k in range(N):
            if i != j and j != k and i != k:
                sum_lst.append(int(card_input[i]) + int(card_input[j]) + int(card_input[k]))

possible_num_lst = []

for i in set(sum_lst):
    if i <= M:
        possible_num_lst.append(i)

print(max(possible_num_lst))

2309 일곱난쟁이

arr = []

for i in range(9):
    arr.append(int(input()))

arr.sort() #정렬
sum = sum(arr)

ans_lst = []
for i in range(len(arr)):
    for j in range(i+1, len(arr)):
        if sum - arr[i] - arr[j] == 100:
            for k in range(len(arr)):
                if k == i or k == j:
                    continue
                else:
                    print(arr[k])

            exit()

2563 색종이

arr = [[0] * 1001 for _ in range(1001)]
N = int(input())

for a in range(1, N+1):
    x, y, w, h = map(int, input().split())

    for i in range(x, x+w):
        for j in range(y, y+h):
            arr[i][j] = a


for s in range(1, N+1):
    cnt = 0
    for i in range(1001):
        for j in range(1001):
            if arr[i][j] == s:
                cnt += 1

    print(cnt)

2567 색종이2

paper = int(input())
arr = [[0] * 102 for _ in range(102)]

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

for _ in range(paper):
    left, under = map(int, input().split())
    for i in range(left, left+10):
        for j in range(under, under+10):
            arr[i][j] = 1

cnt = 0
for i in range(1, 101):
    for j in range(1, 101):
        if arr[i][j] == 1:
            for dir in range(4):
                nx = i + dx[dir]
                ny = j + dy[dir]
                if arr[nx][ny] == 0:
                    cnt += 1

print(cnt)

8320 직사각형을 만드는 방법

n = int(input())
result = 0
for i in range(1, n+1):
    for j in range(i, n//i+1):
        result += 1

print(result)

2628 종이 자르기

hor, ver = map(int, input().split())
hor = [0, hor] #[0, 10]
ver = [0, ver] #[0, 8]

cut = int(input())
for _ in range(cut):
    dir, num = map(int, input().split())

    if dir == 0: #가로로 자르기
        ver.append(num)
    elif dir == 1: #세로로 자르기
        hor.append(num)

hor.sort()
ver.sort()

ans = 0

for i in range(len(hor)-1):
    for j in range(len(ver)-1):
        ans = max(ans, (ver[j+1] - ver[j]) * (hor[i+1] - hor[i]))

print(ans)

2605 줄 세우기

N = int(input())
orders = list(map(int, input().split()))

stack = []
tmp = []

stack.append(1)
for n in range(2, N+1):
    for _ in range(orders[n-1]):
        tmp.append(stack.pop())
    stack.append(n)
    while tmp:
        stack.append(tmp.pop())

print(*stack)

10431 줄세우기

P = int(input())

for _ in range(P):
    height = list(map(int, input().split()))
    stack = []
    cnt = 0

    for i in range(1, len(height)-1):
        stack.append(height[i])
        stack.sort()
        if stack[-1] > height[i+1]:
            for j in stack:
                if height[i+1] < j:
                    cnt += 1

    print(height[0], cnt)

3985 롤 케이크

L = int(input()) #롤케이크 길이
N = int(input()) #방청객 수

rollcake = [0] * (L+1)
lst = []
for i in range(1, N+1):
    p, k = map(int, input().split())
    lst.append(k+1-p)
    for j in range(p, k+1):
        if rollcake[j] == 0:
            rollcake[j] = i

lst2 = []
for i in range(1, N+1):
    c = rollcake.count(i)
    lst2.append(c)

print(lst.index(max(lst)) + 1) #가장 많은 조각을 받을 것으로 기대하고 있던 방청객 번호
print(lst2.index(max(lst2)) + 1) #실제로 가장 많은 조각을 받은 방청객 번호

10157 자리 배정

C, R = map(int, input().split()) #공연장의 격자 크기
K = int(input()) #대기번호

hall = [[0] * C for _ in range(R)]

#위-오른쪽-아래-왼쪽
dx = [-1,0,1,0]
dy = [0,1,0,-1]

cnt = 1
k = 0

sx = R-1
sy = 0
hall[sx][sy] = 1

while True:
    #기저조건
    if cnt == C * R:
        break

    nx = sx + dx[k]
    ny = sy + dy[k]

    if 0 <= nx < R and 0 <= ny < C and hall[nx][ny] == 0:
        cnt += 1
        hall[nx][ny] = cnt
        sx = nx
        sy = ny

    else:
        k += 1
        if k >= 4:
            k = k % 4

for i in range(R):
    for j in range(C):
        if hall[i][j] == K:
            print(j+1, R-i)

if K > C * R:
    print(0)

2578 빙고

bingo = [list(map(int, input().split())) for _ in range(5)]
nums = [list(map(int, input().split())) for _ in range(5)]
cnt = 0

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

def check_bingo(bingo):
    result = 0
    for i in range(5):
        for j in range(5):
            if bingo[i][j] == 0:
                for dir in range(4):
                    ni = i
                    nj = j
                    cnt = 0

                    while 0 <= ni < 5 and 0 <= nj < 5 and bingo[ni][nj] == 0:
                        cnt += 1
                        ni += dx[dir]
                        nj += dy[dir]

                    if cnt == 5:
                        result += 1

    if result >= 3:
        return True
    else:
        return False


for i in range(5):
    for j in range(5):
        num = nums[i][j]
        for x in range(5):
            for y in range(5):
                if num == bingo[x][y]:
                    bingo[x][y] = 0
                    cnt += 1
                    if check_bingo(bingo):
                        print(cnt)
                        exit()

10709 기상 캐스터

H, W = map(int, input().split())
weather = [input() for _ in range(H)]

for a in weather:
    lst = [-1 for _ in range(W)]
    for i in range(W):
        if a[i] == 'c':
            lst[i] = 0
    tmp = 0
    for i in range(1, W):
        if lst[i] == 0:
            tmp = 0
        if lst[i - 1] != -1:
            if lst[i] != 0:
                tmp += 1
                lst[i] = tmp
    print(*lst)

2980 도로와 신호등

n , l = map(int,input().split()) #신호등 개수, 도로의 길이

now = 0
total = 0
for _ in range(n):
    d, r, g = map(int,input().split()) #위치, 빨간불, 초록불
    total += d - now
    now = d
    if total % (r + g) <= r :
        total += r - total % (r + g)

total += l - now
print(total)

2839 설탕 배달

N = int(input())

if N % 5 == 0: # N이 5의 배수인 경우
    print(N // 5)

else:
    cnt = 0
    while N > 0:
        N -= 3
        cnt += 1

        if N % 5 == 0: # 5kg, 3kg 조합해서 담을 수 있는 경우
            cnt += N // 5
            print(cnt)
            break

        elif N == 1 or N == 2: # 5kg, 3kg로 나눌 수 없는 경우
            print(-1)
            break

        elif N == 0: # N이 3의 배수인 경우
            print(cnt)
            break

1063 킹

king, stone, move_num = input().split()

move = {'R':(0,1), 'L':(0,-1), 'B':(1,0), 'T':(-1,0), 'RT':(-1,1), 'LT':(-1,-1), 'RB':(1,1), 'LB':(1,-1)}
chess = ['A','B','C','D','E','F','G','H'] #가로 위치값
kx, ky = (8-int(king[1])), chess.index(king[0])
sx, sy = (8-int(stone[1])), chess.index(stone[0])

for _ in range(int(move_num)):
    command = input()
    x, y = move[command]
    if 0 <= kx + x < 8 and 0 <= ky + y < 8:
        kx, ky = kx + x, ky + y
        if kx == sx and ky == sy:
            sx, sy = sx + x, sy + y

    if not (0 <= sx < 8 and 0 <= sy < 8):
        kx, ky = kx - x, ky - y
        sx, sy = sx - x, sy - y

print(chess[ky], 8-kx, sep='')
print(chess[sy], 8-sx, sep='')

3085 사탕 게임

def cnt_mx():
    row_cnt = col_cnt = 1
    row_max = col_max = 0

    for i in range(N):
        for j in range(N-1):
            if arr[i][j] == arr[i][j+1]:
                row_cnt += 1
            else:
                row_cnt = 1
            row_max = max(row_cnt, row_max)
        row_cnt = 1

    for j in range(N):
        for i in range(N-1):
            if arr[i][j] == arr[i+1][j]:
                col_cnt += 1
            else:
                col_cnt = 1
            col_max = max(col_cnt, col_max)
        col_cnt = 1

    ans = max(row_max, col_max)
    return ans

N = int(input())
arr = [list(input()) for _ in range(N)]

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

result = 0
for i in range(N):
    for j in range(N):
        for dir in range(4):
            nx = i + dx[dir]
            ny = j + dy[dir]
            if not (0 <= nx < N and 0 <= ny < N):
                break
            if arr[i][j] != arr[nx][ny]:
                arr[i][j], arr[nx][ny] = arr[nx][ny], arr[i][j]
                result = max(result, cnt_mx())
                arr[i][j], arr[nx][ny] = arr[nx][ny], arr[i][j]

print(result)

2559 수열

import sys
input = sys.stdin.readline

N, K = map(int, input().split())
temp_lst = list(map(int, input().split()))

sum_lst = []
sum_lst.append(sum(temp_lst[:K]))

for i in range(N-K):
    sum_lst.append(sum_lst[i] - temp_lst[i] + temp_lst[K+i])

print(max(sum_lst))

2304 창고 다각형

n = int(input())

lst = []
for _ in range(n):
    l, h = map(int, input().split())
    lst.append([l,h])

lst.sort()

total = 0
c = 0
for a in lst:
    if a[1] > total:
        total = a[1]
        idx = c #최대 기둥 높이의 인덱스
    c += 1

#앞에서부터 최대 기둥까지
hgt = lst[0][1]

for i in range(idx):
    if hgt < lst[i+1][1]:
        total += hgt * (lst[i+1][0] - lst[i][0])
        hgt = lst[i+1][1]
    else:
        total += hgt * (lst[i+1][0] - lst[i][0])

#뒤에서부터 최대 기둥까지
hgt = lst[-1][1]

for i in range(n-1, idx, -1):
    if hgt < lst[i-1][1]:
        total += hgt * (lst[i][0] - lst[i-1][0])
        hgt = lst[i-1][1]
    else:
        total += hgt * (lst[i][0] - lst[i-1][0])

print(total)

2527 직사각형

for _ in range(4):
    si1, sj1, ei1, ej1, si2, sj2, ei2, ej2 = map(int, input().split())

    if si1 > ei2 or ei1 < si2 or sj1 > ej2 or ej1 < sj2: #공통부분 x
        ans = 'd'

    elif ej1 == sj2 or sj1 == ej2:
        if ei1 == si2 or si1 == ei2: #세로 일치 & 가로 일치
            ans = 'c'
        else: #세로 일치 & 가로 불일치
            ans = 'b'

    elif ei1 == si2 or si1 == ei2: #세로 불일치 & 가로 일치
        ans = 'b'

    else:
        ans = 'a'

    print(ans)