태야

<내 코드>

N, M, x, y, K = map(int, input().split())
maps = [list(map(int, input().split())) for _ in range(N)]
op = list(map(int, input().split()))
dice = [0]*7

# 항상 주사위 6번면이 위에 오도록 설정
def move(op):
    if op == 1:
        dice[1], dice[3], dice[4], dice[6] = dice[3], dice[6], dice[1], dice[4]
    elif op == 2:
        dice[1], dice[3], dice[4], dice[6] = dice[4], dice[1], dice[6], dice[3]
    elif op == 3:
        dice[1], dice[2], dice[5], dice[6] = dice[2], dice[6], dice[1], dice[5]
    elif op == 4:
        dice[1], dice[2], dice[5], dice[6] = dice[5], dice[1], dice[6], dice[2]

# 명령에 따라 지도에서 주사위 이동
def direction(op):
    if op == 1:
        return (0, 1)
    elif op == 2:
        return (0, -1)
    elif op == 3:
        return (-1, 0)
    elif op == 4:
        return (1, 0)


for i in op:
    row, col = direction(i)

    if 0 <= x+row < N and 0 <= y+col < M:
        x += row
        y += col
        move(i)
		# 해당 지도 좌표의 값이 0인지 판단
        if maps[x][y] != 0:
            # 바닥면이 지도의 값이 된다
            dice[1] = maps[x][y]
            maps[x][y] = 0
        else:
            # 지도의 값이 주사위 바닥면 값이 된다
            maps[x][y] = dice[1]
        print(dice[6])

특별한 알고리즘이 필요없는 문제다. 구현, 시뮬레이션 문제인데 이런 유형을 많이 풀어보지 않아 쉽지 않았다.

주사위 6번 면이 항상 위로 오도록 규칙을 정해 문제를 그대로 구현하면 되는 문제였다.

<내 코드>

n = int(input())
cnt = 0
for _ in range(n):
    s = input()
    done = [s[0]]
    for i in range(1, len(s)):
        if (s[i] != s[i-1] or s[i] == s[i-1]) and s[i] not in done:
            done.append(s[i])
        elif s[i] != s[i-1] and s[i] in done:
            done.append(-1)
            break
    if -1 not in done:
        cnt += 1

print(cnt)

<내 코드>

s = input()
alpha = ["c=", "c-", "dz=", "d-", "lj", "nj", "s=", "z="]

for i in alpha:
    s = s.replace(i, '*')

print(len(s))

str.replace(바뀌게 될 문자열, 바꿀 문자열)처럼 사용해서 문자열 안의 특정한 값을 다른 값으로 치환해 준다.

<내 코드>

s = input().lower()

words = list(set(s))
arr = []
for i in words:
    arr.append(s.count(i))

if arr.count(max(arr)) >= 2:
    print('?')
else:
    print(words[arr.index(max(arr))].upper())

<내 코드>

T = int(input())
for _ in range(T):
    R, S = input().split()
    R = int(R)
    result = ""
    for i in range(len(S)):
        result += S[i] * R
    print(result)

<내 코드>

T = int(input())
for _ in range(T):
    case = input()
    cnt = 0
    for i in case:
        if i == '(':
            cnt += 1
        elif i == ')':
            cnt -= 1

        if cnt < 0:
            print("NO")
            break
    if cnt == 0:
        print("YES")
    elif cnt > 0:
        print("NO")

<내 코드>

N, M = map(int, input().split())
A = [list(map(int, list(input()))) for _ in range(N)]
B = [list(map(int, list(input()))) for _ in range(N)]

cnt = 0

def check():
    for i in range(N):
        for j in range(M):
            if A[i][j] != B[i][j]:
                return False
    return True


def solve(x, y):
    for i in range(x, x+3):
        for j in range(y, y+3):
            A[i][j] = 1 - A[i][j]  # 뒤집기

# 3*3 행렬의 왼쪽 상단 지점을 기준으로 삼는다.
for i in range(0, N-2):  # 0 ~ N-3
    for j in range(0, M-2):  # 0 ~ M-3
        if A[i][j] != B[i][j]:
            cnt += 1
            solve(i, j)

if check():
    print(cnt)
else:
    print(-1)

1. 3x3매트릭스의 특성을 고려하면 x의 범위는 [0, N-2]이고 y의 범위는 [0, M-2]이다.

2. [i][j]를 하나씩 늘려가며, 뒤지기 연산을 호출한다.

3. 마지막에는 A행렬과 B행렬이 같은지를 확인하고 같다면 solve() 호출 횟수를, 다르다면 -1을 반환한다.

(0,0) (N-1,0), (0, M-1), (N-1,M-1)의 값을 결정할 수 있는 부분 행렬은 딱 1개밖에 존재하지 않는다.

왼쪽 위 부터 오른쪽으로 하나씩 비교해가면서 다음 줄로 넘어가며 비교한다. 즉 3 x 3 행렬의 왼쪽 상단 점을 기준으로 A와 B가 같은지 비교하며 뒤집어 나간다. 한 번 지나간 기준점은 더 이상 바뀔 일이 없게 되며 이후 비교에 영향을 주지 않는다.

<내 코드>

N = int(input())
nums = list(map(int, input().split()))
nums.sort()

sum_num = 0

for i in range(N):
    if sum_num + 1 >= nums[i]:
        sum_num += nums[i]
    else:
        break
print(sum_num + 1)

1. 입력 값 오름차순 정렬

2. 다음에 등장하는 숫자가 (누적합 + 1) 이하라면 누적합 + 1까지의 숫자들은 기존의 숫자들의 조합으로 모두 표현 가능하다.

3. 하지만, 다음에 등장하는 숫자가 (누적합 + 2) 이상이라면 기존의 숫자들의 조합으로 (누적합 + 1) 표현이 불가능하므로 (누적합 + 1)을 출력해준다. 

생각지도 못한 문제 해결 방법이었다..그리디 문제를 조금 더 다양하게 풀어봐야겠다.