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

Solution in JAVA (judge verdict: Wrong Answer)

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;

import java.util.Scanner;

public class Main {
    private static Scanner sc = new Scanner(System.in);
    public static void main(String[] args) {
        LinkedList<Integer> list = new LinkedList<>();
        int n = sc.nextInt();
        
        for (int i = 0; i < n; i++) {
            String s = sc.next();
            switch (s) {
                case "insert":
                    list.insert(sc.nextInt());
                    break;
                case "delete":
                    list.delete(sc.nextInt());
                    break;
                case "deleteFirst":
                    list.deleteFirst();
                    break;
                case "deleteLast":
                    list.deleteLast();
                    break;
            }
        }
        list.show();
    }
}

class LinkedList<T> {
    Node<T> head;
    Node<T> tail;
    
    public void insert(T t) {
        Node<T> n = new Node<>(t);
        if (head != null) {
            n.next = head;
            head.prev = n;
        }
        if (tail == null) {
            tail = n;
        }
        head = n;
    }
    
    public void delete(T t) {
        Node<T> n = head;
        while (n != null) {
            if (n.getElem() == t) {
                if (n.prev != null) {
                    n.prev.next = n.next;
                } else {
                    head = n.next;
                }
                if (n.next != null) {
                    n.next.prev = n.prev;
                } else {
                    tail = n.prev;
                }
                break;
            }
            n = n.next;
        }
    }
    
    public void deleteFirst() {
        if (head != null) {
            Node<T> next = head.next;
            if (next != null) next.prev = null;
            head = next;
        }
    }

    public void deleteLast() {
        if (tail != null) {
            Node<T> prev = tail.prev;
            if (prev != null) prev.next = null;
            tail = prev;
        }
    }

    public boolean isEmpty() {
        return head == null && tail == null;
    }

    public void show() {
        Node<T> n = head;
        StringBuilder sb = new StringBuilder();
        while (n != null) {
            sb.append(n.getElem()).append(" ");
            n = n.next;
        }
        sb.delete(sb.length()-1, sb.length());
        System.out.println(sb);
    }
}

class Node<T> {
    T elem;
    Node<T> prev;
    Node<T> next;
    public Node(T t) { elem = t; }
    public T getElem() { return elem; }
}

class Pair<K, V> {
    K k;
    V v;
    public K getKey() { return k; }
    public void setKey(K k) { this.k = k; }
    public V getValue() { return v; }
    public void setValue(V v) { this.v = v; }
    public Pair(K k, V v) {
        this.k = k;
        this.v = v;
    }
}