14891 - 톱니바퀴

• K = 1 : 3번 톱니바퀴를 반시계 방향으로 회전 : 3번 톱니바퀴를 기준으로 연두색 칸은 오른쪽, 주황색 칸은 왼쪽

1. 3번 톱니바퀴 기준으로 오른쪽 확인(4번 톱니바퀴) : N(0), S(1)으로 시계방향으로 회전 가능
2. 3번 톱니바퀴 기준으로 왼쪽 확인(2번 톱니바퀴) : S(1), S(1)으로 회전 불가능
3. 2번 톱니바퀴가 회전하지 않으므로, 1번 톱니바퀴도 회전하지 않음

즉, 3번과 4번 톱니바퀴만 반시계, 시계 방향으로 회전

• K = 2 : 1번 톱니바퀴를 시계 방향으로 회전 : 1번 톱니바퀴를 기준으로 노란색 칸이 오른쪽, 왼쪽은 없음

1. 1번 톱니바퀴를 기준으로 오른쪽 확인(2번 톱니바퀴) : S(1), N(0)으로 반시계방향으로 회전 가능
2. 2번 톱니바퀴가 회전하였으므로 3번 톱니바퀴도 회전 가능 : S(1), N(0)으로 시계방향으로 회전 가능
3. 3번 톱니바퀴가 회전하였으므로 4번 톱니바퀴도 회전 가능 : N(0), N(0)으로 회전 불가능

결과

1. 회전시킬 톱니바퀴를 기준으로 좌우 회전 가능 여부 확인
2. 회전 가능한 좌우 톱니바퀴 기준으로 우 또는 좌 톱니바퀴도 연쇄적으로 회전 가능한지 확인

import copy

# 기준 톱니바퀴를 기준으로 양옆으로 회전 가능한 톱니바퀴인지 탐색
def Chkrotate(wheelList, rotateNum, rotateDirection):
    visited = [False] * 4
    visited[rotateNum] = True
    direction =[0]*4
    direction[rotateNum] = rotateDirection
    copyWheelList = copy.deepcopy(wheelList)
    # 오른쪽 탐색
    if rotateNum == 0 or rotateNum == 1 or rotateNum == 2:
        visited[rotateNum + 1] = True
        if copyWheelList[rotateNum][2] != copyWheelList[rotateNum+1][6]:
            direction[rotateNum+1] = -direction[rotateNum]

    # 왼쪽 탐색
    if rotateNum == 3 or rotateNum == 1 or rotateNum == 2:
        visited[rotateNum - 1] = True
        if copyWheelList[rotateNum][6] != copyWheelList[rotateNum-1][2]:
            direction[rotateNum-1] = -direction[rotateNum]

    # [False, True, True, True] : 1유형 (3)
    # [False, False, True, True] : 2유형 (4)
    # [True, True, False, False] : 3유형 (1)
    # [True, True, True, False] : 4유형 (2)
    if visited[0] == False and visited[1] == False:
        idx = 1
        while False in visited:
            visited[idx] = True
            if copyWheelList[idx][2] != copyWheelList[idx+1][6]:
                    direction[idx] = -direction[idx+1]
                    idx -= 1
            else: break
    elif visited[0] == False and visited.count(False) == 1:
        if copyWheelList[0][2] != copyWheelList[1][6]:
            direction[0] = -direction[1]
    elif visited[2] == False and visited[3] == False:
        idx = 2
        while False in visited:
            visited[idx] = True
            if copyWheelList[idx][6] != copyWheelList[idx - 1][2]:
                direction[idx] = -direction[idx - 1]
                idx += 1
            else:break
    elif visited[3] == False and visited.count(False) == 1:
        if copyWheelList[2][2] != copyWheelList[3][6]:
            direction[3] = -direction[2]

    return direction

def rotate(direction, wheelList):
    copyWheelList = copy.deepcopy(wheelList)
    for idx, ro in enumerate(direction):
        # 시계방향
        if ro == 1:
            endNum = copyWheelList[idx].pop(-1)
            copyWheelList[idx].insert(0, endNum)
        elif ro == -1:
            startNum = copyWheelList[idx].pop(0)
            copyWheelList[idx].append(startNum)
    return copyWheelList

def getScore(wheelList):
    score = 0
    for i in range(4):
        if wheelList[i][0] == 1:
            score += pow(2, i)
    return score

# N = 0, S = 1
# 인 경우, 시계방향, -1인 경우 반시계 방향
wheelList = []
for _ in range(4):
    wheelList.append(list(map(int, input())))

m = int(input())
numAnsDirection = []
for _ in range(m):
    numAnsDirection.append(list(map(int, input().split())))

for i in range(m):
    rotateNum = numAnsDirection[i][0]-1
    rotateDirection = numAnsDirection[i][1]
    directionList = Chkrotate(wheelList, rotateNum, rotateDirection)
    wheelList = rotate(directionList, wheelList)

print(getScore(wheelList))

재귀함수로 풀수 있다고 하는데... 톱니바퀴가 4개 뿐이라 유형 분류하기 쉽고, 직관적이다 보니 위와 같이 풀이를 했다.

논리적 오류보다는 복붙하는 과정에서 발생하는 코드 오류가 많은데 이 부분은 개선해야할 것 같다.