The A-Team: Поништување на топчиња

import java.util.NoSuchElementException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.List;

interface Queue<E> {

    // Elementi na redicata se objekti od proizvolen tip.

    // Metodi za pristap:

    public boolean isEmpty ();
        // Vrakja true ako i samo ako redicata e prazena.

    public int size ();
        // Ja vrakja dolzinata na redicata.

    public E peek ();
        // Go vrakja elementot na vrvot t.e. pocetokot od redicata.

    // Metodi za transformacija:

    public void clear ();
        // Ja prazni redicata.

    public void enqueue (E x);
        // Go dodava x na kraj od redicata.

    public E dequeue ();
        // Go otstranuva i vrakja pochetniot element na redicata.

};

interface Stack<E> {

    // Elementi na stekot se objekti od proizvolen tip.

    // Metodi za pristap:

    public boolean isEmpty ();
        // Vrakja true ako i samo ako stekot e prazen.

    public E peek ();
        // Go vrakja elementot na vrvot od stekot.

    // Metodi za transformacija:

    public void clear ();
        // Go prazni stekot.

    public void push (E x);
        // Go dodava x na vrvot na stekot.

    public E pop ();
        // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
};

class ArrayQueue<E> implements Queue<E> {

    // Redicata e pretstavena na sledniot nacin:
    // length go sodrzi brojot na elementi.
    // Ako length > 0, togash elementite na redicata se zachuvani vo elems[front...rear-1]
    // Ako rear > front, togash vo  elems[front...maxlength-1] i elems[0...rear-1]
    E[] elems;
    int length, front, rear;

    @SuppressWarnings("unchecked")
    public ArrayQueue (int maxlength) {
        elems = (E[]) new Object[maxlength];
        clear();
    }

    public boolean isEmpty () {
        // Vrakja true ako i samo ako redicata e prazena.
        return (length == 0);
    }

    public int size () {
        // Ja vrakja dolzinata na redicata.
        return length;
    }

    public E peek () {
        // Go vrakja elementot na vrvot t.e. pocetokot od redicata.
        if (length > 0)
            return elems[front];
        else
            throw new NoSuchElementException();
    }

    public void clear () {
        // Ja prazni redicata.
        length = 0;
        front = rear = 0;  // arbitrary
    }

    public void enqueue (E x) {
        // Go dodava x na kraj od redicata.
        elems[rear++] = x;
        if (rear == elems.length)  rear = 0;
        length++;
    }

    public E dequeue () {
        // Go otstranuva i vrakja pochetniot element na redicata.
        if (length > 0) {
            E frontmost = elems[front];
            elems[front++] = null;
            if (front == elems.length)  front = 0;
            length--;
            return frontmost;
        } else
            throw new NoSuchElementException();
    }
};

class ArrayStack<E> implements Stack<E> {

    // Stekot e pretstaven na sledniot nacin:
    //depth e dlabochinata na stekot, a
    // elems[0...depth-1] se negovite elementi.
    private E[] elems;
    private int depth;

    @SuppressWarnings("unchecked")
    public ArrayStack (int maxDepth) {
        // Konstrukcija na nov, prazen stek.
        elems = (E[]) new Object[maxDepth];
        depth = 0;
    }


    public boolean isEmpty () {
        // Vrakja true ako i samo ako stekot e prazen.
        return (depth == 0);
    }


    public E peek () {
        // Go vrakja elementot na vrvot od stekot.
        if (depth == 0)
            throw new NoSuchElementException();
        return elems[depth-1];
    }


    public void clear () {
        // Go prazni stekot.
        for (int i = 0; i < depth; i++)  elems[i] = null;
        depth = 0;
    }


    public void push (E x) {
        // Go dodava x na vrvot na stekot.
        elems[depth++] = x;
    }


    public E pop () {
        // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
        if (depth == 0)
            throw new NoSuchElementException();
        E topmost = elems[--depth];
        elems[depth] = null;
        return topmost;
    }
};

/*

Поништување топчиња Задача 1
Да се напише алгоритам со кој ќе се имплементира играта “Поништување топчиња”. Во оваа игра на располагање
имате топчиња во три различни бои (R-црвена, G-зелена и B-сина), обележани со знакот + или -.
Поништување на топчиња може да настане само доколку тие се од иста боја и со спротивен знак.
На почеток се генерира една случајна листа со топчиња. Ваша задача е од тој влез, како доаѓаат
топчињата да направите поништување и да кажете колку, од каков тип (+ или -) и од која боја
фалат за да се поништат сите топчиња од влезот.

Влез: Листа од случајни топчиња и тоа во облик: боја, знак

Име на класата (Java): Topcinja

Делумно решение: Задачата се смета за делумно решена доколку се поминати 5 тест примери.
Забелешка: При реализација на задачите МОРА да се користат дадените структури,
а не да се користат помошни структури како низи или сл.

Пример влез: R+ G- G+ G+ R+ B- B+ R- G+ R- B- B+ B+ R+
Парови кои може да се формираат од овој список се: (R+,R-); (B+, B-); (B- B+); (R+, R-); (G-, G+); (R+, R-)
Остануваат без партнер: G+, G+, B+, R+
Излез:

4
R- G- G- B-

*/


public class Topcinja {

    public static void main (String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String vlez[] = new String[100];
        vlez = br.readLine().split(" ");

        ArrayStack<String> rStack = new ArrayStack<>(100);
        ArrayStack<String> gStack = new ArrayStack<>(100);
        ArrayStack<String> bStack = new ArrayStack<>(100);


        for(int i=0;i<vlez.length;i++){
            String segasenVlez = vlez[i];

            if(segasenVlez.equals("R+")){
                if(rStack.isEmpty()){
                    rStack.push(segasenVlez);
                }
                else{
                    String gorenElement = rStack.peek();
                    if(gorenElement.equals("R-")){
                        rStack.pop();
                    }
                    else{
                        rStack.push(segasenVlez);
                    }
                }
            }
            else if(segasenVlez.equals("R-")){
                if(rStack.isEmpty()){
                    rStack.push(segasenVlez);
                }
                else{
                    String gorenElement = rStack.peek();
                    if(gorenElement.equals("R+")){
                        rStack.pop();
                    }
                    else{
                        rStack.push(segasenVlez);
                    }
                }
            }
            else if(segasenVlez.equals("G+")){
                if(gStack.isEmpty()){
                    gStack.push(segasenVlez);
                }
                else{
                    String gorenElement = gStack.peek();
                    if(gorenElement.equals("G-")){
                        gStack.pop();

                    }
                    else{
                        gStack.push(segasenVlez);
                    }
                }
            }
            else if(segasenVlez.equals("G-")){
                if(gStack.isEmpty()){
                    gStack.push(segasenVlez);
                }
                else{
                    String gorenElement = gStack.peek();
                    if(gorenElement.equals("G+")){
                        gStack.pop();
                    }
                    else{
                        gStack.push(segasenVlez);
                    }
                }
            }
            else if(segasenVlez.equals("B+")){
                if(bStack.isEmpty()){
                    bStack.push(segasenVlez);
                }
                else{
                    String gorenElement = bStack.peek();
                    if(gorenElement.equals("B-")){
                        bStack.pop();
                    }
                    else{
                        bStack.push(segasenVlez);
                    }
                }
            }
            else if(segasenVlez.equals("B-")){
                if(bStack.isEmpty()){
                    bStack.push(segasenVlez);
                }
                else{
                    String gorenElement = bStack.peek();
                    if(gorenElement.equals("B+")){
                        bStack.pop();
                    }
                    else{
                        bStack.push(segasenVlez);
                    }
                }
            }
        }



        if(!rStack.isEmpty()){
            while(!rStack.isEmpty()){
                String gorenElement = rStack.pop();
                if(gorenElement.equals("R+")){
                    System.out.print("R- ");
                }
                else{
                    System.out.print("R+ ");
                }
            }
        }

        if(!gStack.isEmpty()){
            while(!gStack.isEmpty()){
                String gorenElement = gStack.pop();
                if(gorenElement.equals("G+")){
                    System.out.print("G- ");
                }
                else{
                    System.out.print("G+ ");
                }
            }
        }

        if(!bStack.isEmpty()){
            while(!bStack.isEmpty()){
                String gorenElement = bStack.pop();
                if(gorenElement.equals("B+")){
                    System.out.print("B- ");
                }
                else{
                    System.out.print("B+ ");
                }
            }
        }

    }
}