대학원생이 쉽게 설명해보기

for i in range(int(input())):
    q = input()
    arr_len = int(input())
    if(arr_len == 0):
        input_arr = input()
        input_arr = []
    else:
        input_arr = list(map(int, input()[1:-1].split(',')))
    is_reverse = False
    is_ok = True
    front = 0
    rear = 0
    
    for act in q:
        try:
            if(act == 'R'):
                is_reverse = not is_reverse
            elif(act == 'D' and not is_reverse):
                front += 1
            elif(act == 'D' and is_reverse):
                rear += 1
        except:
            is_ok = False
            print('error')
            break

    if(is_ok):
        if(front + rear <= arr_len):
            if(not is_reverse):
                input_arr = input_arr[front:arr_len - rear]
                print(str(input_arr).replace(' ', ''))
            else:
                input_arr = input_arr[::-1][rear:arr_len - front]
                print(str(input_arr).replace(' ', ''))
        else:
            print('error')

런타임에러가 계속 뜨거나 틀렸습니다에서 헤어나지 못하는 분들은 밑의 사이트를 참조하세요.

https://www.acmicpc.net/board/view/25456

# 각 원소를 delete하는 과정에서 pop을 사용하면
# 리스트 전체에 변화를 주게 되므로 시간초과가 뜨게 될 겁니다.

import sys

# N, M = map(int, sys.stdin.readline().split())
N, M = map(int, input().split())
elements = [x for x in range(1, N + 1)]
# position = list(map(int, sys.stdin.readline().split()))
position = list(map(int, input().split()))
count = 0

for i in range(len(position)):
    left = 0
    right = 0
    memory = [0] * len(elements)
    
    if(elements[0] == position[i]):
        del elements[0]
    else:
        for j in range(len(elements)):
            memory[j] = elements[j]
        
        # 오른쪽으로 옮기는 경우
        while memory[0] != position[i]:
            memory.insert(0, memory[-1])
            del memory[-1]
            right += 1
            
        # 왼쪽으로 옮기는 경우
        while elements[0] != position[i]:
            elements.append(elements[0])
            del elements[0]
            left += 1
            
        if(right >= left):
            count = count + left
        else:
            count = count + right
            elements = memory
            
        del elements[0]
sys.stdout.write(str(count))

import sys

class Deque:
    def __init__(self):
        self.arr = list()
        
    def push_front(self, x):
        self.arr.insert(0, x)
    
    def push_back(self, x):
        self.arr.append(x)
    
    def pop_front(self):
        if(self.empty()):
            return -1
        else:
            return self.arr.pop(0)
        
    def pop_back(self):
        if(self.empty()):
            return -1
        else:
            return self.arr.pop()
        
    def front(self):
        if(self.empty()):
            return -1
        else:
            return self.arr[0]
        
    def back(self):
        if(self.empty()):
            return -1
        else:
            return self.arr[-1]
        
    def empty(self):
        return 1 if self.size() == 0 else 0
    
    def size(self):
        return len(self.arr)
    
N = int(sys.stdin.readline())
deque = Deque()

for _ in range(N):
    input_split = sys.stdin.readline().split()
    
    order = input_split[0]
    
    if(order == 'push_front'):
        deque.push_front(int(input_split[1]))
    elif(order == 'push_back'):
        deque.push_back(int(input_split[1]))
    elif(order == 'pop_front'):
        print(deque.pop_front())
    elif(order == 'pop_back'):
        print(deque.pop_back())
    elif(order == 'front'):
        print(deque.front())
    elif(order == 'back'):
        print(deque.back())
    elif(order == 'empty'):
        print(deque.empty())
    elif(order == 'size'):
        print(deque.size())

# python3로 제출할 시에 1158번에서는 시간초과입니다.
# pypy3로 제출해야 시간초과가 뜨지 않습니다.

import sys
 
class Queue(): 
    def __init__(self, size):
        self.maxSize = size
        self.size = 0
        self.arr = ['']*size
        self.front = -1
        self.rear = -1
 
    def enqueue(self, data):
        if not self.isFull():
            self.rear = (self.rear+1) % self.maxSize
            self.arr[self.rear] = data
            self.size += 1
 
    def dequeue(self):
        if not self.isEmpty():
            self.front = (self.front + 1) % self.maxSize
            self.size -= 1
            return self.arr[self.front]
 
    def isEmpty(self):
        return self.size == 0
 
    def isFull(self):
        return self.size == self.maxSize
 
    def __bool__(self):
        return self.isEmpty()
    
N, K = map(int, sys.stdin.readline().strip().split())
# N, K = map(int, input().split())
people = Queue(N)
 
for i in range(1, N+1):
    people.enqueue(str(i))

result = '<'
 
while not people.isEmpty():
    for i in range(K-1):
            people.enqueue(people.dequeue())
    result += str(people.dequeue())
    if not people.isEmpty():
        result += ', '
    else:
        result += '>'
sys.stdout.write(result)

Case = int(input())

def priority_print(queue, M, print_count):
    priority = max(queue.values())
    
    for key, item in queue.items():
        if(priority == item):
            if(M == key):
                return print_count
            else:
                queue.pop(key)
                return priority_print(queue, M, print_count + 1)
        else:
            cur_key = key
            cur_item = item
            queue.pop(cur_key)
            queue.update({cur_key: cur_item})
            return priority_print(queue, M, print_count)

for _ in range(Case):
    # N : 문서의 수 
    # M : 몇번째로 인쇄될지 궁금한 문서의 위치
    N, M = map(int, input().split())
    
    if(N == 1):
        dummy = input()
        print(1)
        continue
    
    num_list = map(int, input().split())
    
    queue = dict()
    for i, num in enumerate(num_list):
        queue[i] = num
        
    print(priority_print(queue, M, 1))