Problem:


Doubly Linked List

Your task is to implement a double linked list.

Write a program which performs the following operations:

insert x: insert an element with key x into the front of the list.

delete x: delete the first element which has the key of x from the list. If there is not such element, you need not do anything.

deleteFirst: delete the first element from the list. 

deleteLast: delete the last element from the list. 

Input

The input is given in the following format:

n

command1 

command2 

...

commandn 

In the first line, the number of operations n is given. In the following n lines, the above mentioned operations are given in the following format:

insert x

delete x

deleteFirst 

deleteLast 

Output

Print all the element (key) in the list after the given operations. Two consequtive keys should be separated by a single space.

Constraints

The number of operations ≤ 2,000,000

The number of delete operations ≤ 20

0 ≤ value of a key ≤ 109

The number of elements in the list does not exceed 106

For a delete, deleteFirst or deleteLast operation, there is at least one element in the list.

Sample Input 1

7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5

Sample Output 1

6 1 2

Sample Input 2

9
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
deleteFirst
deleteLast

Sample Output 2

1

Template in C
-->


Sample input:
7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5


Sample output:
6 1 2

Submission status: Time Limit Exceeded

Solution code:
#16D8104025G 佐藤智裕 mist75__ Python3

class DLL:
    class Node:
        def __init__(self, x, y, z):
            self.v = x
            self.prv = y
            self.nxt = z

    def __init__(self):
        init = DLL.Node(None, None, None)
        init.prv = init
        init.nxt = init
        self.size = 0
        self.init = init

    def insert(self, x):
        i = self.init
        j = i.nxt
        k = DLL.Node(x, i, j)
        i.nxt = k
        j.prv = k
        self.size += 1

    def deleteFirst(self):
        if self.size != 0:
            i = self.init
            k = i.nxt
            j = k.nxt
            i.nxt = j
            j.prv = i
            self.size -= 1

    def deleteLast(self):
        if self.size != 0:
            i = self.init
            k = i.prv
            j = k.prv
            i.prv = j
            j.nxt = i
            self.size -= 1

    def delete(self, x):
        if self.size != 0:
            i = self.init
            k = i.nxt
            while 1:
                if k.v == x:
                    i = k.prv
                    j = k.nxt
                    i.nxt = j
                    j.prv = i
                    self.size -= 1
                    break
                else:
                    if k.nxt == i:
                        break
                    else:
                        k = k.nxt

    def prt(self):
        f = self.init
        s = f.nxt
        l = f.prv
        while 1:
            if s != l:
                print(s.v, end=' ')
                s = s.nxt
            else:
                print(l.v)
                break

n = int(input())
L = DLL()

for i in range(n):
    com = input()
    if com == "deleteFirst":
        L.deleteFirst()
    elif com == "deleteLast":
        L.deleteLast()
    else:
        C = com.split()
        if C[0] == "insert":
            L.insert(int(C[1]))
        elif C[0] == "delete":
            L.delete(int(C[1]))
    #L.prt()
    
L.prt()

Submission status: Time Limit Exceeded

Solution code:
class DLL:
    class Node:
        def __init__(self, x, y, z):
            self.v = x
            self.prv = y
            self.nxt = z

    def __init__(self):
        init = DLL.Node(None, None, None)
        init.prv = init
        init.nxt = init
        self.size = 0
        self.init = init

    def insert(self, x):
        i = self.init
        j = i.nxt
        k = DLL.Node(x, i, j)
        i.nxt = k
        j.prv = k
        self.size += 1

    def deleteFirst(self):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        j = k.nxt
        i.nxt = j
        j.prv = i
        self.size -= 1

    def deleteLast(self):
        #if self.size != 0:
        i = self.init
        k = i.prv
        j = k.prv
        i.prv = j
        j.nxt = i
        self.size -= 1

    def delete(self, x):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        while 1:
            if k.v == x:
                i = k.prv
                j = k.nxt
                i.nxt = j
                j.prv = i
                self.size -= 1
                break
            else:
                if k.nxt == i:
                    break
                else:
                    k = k.nxt

    def prt(self):
        f = self.init
        s = f.nxt
        l = f.prv
        while 1:
            if s != l:
                print(s.v, end=' ')
                s = s.nxt
            else:
                print(l.v)
                break

n = int(input())
L = DLL()

for i in range(n):
    com = input()
    if com == "deleteFirst":
        L.deleteFirst()
    elif com == "deleteLast":
        L.deleteLast()
    else:
        C = com.split()
        if C[0] == "insert":
            L.insert(int(C[1]))
        elif C[0] == "delete":
            L.delete(int(C[1]))
    #L.prt()
    
L.prt()

Submission status: Time Limit Exceeded

Solution code:
class DLL:
    class Node:
        def __init__(self, x, y, z):
            self.v = x
            self.prv = y
            self.nxt = z

    def __init__(self):
        init = DLL.Node(None, None, None)
        init.prv = init
        init.nxt = init
        self.size = 0
        self.init = init

    def insert(self, x):
        i = self.init
        j = i.nxt
        k = DLL.Node(x, i, j)
        i.nxt = k
        j.prv = k
        self.size += 1

    def deleteFirst(self):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        j = k.nxt
        i.nxt = j
        j.prv = i
        self.size -= 1

    def deleteLast(self):
        #if self.size != 0:
        i = self.init
        k = i.prv
        j = k.prv
        i.prv = j
        j.nxt = i
        self.size -= 1

    def delete(self, x):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        while 1:
            if k.v == x:
                """
                i = k.prv
                j = k.nxt
                i.nxt = j
                j.prv = i
                """
                k.prv.nxt = k.nxt
                k.nxt.prv = k.prv
                self.size -= 1
                break
            else:
                if k.nxt == i:
                    break
                else:
                    k = k.nxt

    def prt(self):
        f = self.init
        s = f.nxt
        l = f.prv
        while 1:
            if s != l:
                print(s.v, end=' ')
                s = s.nxt
            else:
                print(l.v)
                break

n = int(input())
L = DLL()

for i in range(n):
    com = input()
    if com == "deleteFirst":
        L.deleteFirst()
    elif com == "deleteLast":
        L.deleteLast()
    else:
        C = com.split()
        if C[0] == "insert":
            L.insert(int(C[1]))
        elif C[0] == "delete":
            L.delete(int(C[1]))
    #L.prt()
    
L.prt()

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

def pr(A,n):
    for i in range(n):
        if i!=n-1:
            print(A[i],end=" ")
        else:
            print(A[i])

n=int(input())
que_r=deque()
c=0

for i in range(n):
    s=input().split()

    if s[0]=="insert":
        que_r.appendleft(int(s[1]))
    elif s[0]=="delete" and que_r.count(int(s[1]))>=1:
        que_r.remove(int(s[1]))
    elif s[0]=="deleteFirst":
        gav=que_r.popleft()
    elif s[0]=="deleteLast":
        gav=que_r.pop()

pr(que_r,len(que_r))

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

def pr(A,n):
    for i in range(n):
        if i!=n-1:
            print(A[i],end=" ")
        else:
            print(A[i])

n=int(input())
que_r=deque()

for i in range(n):
    s=input().split()

    if s[0]=="insert":
        que_r.appendleft(int(s[1]))
    elif s[0]=="delete" and que_r.count(int(s[1]))>=1:
        que_r.remove(int(s[1]))
    elif s[0]=="deleteFirst":
        gav=que_r.popleft()
    elif s[0]=="deleteLast":
        gav=que_r.pop()

pr(que_r,len(que_r))

Submission status: Time Limit Exceeded

Solution code:
class DLL:
    class Node:
        def __init__(self, x, y, z):
            self.v = x
            self.prv = y
            self.nxt = z

    def __init__(self):
        init = DLL.Node(None, None, None)
        init.prv = init
        init.nxt = init
        self.size = 0
        self.init = init

    def insert(self, x):
        i = self.init
        j = i.nxt
        k = DLL.Node(x, i, j)
        i.nxt = k
        j.prv = k
        self.size += 1

    def deleteFirst(self):
        if self.size > 1:
            i = self.init
            k = i.nxt
            j = k.nxt
            i.nxt = j
            j.prv = i
        else:
            i = self.init
            i.nxt = i
            i.prv = i

        self.size -= 1

    def deleteLast(self):
        if self.size > 1:
            i = self.init
            k = i.prv
            j = k.prv
            i.prv = j
            j.nxt = i
        else:
            i = self.init
            i.nxt = i
            i.prv = i

        self.size -= 1

    def delete(self, x):
        if self.size > 1:
            i = self.init
            k = i.nxt
            while 1:
                if k.v == x:
                    """
                    i = k.prv
                    j = k.nxt
                    i.nxt = j
                    j.prv = i
                    """
                    k.prv.nxt = k.nxt
                    k.nxt.prv = k.prv
                    self.size -= 1
                    break
                else:
                    if k.nxt == i:
                        break
                    else:
                        k = k.nxt
        else:
            i = self.init
            i.nxt = i
            i.prv = i

    def prt(self):
        f = self.init
        s = f.nxt
        l = f.prv
        while 1:
            if s != l:
                print(s.v, end=' ')
                s = s.nxt
            else:
                print(l.v)
                break

n = int(input())
L = DLL()

for i in range(n):
    com = input()
    if com == "deleteFirst":
        L.deleteFirst()
    elif com == "deleteLast":
        L.deleteLast()
    else:
        C = com.split()
        if C[0] == "insert":
            L.insert(int(C[1]))
        elif C[0] == "delete":
            L.delete(int(C[1]))
    #L.prt()
    
L.prt()

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

def pr(A,n):
    for i in range(n):
        if i!=n-1:
            print(A[i],end=" ")
        else:
            print(A[i])

n=int(input())
que_r=deque()

for i in range(n):
    s=input().split()

    if s[0]=="insert":
        que_r.appendleft(int(s[1]))
    elif s[0]=="delete":
        try:
            que_r.remove(int(s[1]))
        except: pass
    elif s[0]=="deleteFirst":
        gav=que_r.popleft()
    elif s[0]=="deleteLast":
        gav=que_r.pop()

pr(que_r,len(que_r))

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

def pr(A,n):
    for i in range(n):
        if i!=n-1:
            print(A[i],end=" ")
        else:
            print(A[i])

n=int(input())
que_r=deque()

for i in range(n):
    s=input().split()

    if s[0]=="insert":
        que_r.appendleft(int(s[1]))
    elif s[0]=="delete":
        try:
            que_r.remove(int(s[1]))
        except ValueError: pass
    elif s[0]=="deleteFirst":
        gav=que_r.popleft()
    elif s[0]=="deleteLast":
        gav=que_r.pop()

pr(que_r,len(que_r))

Submission status: Time Limit Exceeded

Solution code:
def pr(data,next,head,tail):
    i = head
    while(1):
        if i == -1:
            print("")
            break
        print(data[i],end = "")
        i = next[i]
        if i != -1 :
            print(" ",end = "")

def ins_f(data,next,prev,x,head,tail):
    size = len(data)
    if head != -1 :
        data.append(x)
        size += 1
        next.append(head)
        prev.append(-1)
        prev[head] = size -1
        head = size -1
    else :
        data.append(x)
        size += 1
        next.append(-1)
        prev.append(-1)
        tail = size-1
        head = size-1
    return head,tail

def dl(data,next,prev,x,head,tail):
    i = head
    while(1):
        if data[i] == x:
            if i == head:
                head,tail = dl_f(next,prev,head,tail)
                break
            elif i == tail:
                head,tail = dl_l(next,prev,head,tail)
                break
            else :
                prev[next[i]] = prev[i]
                next[prev[i]] = next[i]
                break
        elif i == tail:
            break
        i = next[i]
    return head,tail

def dl_f(next,prev,head,tail):
    if head == -1:
        return head
    elif next[head] == -1:
        head = -1
        tail = -1
    else:
        prev[next[head]] = -1
        head = next[head]
    return head,tail

def dl_l(next,prev,head,tail):
    if tail == -1:
        pass
    elif prev[tail] == -1:
        head = -1
        tail = -1
    else:
        next[prev[tail]] = -1
        tail = prev[tail]
    return head,tail

n = int(input())
data = []
next = []
prev = []
head = -1
tail = -1
size = len(data)

for i in range(n):
    x = input().split()
    if x[0] == "insert":
        head,tail = ins_f(data,next,prev,x[1],head,tail)
    elif x[0] == "delete":
        head,tail = dl(data,next,prev,x[1],head,tail)
    elif x[0] == "deleteFirst":
        head,tail = dl_f(next,prev,head,tail)
    elif x[0] == "deleteLast":
        head,tail = dl_l(next,prev,head,tail)
pr(data,next,head,tail)

Submission status: Time Limit Exceeded

Solution code:
def pr(data,next,head,tail):
    i = head
    while(1):
        if i == -1:
            print("")
            break
        print(data[i],end = "")
        i = next[i]
        if i != -1 :
            print(" ",end = "")

def ins_f(data,next,prev,x,head,tail):
    size = len(data)
    if head != -1 :
        data.append(x)
        size += 1
        next.append(head)
        prev.append(-1)
        prev[head] = size -1
        head = size -1
    else :
        data.append(x)
        size += 1
        next.append(-1)
        prev.append(-1)
        tail = size-1
        head = size-1
    return head,tail

def dl(data,next,prev,x,head,tail):
    i = head
    while(1):
        if data[i] == x:
            if i == head:
                head,tail = dl_f(next,prev,head,tail)
                break
            elif i == tail:
                head,tail = dl_l(next,prev,head,tail)
                break
            else :
                prev[next[i]] = prev[i]
                next[prev[i]] = next[i]
                break
        elif i == tail:
            break
        i = next[i]
    return head,tail

def dl_f(next,prev,head,tail):
    if head == -1:
        return head
    elif next[head] == -1:
        head = -1
        tail = -1
    else:
        prev[next[head]] = -1
        head = next[head]
    return head,tail

def dl_l(next,prev,head,tail):
    if tail == -1:
        pass
    elif prev[tail] == -1:
        head = -1
        tail = -1
    else:
        next[prev[tail]] = -1
        tail = prev[tail]
    return head,tail

n = int(input())
data = []
next = []
prev = []
head = -1
tail = -1
size = len(data)

for i in range(n):
    x = input()
    l = len(x)
    if x[0] == "i":
        head,tail = ins_f(data,next,prev,x[7:],head,tail)
    elif x[6] == " ":
        head,tail = dl(data,next,prev,x[7:],head,tail)
    elif l > 10:
        head,tail = dl_f(next,prev,head,tail)
    elif l > 6:
        head,tail = dl_l(next,prev,head,tail)
pr(data,next,head,tail)

Submission status: Time Limit Exceeded

Solution code:
def pr(a):
    for i in range(len(a)):
        if i == len(a)-1:
            print(a[i])
        else:
            print(a[i],end = " ")

n = int(input())
a = []
for i in range(n):
    x = input()
    l = len(x)
    if x[0] == "i":
        a.insert(0,x[7:])
    elif x[6] == " ":
        try:
            a.remove(x[7:])
        except:
            pass
    elif l > 10:
        a.pop(0)
    elif l > 6:
        a.pop()

pr(a)

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

def pr(a):
    for i in range(len(a)):
        if i == len(a)-1:
            print(a[i])
        else:
            print(a[i],end = " ")

n = int(input())
q = deque()
for i in range(n):
    x = input()
    l = len(x)
    if x[0] == "i":
        q.insert(0,x[7:])
    elif x[6] == " ":
        try:
            q.remove(x[7:])
        except:
            pass
    elif l > 10:
        q.popleft()
    elif l > 6:
        q.pop()

pr(q)

Submission status: Time Limit Exceeded

Solution code:
class DLL:
    class Node:
        def __init__(self, x, y, z):
            self.v = x
            self.prv = y
            self.nxt = z

    def __init__(self):
        init = DLL.Node(None, None, None)
        init.prv = init
        init.nxt = init
        self.size = 0
        self.init = init

    def insert(self, x):
        i = self.init
        j = i.nxt
        k = DLL.Node(x, i, j)
        i.nxt = k
        j.prv = k
        self.size += 1

    def deleteFirst(self):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        j = k.nxt
        i.nxt = j
        j.prv = i
        self.size -= 1

    def deleteLast(self):
        #if self.size != 0:
        i = self.init
        k = i.prv
        j = k.prv
        i.prv = j
        j.nxt = i
        self.size -= 1

    def delete(self, x):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        while 1:
            if k.v == x:
                i = k.prv
                j = k.nxt
                i.nxt = j
                j.prv = i
                self.size -= 1
                break
            else:
                if k.nxt == i:
                    break
                else:
                    k = k.nxt

    def prt(self):
        f = self.init
        s = f.nxt
        l = f.prv
        while 1:
            if s != l:
                print(s.v, end=' ')
                s = s.nxt
            else:
                print(l.v)
                break

n = int(input())
L = DLL()

for i in range(n):
    """
    com = input()
    if com[0] == "deleteFirst":
        L.deleteFirst()
    elif com == "deleteLast":
        L.deleteLast()
    else:
        C = com.split()
        if C[0] == "insert":
            L.insert(int(C[1]))
        elif C[0] == "delete":
            L.delete(int(C[1]))
    #L.prt()
    """

    com = input()
    if com[0] == "i":
        C = com.split()
        L.insert(int(C[1]))
    else:
        if com[6] == "F":
            L.deleteFirst()
        elif com[6] == "L":
            L.deleteLast()
        else:
            C = com.split()
            L.delete(int(C[1]))
L.prt()

Submission status: Time Limit Exceeded

Solution code:
from collections import deque


n = int(input())
L = deque()

for i in range(n):
    com = input()
    if com[0] == 'i':
        C = com.split()
        L.appendleft(int(C[1]))
    else:
        if com[6] == 'F':
            L.popleft()
        elif com[6] == 'L':
            L.pop()
        else:
            C = com.split()
            x = int(C[1])
            if L.count(x) > 0:
                L.remove(x)

for i in range(len(L)-1):
    print(L[i], end=' ')
print(L.pop())

Submission status: Time Limit Exceeded

Solution code:
from collections import deque


n = int(input())
L = deque()

for i in range(n):
    com = input()
    if com[0] == 'i':
        C = com.split()
        L.appendleft(int(C[1]))
    else:
        if com[6] == 'F':
            L.popleft()
        elif com[6] == 'L':
            L.pop()
        else:
            C = com.split()
            x = int(C[1])
            if L.count(x) > 0:
                L.remove(x)

print(*L)

Submission status: Time Limit Exceeded

Solution code:
class DLL:
    class Node:
        def __init__(self, x, y, z):
            self.v = x
            self.prv = y
            self.nxt = z

    def __init__(self):
        init = DLL.Node(None, None, None)
        init.prv = init
        init.nxt = init
        #self.size = 0
        self.init = init

    def insert(self, x):
        i = self.init
        j = i.nxt
        k = DLL.Node(x, i, j)
        i.nxt = k
        j.prv = k
       # self.size += 1

    def deleteFirst(self):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        j = k.nxt
        i.nxt = j
        j.prv = i
       # self.size -= 1

    def deleteLast(self):
        #if self.size != 0:
        i = self.init
        k = i.prv
        j = k.prv
        i.prv = j
        j.nxt = i
        #self.size -= 1

    def delete(self, x):
        #if self.size != 0:
        i = self.init
        k = i.nxt
        while 1:
            if k.v == x:
                i = k.prv
                j = k.nxt
                i.nxt = j
                j.prv = i
                #self.size -= 1
                break
            else:
                if k.nxt == i:
                    break
                else:
                    k = k.nxt

    def getlist(self):
        f = self.init
        s = f.nxt
        l = f.prv
        lt = []
        while 1:
            if s != l:
                lt.append(s.v)
                s = s.nxt
            else:
                lt.append(l.v)
                break

        return lt


n = int(input())
L = DLL()

for i in range(n):
    """
    com = input()
    if com[0] == "deleteFirst":
        L.deleteFirst()
    elif com == "deleteLast":
        L.deleteLast()
    else:
        C = com.split()
        if C[0] == "insert":
            L.insert(int(C[1]))
        elif C[0] == "delete":
            L.delete(int(C[1]))
    #L.prt()
    """

    com = input()
    if com[0] == "i":
        C = com.split()
        L.insert(int(C[1]))
    else:
        if com[6] == "F":
            L.deleteFirst()
        elif com[6] == "L":
            L.deleteLast()
        else:
            C = com.split()
            L.delete(int(C[1]))

print(*L.getlist())

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

n = int(input())
L = deque()

for i in range(n):
    com = input()
    l = len(com)
    if com[0] == 'i':
        C = com.split()
        L.appendleft(int(C[1]))
    elif com[6] == " ":
        C = com.split()
        x = int(C[1])
        try:
            L.remove(x)
        except:
            pass
    elif l > 10:
        L.popleft()
    else:
        L.pop()

print(*L)

Submission status: Time Limit Exceeded

Solution code:
lst=[]

n=int(input())
for i in range(n):
    ts=[x for x in input().split()]
    t=ts[0]
    if t=='insert' or t=='delete':
        s=int(ts[1]) 
        
    if t=='insert':
        lst.insert(0,s)
    elif t=='delete':
        try:
            lst.remove(s)      
        except ValueError:
            pass
        
    elif t=='deleteFirst':
        lst.pop(0)
    elif t=='deleteLast':
        lst.pop(-1)
            
for i in range(0,len(lst)):
    if i!=len(lst)-1:
        print(lst[i],end=' ')
    else: 
        print(lst[i])

Submission status: Time Limit Exceeded

Solution code:
from collections import deque
 
lst=[]
rs=deque()

n=int(input())

for i in range(n):
    e=[x for x in input().split()]
    lst.append(e)

   
for ts in lst:
    t=ts[0]
    if len(t)==6:   # t=='insert' or t=='delete':
        s=int(ts[1]) 
        if t[0]=='i': #t='insert':
            rs.appendleft(s)
        else:
            # t='delete':
            if s in rs:
                rs.remove(s)      
            
    elif t[6]=='F':  #t=deleteFirst':
        if len(rs)>0:
            rs.popleft()
 
    elif t[6]=='L': #'deleteLast':
        if len(rs)>0:
            rs.pop()

lens=len(rs)           
if lens!=0:
    for i in range(0,lens-1):
        print(rs[i],end=' ')
    print(rs[lens-1])

Submission status: Time Limit Exceeded

Solution code:
n = int(input())

linked_list = []

for _ in range(n):
    command = input()

    if "insert" in command:
        x = command.split()[-1]
        linked_list.insert(0, x)
    elif command == "deleteFirst":
        del linked_list[0]
    elif command == "deleteLast":
        del linked_list[-1]
    elif "delete" in command:
        x = command.split()[-1]
        if x in linked_list:
            del linked_list[linked_list.index(x)]

print(*linked_list)

Submission status: Time Limit Exceeded

Solution code:
n = int(input())
output = []
for i in range(n):
    li = input().split(' ')
    if(li[0] == 'insert'):
        output.insert(0, int(li[1]))
    elif(li[0] == 'delete'):
        if(int(li[1]) in output):
            output.remove(int(li[1]))
    elif(li[0] == 'deleteFirst'):
        del output[0]
    elif(li[0] == 'deleteLast'):
        del output[-1]
str_l = [str(o) for o in output]
print(' '.join(str_l))

Submission status: Time Limit Exceeded

Solution code:
n = int(input())
output = []
for i in range(n):
    li = input().split(' ')
    if(li[0] == 'insert'):
        output[0:0] = [int(li[1])]
        #output.insert(0, int(li[1]))
    elif(li[0] == 'delete'):
        if(int(li[1]) in output):
            output.remove(int(li[1]))
    elif(li[0] == 'deleteFirst'):
        del output[0]
    elif(li[0] == 'deleteLast'):
        del output[-1]
str_l = [str(o) for o in output]
print(' '.join(str_l))

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

n = int(input())
output = deque()
for i in range(n):
    li = input().split(' ')
    if(li[0] == 'insert'):
        output.appendleft(int(li[1]))
    elif(li[0] == 'delete'):
        if(int(li[1]) in output):
            output.remove(int(li[1]))
    elif(li[0] == 'deleteFirst'):
        output.popleft()
    elif(li[0] == 'deleteLast'):
        output.pop()
str_l = [str(o) for o in output]
print(' '.join(str_l))

Submission status: Time Limit Exceeded

Solution code:
from collections import deque

n = int(input())
output = deque()
for i in range(n):
    li = input().split(' ')
    if(li[0] == 'insert'):
        output.appendleft(int(li[1]))
    elif(li[0] == 'delete'):
        try:
            output.remove(int(li[1]))
        except:
            pass
    elif(li[0] == 'deleteFirst'):
        output.popleft()
    elif(li[0] == 'deleteLast'):
        output.pop()
str_l = [str(o) for o in output]
print(' '.join(str_l))

Submission status: Time Limit Exceeded

Solution code:
class Node():
    def __init__(self,  key=None, prev=None, next=None):
        self.key = key
        self.prev = prev
        self.next = next


class DoublyLinkedList():
    def __init__(self):
        head = Node()
        head.next = head
        head.prev = head
        self.size = 0
        self.head = head

    def insert(self, x):
        node = Node(key=x, prev=self.head, next=self.head.next)
        self.head.next.prev = node
        self.head.next = node
        self.size += 1

    def delete(self, x):
        node = self.head.next
        while node is not self.head:
            if node.key == x:
                node.prev.next = node.next
                node.next.prev = node.prev
                self.size -= 1
                break
            node = node.next

    def deleteFirst(self):
        self.head.next.next.prev = self.head
        self.head.next = self.head.next.next
        self.size -= 1

    def deleteLast(self):
        self.head.prev.prev.next = self.head
        self.head.prev = self.head.prev.prev
        self.size -= 1

    def getKeys(self):
        node = self.head.next
        keys = []
        while node is not self.head:
            keys.append(str(node.key))
            node = node.next
        return " ".join(keys)


L = DoublyLinkedList()
n = int(input())
for i in range(n):
    inputs = input().split()
    if len(inputs) == 1:
        command = inputs[0]
    else:
        command = inputs[0]
        key = inputs[1]
    if command == "insert":
        L.insert(int(key))
    elif command == "delete":
        L.delete(int(key))
    elif command == "deleteFirst":
        L.deleteFirst()
    else:
        L.deleteLast()

print(L.getKeys())

Submission status: Time Limit Exceeded

Solution code:
from sys import stdin


class Node():
    def __init__(self,  key=None, prev=None, next=None):
        self.key = key
        self.prev = prev
        self.next = next


class DoublyLinkedList():
    def __init__(self):
        head = Node()
        head.next = head
        head.prev = head
        self.size = 0
        self.head = head

    def insert(self, x):
        node = Node(key=x, prev=self.head, next=self.head.next)
        self.head.next.prev = node
        self.head.next = node
        self.size += 1

    def delete(self, x):
        node = self.head.next
        while node is not self.head:
            if node.key == x:
                node.prev.next = node.next
                node.next.prev = node.prev
                self.size -= 1
                break
            node = node.next

    def deleteFirst(self):
        self.head.next.next.prev = self.head
        self.head.next = self.head.next.next
        self.size -= 1

    def deleteLast(self):
        self.head.prev.prev.next = self.head
        self.head.prev = self.head.prev.prev
        self.size -= 1

    def getKeys(self):
        node = self.head.next
        keys = []
        while node is not self.head:
            keys.append(str(node.key))
            node = node.next
        return " ".join(keys)


L = DoublyLinkedList()
n = int(input())
for i in range(n):
    command = stdin.readline().strip().split()
    if command[0] == "insert":
        L.insert(int(command[1]))
    elif command[0] == "delete":
        L.delete(int(command[1]))
    elif command[0] == "deleteFirst":
        L.deleteFirst()
    else:
        L.deleteLast()

print(L.getKeys())