Tag: implementation

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

ans = n - 2

# 모든 가능한 두 카드 조합 (i, j)에 대해 확인
for i in range(n):
    for j in range(i + 1, n):
        if (cards[j] - cards[i]) % (j - i) != 0:
            continue
        d = (cards[j] - cards[i]) // (j - i)
        cnt = 0
        
        for k in range(n):
            expected = cards[i] + (k - i) * d
            if cards[k] != expected:
                cnt += 1
        
        ans = min(ans, cnt)

print(ans)

D, N = map(int, input().split())
oven = list(map(int, input().split()))
doughs = list(map(int, input().split()))

min_oven = oven[0]
for i in range(1, D):
    min_oven = min(min_oven, oven[i])
    oven[i] = min(oven[i], min_oven)

oven_i = D - 1
dough_i = 0

while dough_i < N:
    if oven[oven_i] < doughs[dough_i]:
        # 못들어감
        oven_i -= 1
        if oven_i < 0:
            # 다 들어갈 수 없음
            print(0)
            break
    else:
        dough_i += 1
        oven_i -= 1

else:
    print(oven_i + 2)

n, w, L = map(int, input().split())
trucks = list(map(int, input().split()))

bridge = deque([0] * w)
t = 0
cur_w = 0
i = 0

while i < n:
    t += 1
    cur_w -= bridge.popleft()
    if cur_w + trucks[i] <= L:
        bridge.append(trucks[i])
        cur_w += trucks[i]
        i += 1
    else:
        bridge.append(0)

t += w
print(t)

field = list(map(list, [input() for _ in range(12)]))

dyx = [(1, 0), (0, 1), (-1, 0), (0, -1)]

def bfs(sy, sx):
    visited = set()
    q = [(sy, sx)]
    visited.add((sy, sx))
    while q:
        y, x = q.pop(0)
        for dy, dx in dyx:
            ny, nx = y + dy, x + dx
            if not(0 <= ny < 12 and 0 <= nx < 6):
                continue
            if (ny, nx) in visited:
                continue
            
            if field[ny][nx] == field[sy][sx]:
                visited.add((ny, nx))
                q.append((ny, nx))
    
    if len(visited) >= 4:
        for y, x in visited:
            field[y][x] = '.'
        return True
    return False

cnt = 0
while True:
    is_remove = False
    for i in range(12):
        for j in range(6):
            if field[i][j] == '.':
                continue

            if bfs(i, j):
                is_remove = True

    if not is_remove:
        break

    # 블록 내리기
    for j in range(6):
        stack = []
        for i in range(11, -1, -1):
            if field[i][j] == '.':
                continue
            
            stack.append(field[i][j])
            field[i][j] = '.'
        
        i = 11
        while stack:
            field[i][j] = stack.pop(0)
            i -= 1

    cnt += 1

print(cnt)

P = list(map(int, input().split()))
S = list(map(int, input().split()))

def shuffle_card(cards, S):
    new_cards = [0] * (N)
    for i, n_i in enumerate(S):
        new_cards[n_i] = cards[i]
    return new_cards

cards = P[:]
answer = [0, 1, 2] * (N // 3)
cnt = 0

while answer != cards:
    cards = shuffle_card(cards, S)
    cnt += 1

    if cards == P:
        print(-1)
        break

else:
    print(cnt)

sys.setrecursionlimit(10**6)

string = sys.stdin.readline().strip()
length = len(string)

visited = [False] * length

def select_char(start, end):
    if start > end:
        return

    min_char = 'Z' + '1' 
    min_idx = -1
    for i in range(start, end + 1):
        if string[i] < min_char:
            min_char = string[i]
            min_idx = i

    visited[min_idx] = True

    current_result = ""
    for i in range(length):
        if visited[i]:
            current_result += string[i]
    print(current_result)
    select_char(min_idx + 1, end)
    select_char(start, min_idx - 1)

select_char(0, length - 1)

from copy import deepcopy
class Matrix:
    def __init__(self):
        self.size, degree = map(int, input().split())
        self.rotate_n = (degree + 360) // 45
        self.matrix = [list(map(int, input().split())) for _ in range(self.size)]
        self.mid = self.size // 2

    def rotate_matrix(self):
        new_matrix = deepcopy(self.matrix)

        for _ in range(self.rotate_n):
            for i in range(self.size):
                new_matrix[i][self.mid] = self.matrix[i][i]
                new_matrix[self.size - i - 1][i] = self.matrix[self.size - i - 1][self.mid]
                new_matrix[self.mid][i] = self.matrix[self.size - i - 1][i]
                new_matrix[i][i] = self.matrix[self.mid][i]
            self.matrix = deepcopy(new_matrix)

        return new_matrix

    def print_matrix(self):
        for row in self.matrix:
            print(*row)
    

if __name__ == "__main__":
    TC = int(input())
    for _ in range(TC):
        matrix = Matrix()
        matrix.rotate_matrix()
        matrix.print_matrix()

크기가 N×M인 배열이 있을 때, 배열을 반시계 방향으로 R번 회전시키려고 한다. 배열의 회전은 각 껍질 별로 독립적으로 일어난다.

구현 문제이다. 각 껍질을 추출하고 회전시킨 후 다시 배치한다.

gear1 = list(map(int, list(input().strip())))
gear2 = list(map(int, list(input().strip())))

len1 = len(gear1)
len2 = len(gear2)

if len1 > len2:
    gear1, gear2 = gear2, gear1
    len1, len2 = len2, len1

min_total_length = len1 + len2

for start in range(-len1 + 1, len2):
    
    for i in range(len1):
        gear2_idx = start + i
        if 0 <= gear2_idx < len2:
            # 두 개의 이가 맞물리면 안됨
            if gear1[i] == 2 and gear2[gear2_idx] == 2:
                break

    else:
        current_length = max(len2, start + len1) - min(0, start)
        min_total_length = min(min_total_length, current_length)

print(min_total_length)