Latkoski

Топчиња

Jan 17th, 2016
91
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 7.32 KB | None | 0 0
  1. package topcinja;
  2.  
  3.  
  4. import java.util.NoSuchElementException;
  5. import java.io.BufferedReader;
  6. import java.io.IOException;
  7. import java.io.InputStreamReader;
  8. import java.util.LinkedList;
  9. import java.util.List;
  10.  
  11. interface Queue<E> {
  12.  
  13.     // Elementi na redicata se objekti od proizvolen tip.
  14.  
  15.     // Metodi za pristap:
  16.  
  17.     public boolean isEmpty ();
  18.         // Vrakja true ako i samo ako redicata e prazena.
  19.  
  20.     public int size ();
  21.         // Ja vrakja dolzinata na redicata.
  22.  
  23.     public E peek ();
  24.         // Go vrakja elementot na vrvot t.e. pocetokot od redicata.
  25.  
  26.     // Metodi za transformacija:
  27.  
  28.     public void clear ();
  29.         // Ja prazni redicata.
  30.  
  31.     public void enqueue (E x);
  32.         // Go dodava x na kraj od redicata.
  33.  
  34.     public E dequeue ();
  35.         // Go otstranuva i vrakja pochetniot element na redicata.
  36.  
  37. };
  38.  
  39. interface Stack<E> {
  40.  
  41.     // Elementi na stekot se objekti od proizvolen tip.
  42.  
  43.     // Metodi za pristap:
  44.  
  45.     public boolean isEmpty ();
  46.         // Vrakja true ako i samo ako stekot e prazen.
  47.  
  48.     public E peek ();
  49.         // Go vrakja elementot na vrvot od stekot.
  50.  
  51.     // Metodi za transformacija:
  52.  
  53.     public void clear ();
  54.         // Go prazni stekot.
  55.  
  56.     public void push (E x);
  57.         // Go dodava x na vrvot na stekot.
  58.  
  59.     public E pop ();
  60.         // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
  61. };
  62.  
  63. class ArrayQueue<E> implements Queue<E> {
  64.  
  65.     // Redicata e pretstavena na sledniot nacin:
  66.     // length go sodrzi brojot na elementi.
  67.     // Ako length > 0, togash elementite na redicata se zachuvani vo elems[front...rear-1]
  68.     // Ako rear > front, togash vo  elems[front...maxlength-1] i elems[0...rear-1]
  69.     E[] elems;
  70.     int length, front, rear;
  71.  
  72.     @SuppressWarnings("unchecked")
  73.     public ArrayQueue (int maxlength) {
  74.         elems = (E[]) new Object[maxlength];
  75.         clear();
  76.     }
  77.  
  78.     public boolean isEmpty () {
  79.         // Vrakja true ako i samo ako redicata e prazena.
  80.         return (length == 0);
  81.     }
  82.  
  83.     public int size () {
  84.         // Ja vrakja dolzinata na redicata.
  85.         return length;
  86.     }
  87.  
  88.     public E peek () {
  89.         // Go vrakja elementot na vrvot t.e. pocetokot od redicata.
  90.         if (length > 0)
  91.             return elems[front];
  92.         else
  93.             throw new NoSuchElementException();
  94.     }
  95.  
  96.     public void clear () {
  97.         // Ja prazni redicata.
  98.         length = 0;
  99.         front = rear = 0;  // arbitrary
  100.     }
  101.  
  102.     public void enqueue (E x) {
  103.         // Go dodava x na kraj od redicata.
  104.         elems[rear++] = x;
  105.         if (rear == elems.length)  rear = 0;
  106.         length++;
  107.     }
  108.  
  109.     public E dequeue () {
  110.         // Go otstranuva i vrakja pochetniot element na redicata.
  111.         if (length > 0) {
  112.             E frontmost = elems[front];
  113.             elems[front++] = null;
  114.             if (front == elems.length)  front = 0;
  115.             length--;
  116.             return frontmost;
  117.         } else
  118.             throw new NoSuchElementException();
  119.     }
  120. };
  121.  
  122. class ArrayStack<E> implements Stack<E> {
  123.  
  124.     // Stekot e pretstaven na sledniot nacin:
  125.     //depth e dlabochinata na stekot, a
  126.     // elems[0...depth-1] se negovite elementi.
  127.     private E[] elems;
  128.     private int depth;
  129.  
  130.     @SuppressWarnings("unchecked")
  131.     public ArrayStack (int maxDepth) {
  132.         // Konstrukcija na nov, prazen stek.
  133.         elems = (E[]) new Object[maxDepth];
  134.         depth = 0;
  135.     }
  136.  
  137.  
  138.     public boolean isEmpty () {
  139.         // Vrakja true ako i samo ako stekot e prazen.
  140.         return (depth == 0);
  141.     }
  142.  
  143.  
  144.     public E peek () {
  145.         // Go vrakja elementot na vrvot od stekot.
  146.         if (depth == 0)
  147.             throw new NoSuchElementException();
  148.         return elems[depth-1];
  149.     }
  150.  
  151.  
  152.     public void clear () {
  153.         // Go prazni stekot.
  154.         for (int i = 0; i < depth; i++)  elems[i] = null;
  155.         depth = 0;
  156.     }
  157.  
  158.  
  159.     public void push (E x) {
  160.         // Go dodava x na vrvot na stekot.
  161.         elems[depth++] = x;
  162.     }
  163.  
  164.  
  165.     public E pop () {
  166.         // Go otstranuva i vrakja elementot shto e na vrvot na stekot.
  167.         if (depth == 0)
  168.             throw new NoSuchElementException();
  169.         E topmost = elems[--depth];
  170.         elems[depth] = null;
  171.         return topmost;
  172.     }
  173. };
  174.  
  175. public class topcinja {
  176.     public static void main(String[] args) throws IOException
  177.     {
  178.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  179.         String niza_topcinja = br.readLine();
  180.         int brojac = 0;
  181.         String[] niza_topcinja_podeleni = niza_topcinja.split(" ");
  182.         ArrayStack<String> stack = new ArrayStack<String>(100);
  183.         for(int i = 0 ; i < niza_topcinja_podeleni.length; i++)
  184.         {
  185.            
  186.             if(niza_topcinja_podeleni[i].equals("R+"))
  187.             {
  188.                 stack.push(niza_topcinja_podeleni[i]);
  189.                 for(int j = i ; j < niza_topcinja_podeleni.length ; j++)
  190.                 {
  191.                    
  192.                     if(niza_topcinja_podeleni[j].equals("R-"))
  193.                         {
  194.                         niza_topcinja_podeleni[j] = "";
  195.                         if(stack.isEmpty()==false)
  196.                             stack.pop();
  197.                         }
  198.                    
  199.                    
  200.                 }
  201.             }
  202.             else if(niza_topcinja_podeleni[i].equals("R-"))
  203.             {
  204.                 stack.push(niza_topcinja_podeleni[i]);
  205.                 for(int j = i ; j < niza_topcinja_podeleni.length;j++)
  206.                 {
  207.                     if(niza_topcinja_podeleni[j].equals("R+"))
  208.                         {
  209.                         niza_topcinja_podeleni[j] = "";
  210.                         if(stack.isEmpty()==false)
  211.                         stack.pop();
  212.                        
  213.                        
  214.                         }
  215.                    
  216.                    
  217.                 }
  218.             }
  219.             else if(niza_topcinja_podeleni[i].equals("G+"))
  220.             {
  221.                 stack.push(niza_topcinja_podeleni[i]);
  222.                 for(int j = i ; j < niza_topcinja_podeleni.length ; j++)
  223.                 {
  224.                    
  225.                     if(niza_topcinja_podeleni[j].equals("G-"))
  226.                         {
  227.                         niza_topcinja_podeleni[j] = "";
  228.                         if(stack.isEmpty()==false)
  229.                             stack.pop();
  230.                         }
  231.                    
  232.                    
  233.                 }
  234.             }
  235.             else if(niza_topcinja_podeleni[i].equals("G-"))
  236.             {
  237.                 stack.push(niza_topcinja_podeleni[i]);
  238.                 for(int j = i ; j < niza_topcinja_podeleni.length;j++)
  239.                 {
  240.                     if(niza_topcinja_podeleni[j].equals("G+"))
  241.                         {
  242.                         niza_topcinja_podeleni[j] = "";
  243.                         if(stack.isEmpty()==false)
  244.                         stack.pop();
  245.                        
  246.                        
  247.                         }
  248.                    
  249.    
  250.                 }
  251.             }
  252.             if(niza_topcinja_podeleni[i].equals("B+"))
  253.             {
  254.                 stack.push(niza_topcinja_podeleni[i]);
  255.                 for(int j = i ; j < niza_topcinja_podeleni.length;j++)
  256.                 {
  257.                     if(niza_topcinja_podeleni[j].equals("B-"))
  258.                         {
  259.                         niza_topcinja_podeleni[j] = "";
  260.                         if(stack.isEmpty()==false)
  261.                         stack.pop();
  262.                        
  263.                        
  264.                         }
  265.                    
  266.                 }
  267.             }
  268.             if(niza_topcinja_podeleni[i].equals("B-"))
  269.             {
  270.                
  271.                 stack.push(niza_topcinja_podeleni[i]);
  272.                 for(int j = i ; j < niza_topcinja_podeleni.length;j++)
  273.                 {
  274.                     if(niza_topcinja_podeleni[j].equals("B+"))
  275.                         {
  276.                         niza_topcinja_podeleni[j] = "";
  277.                         if(stack.isEmpty()==false)
  278.                         stack.pop();
  279.                        
  280.                         }
  281.                 }
  282.             }
  283.             else
  284.                 i++;
  285.         }
  286.        
  287.         while(stack.isEmpty()==false)
  288.         {
  289.             brojac++;
  290.             String tmp = stack.pop();
  291.        
  292.                 if(tmp.equals("R-"))
  293.                     System.out.print("R+" + " ");
  294.                 else if(tmp.equals("R+"))
  295.                     System.out.print("R-" + " ");
  296.                 else if(tmp.equals("G+"))
  297.                     System.out.print("G-" + " ");
  298.                 else if(tmp.equals("G-"))
  299.                     System.out.print("G+" + " ");
  300.                 else if(tmp.equals("B+"))
  301.                     System.out.print("B-" + " ");
  302.                 else if(tmp.equals("B-"))
  303.                     System.out.print("B+" + " ");
  304.         }
  305.         System.out.println("");
  306.         System.out.println(brojac);
  307.     }
  308. }
Advertisement
Add Comment
Please, Sign In to add comment