C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Linq;
using System.Collections.Generic;

interface IStackCollection
{
    void push_back(int num);
    int pop_back();
    int back();
    int size();
    void clear();
}

interface IQueueCollection
{
    void push_front(int num);
    int front();
    int pop_front();
    int size();
    void clear();
}

class MyStack : IStackCollection
{
    public MyStack()
    {
    }

    private List<int> my_stack = new List<int>();

    public void push_back(int num)
    {
        my_stack.Add(num);
    }

    public int pop_back()
    {
        int last_elem = my_stack.Last();
        my_stack.RemoveAt(my_stack.Count - 1);
        return last_elem;
    }

    public int back()
    {
        return my_stack[my_stack.Count - 1];
    }

    public int size()
    {
        return my_stack.Count;
    }

    public void clear()
    {
        my_stack.Clear();
    }
}

class MyQueue : IQueueCollection
{
    public MyQueue()
    {
    }

    private List<int> my_queue = new List<int>();

    public void push_front(int num)
    {
        my_queue.Insert(0, num);
    }

    public int pop_front()
    {
        int last_elem = my_queue[0];
        my_queue.RemoveAt(my_queue[0]);
        return last_elem;
    }

    public int front()
    {
        return my_queue[0];
    }

    public int size()
    {
        return my_queue.Count;
    }

    public void clear()
    {
        my_queue.Clear();
    }
}

public class MyDeque : IStackCollection, IQueueCollection
{
    protected List<int> deq;
    private int check_back = 0;
    private int check_front = 0;

    public MyDeque()
    {
        deq = new List<int>();
    }

    public void push_back(int num)
    {
        deq.Add(num);
        check_back++;
    }
    public void push_front(int num)
    {
        deq.Insert(0, num);
        check_front++;
    }
    public int back()
    {
        if (check_back != 0)
        {
            return deq[deq.Count - 1];
        } else
        {
            throw new IndexOutOfRangeException("error");
        }
    }

    public bool TryBack(out int value)
    {
        value = 0;
        if (check_back == 0)
        {
            return false;
        }
        value = deq[deq.Count - 1];
        return true;
    }
    public bool TryFront(out int value)
    {
        value = 0;
        if (check_front == 0)
        {
            return false;
        }
        value = deq[0];
        return true;
    }
    public bool TryPopFront(out int value)
    {
        value = 0;
        if (check_front == 0)
        {
            return false;
        }
        value = deq[0];
        deq.RemoveAt(0);
        check_front--;
        return true;
    }
    public bool TryPopBack(out int value)
    {
        value = 0;
        if (check_back == 0)
        {
            return false;
        }
        value = deq[deq.Count - 1];
        deq.RemoveAt(deq.Count - 1);
        check_back--;
        return true;
    }
    public int front()
    {
        if (check_front != 0)
        {
            return deq[0];
        }
        else
        {
            throw new IndexOutOfRangeException("error");
        }
    }
    public int pop_back()
    {
        int elem;
        if (check_back != 0)
        {
            elem = deq[deq.Count - 1];
            deq.RemoveAt(deq.Count - 1);
            check_back--;
        } else
        {
            throw new IndexOutOfRangeException("error");
        }
        return elem;
    }
    public int pop_front()
    {
        int elem;
        if (check_front != 0)
        {
            elem = deq[0];
            deq.RemoveAt(0);
            check_front--;
        } else
        {
            throw new IndexOutOfRangeException("error");
        }
        return elem;
    }
    public int size()
    {
        return deq.Count;
    }
    public void clear()
    {
        deq.Clear();
        check_back = 0;
        check_front = 0;
    }
}

public class Program
{
    public static void Main()
    {
        int number = 0;
        bool flag = true;
        MyDeque deq = new MyDeque();

        while (flag)
        {
            var str = Console.ReadLine().Split(' ');
            var command = str[0];
            if (str.Length > 1)
            {
                number = Int32.Parse(str[1]);
            }

            switch (command)
            {
                case "push_back":
                    deq.push_back(number);
                    Console.WriteLine("ok");
                    break;
                case "push_front":
                    deq.push_front(number);
                    Console.WriteLine("ok");
                    break;
                case "pop_back":
                    Console.WriteLine(deq.pop_back());
                    break;
                case "pop_front":
                    Console.WriteLine(deq.pop_front());
                    break;
                case "front":
                    Console.WriteLine(deq.front());
                    break;
                case "back":
                    Console.WriteLine(deq.back());
                    break;
                case "TryBack":
                    {
                        var value = 0;
                        if (deq.TryBack(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "TryFront":
                    {
                        var value = 0;
                        if (deq.TryFront(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "TryPopFront":
                    {
                        var value = 0;
                        if (deq.TryPopFront(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "TryPopBack":
                    {
                        var value = 0;
                        if (deq.TryPopBack(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "size":
                    Console.WriteLine(deq.size());
                    break;
                case "clear":
                    deq.clear();
                    Console.WriteLine("ok");
                    break;
                case "exit":
                    Console.WriteLine("bye");
                    flag = false;
                    break;
            }
        }
    }
}

​x
 
using System;
using System.Linq;
using System.Collections.Generic;
​
interface IStackCollection
{
    void push_back(int num);
    int pop_back();
    int back();
    int size();
    void clear();
}
​
interface IQueueCollection
{
    void push_front(int num);
    int front();
    int pop_front();
    int size();
    void clear();
}
​
class MyStack : IStackCollection
{
    public MyStack()
    {
    }
​
    private List<int> my_stack = new List<int>();
​
    public void push_back(int num)
    {
        my_stack.Add(num);
    }
​
    public int pop_back()
    {
        int last_elem = my_stack.Last();
        my_stack.RemoveAt(my_stack.Count - 1);
        return last_elem;
    }
​
    public int back()
    {
        return my_stack[my_stack.Count - 1];
    }
​
    public int size()
    {
        return my_stack.Count;
    }
​
    public void clear()
    {
        my_stack.Clear();
    }
}
​
class MyQueue : IQueueCollection
{
    public MyQueue()
    {
    }
​
    private List<int> my_queue = new List<int>();
​
    public void push_front(int num)
    {
        my_queue.Insert(0, num);
    }
​
    public int pop_front()
    {
        int last_elem = my_queue[0];
        my_queue.RemoveAt(my_queue[0]);
        return last_elem;
    }
​
    public int front()
    {
        return my_queue[0];
    }
​
    public int size()
    {
        return my_queue.Count;
    }
​
    public void clear()
    {
        my_queue.Clear();
    }
}
​
public class MyDeque : IStackCollection, IQueueCollection
{
    protected List<int> deq;
    private int check_back = 0;
    private int check_front = 0;
​
    public MyDeque()
    {
        deq = new List<int>();
    }
​
    public void push_back(int num)
    {
        deq.Add(num);
        check_back++;
    }
    public void push_front(int num)
    {
        deq.Insert(0, num);
        check_front++;
    }
    public int back()
    {
        if (check_back != 0)
        {
            return deq[deq.Count - 1];
        } else
        {
            throw new IndexOutOfRangeException("error");
        }
    }
​
    public bool TryBack(out int value)
    {
        value = 0;
        if (check_back == 0)
        {
            return false;
        }
        value = deq[deq.Count - 1];
        return true;
    }
    public bool TryFront(out int value)
    {
        value = 0;
        if (check_front == 0)
        {
            return false;
        }
        value = deq[0];
        return true;
    }
    public bool TryPopFront(out int value)
    {
        value = 0;
        if (check_front == 0)
        {
            return false;
        }
        value = deq[0];
        deq.RemoveAt(0);
        check_front--;
        return true;
    }
    public bool TryPopBack(out int value)
    {
        value = 0;
        if (check_back == 0)
        {
            return false;
        }
        value = deq[deq.Count - 1];
        deq.RemoveAt(deq.Count - 1);
        check_back--;
        return true;
    }
    public int front()
    {
        if (check_front != 0)
        {
            return deq[0];
        }
        else
        {
            throw new IndexOutOfRangeException("error");
        }
    }
    public int pop_back()
    {
        int elem;
        if (check_back != 0)
        {
            elem = deq[deq.Count - 1];
            deq.RemoveAt(deq.Count - 1);
            check_back--;
        } else
        {
            throw new IndexOutOfRangeException("error");
        }
        return elem;
    }
    public int pop_front()
    {
        int elem;
        if (check_front != 0)
        {
            elem = deq[0];
            deq.RemoveAt(0);
            check_front--;
        } else
        {
            throw new IndexOutOfRangeException("error");
        }
        return elem;
    }
    public int size()
    {
        return deq.Count;
    }
    public void clear()
    {
        deq.Clear();
        check_back = 0;
        check_front = 0;
    }
}
​
public class Program
{
    public static void Main()
    {
        int number = 0;
        bool flag = true;
        MyDeque deq = new MyDeque();
​
        while (flag)
        {
            var str = Console.ReadLine().Split(' ');
            var command = str[0];
            if (str.Length > 1)
            {
                number = Int32.Parse(str[1]);
            }
​
            switch (command)
            {
                case "push_back":
                    deq.push_back(number);
                    Console.WriteLine("ok");
                    break;
                case "push_front":
                    deq.push_front(number);
                    Console.WriteLine("ok");
                    break;
                case "pop_back":
                    Console.WriteLine(deq.pop_back());
                    break;
                case "pop_front":
                    Console.WriteLine(deq.pop_front());
                    break;
                case "front":
                    Console.WriteLine(deq.front());
                    break;
                case "back":
                    Console.WriteLine(deq.back());
                    break;
                case "TryBack":
                    {
                        var value = 0;
                        if (deq.TryBack(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "TryFront":
                    {
                        var value = 0;
                        if (deq.TryFront(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "TryPopFront":
                    {
                        var value = 0;
                        if (deq.TryPopFront(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "TryPopBack":
                    {
                        var value = 0;
                        if (deq.TryPopBack(out value))
                        {
                            Console.WriteLine(value);
                        }
                        else
                        {
                            throw new IndexOutOfRangeException("error");
                        }
                        break;
                    }
                case "size":
                    Console.WriteLine(deq.size());
                    break;
                case "clear":
                    deq.clear();
                    Console.WriteLine("ok");
                    break;
                case "exit":
                    Console.WriteLine("bye");
                    flag = false;
                    break;
            }
        }
    }
}

View IL Code