RPN Generator

Author: amadejsky

ArrayStackT03_17/.idea/workspace.xml

@@ -0,0 +1,9 @@
+package inter;
+
+public class Exercise4 {
+    public static void main(String[] args) {
+        RPNGenerator rpn = new RPNGenerator(256);
+        String onp = rpn.generate("D:\\CodeProjects\\DataStructures\\DataStructuresJava\\ArrayStackT03_17\\expression01.txt");
+        System.out.println(onp);
+    }
+}

ArrayStackT03_17/Exercise4.java

@@ -0,0 +1,93 @@
+package inter;
+
+import javax.naming.OperationNotSupportedException;
+import java.util.EmptyStackException;
+import java.util.Scanner;
+import java.util.zip.DataFormatException;
+
+public class RPNCalculator
+{
+    private TArrayStack<Integer> stack;
+
+    public RPNCalculator(int stackSize)
+    {
+        stack = new TArrayStack<Integer>(stackSize > 126 ? stackSize : 256);
+    }
+
+    public int compute(String rpn) throws OperationNotSupportedException, DataFormatException{
+        Scanner sc = new Scanner(rpn);
+        int result = 0;
+        while(sc.hasNext()){
+            if(sc.hasNextInt()){
+                stack.push(sc.nextInt());
+            }else{
+                String word= sc.next();
+                char sign = word.charAt(0);
+                if(operation(sign)){
+                    executeOperation(sign);
+                }else{
+                    throw new OperationNotSupportedException();
+                }
+            }
+        }
+        if(!stack.isEmpty())
+            result = stack.pop();
+        if(!stack.isEmpty())
+            throw new DataFormatException();
+        return result;
+    }
+
+    private void executeOperation(char sign) throws OperationNotSupportedException{
+        int a1, a2;
+        if(!stack.isEmpty()){
+            a2 = stack.pop();
+        }else{
+            throw new EmptyStackException();
+        }
+        if(!stack.isEmpty()){
+            a1 = stack.pop();
+        }else{
+            throw new EmptyStackException();
+        }
+
+        switch(sign){
+            case '+':
+                stack.push(a1 + a2);
+                return;
+            case '-':
+                stack.push(a1 - a2);
+                return;
+            case '*':
+                stack.push(a1 * a2);
+                return;
+            case '/':
+                if(a2!=0)
+                stack.push(a1 / a2);
+                else
+                    throw new ArithmeticException();
+                return;
+
+            case '%':
+                if(a2!=0)
+                stack.push(a1 % a2);
+                else
+                    throw new ArithmeticException();
+                return;
+            default:
+                throw new OperationNotSupportedException();
+        }
+    }
+
+    private boolean operation(char sign)
+    {
+        switch (sign)
+        {
+            case '+':
+            case '-':
+            case '/':
+            case '%':
+            case '*': return true;
+            default: return false;
+        }
+    }
+}

ArrayStackT03_17/RPNCalculator.java

@@ -0,0 +1,112 @@
+package inter;
+
+import javax.naming.OperationNotSupportedException;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Scanner;
+import java.util.zip.DataFormatException;
+
+public class RPNGenerator {
+    private TArrayStack<Character> stack;
+    private StringBuilder str;
+
+    public RPNGenerator(int stackSize){
+        stack = new TArrayStack<Character>(stackSize > 126 ? stackSize : 256);
+        str = new StringBuilder();
+    }
+
+    public String generate(String fileName) {
+        str.setLength(0);
+        try (FileInputStream fin = new FileInputStream(fileName)) {
+            Scanner sc = new Scanner(fin);
+            while (sc.hasNext()) {
+                String word = sc.next();
+                char sign = word.charAt(0);
+                if (sign == '(') {
+                    stack.push(sign);
+                } else if (sign == ')') {
+                    removeUntillBracker();
+                    System.out.println("Stack contents: " + stack.toString()); // <-- add this line
+                    System.out.println("StringBuilder contents: " + str.toString()); // <-- add this line
+                } else if (numberOrVariable(sign)) {
+                    str.append(word).append(" ");
+                } else if (operation(sign)) {
+                    pushOperationToStack(sign);
+                    System.out.println("Stack contents: " + stack.toString()); // <-- add this line
+                    System.out.println("StringBuilder contents: " + str.toString()); // <-- add this line
+                } else {
+                    throw new DataFormatException();
+                }
+            }
+            while (!stack.isEmpty()) {
+                str.append((stack.pop())).append(" ");
+            }
+            return str.toString();
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (DataFormatException e) {
+            e.printStackTrace();
+        } catch (OperationNotSupportedException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return "err";
+    }
+
+    private void pushOperationToStack(char sign) throws OperationNotSupportedException{
+        while(!stack.isEmpty()){
+            if(priority(sign) > priority(stack.top())){
+                stack.push(sign);
+                return;
+            }else{
+                str.append(stack.pop()).append(" ");
+            }
+        }
+        stack.push(sign);
+    }
+
+    private int priority(char sign) throws OperationNotSupportedException{
+        switch(sign){
+            case '(': return 0;
+            case '+':
+            case '-':
+            case ')': return 1;
+            case '*':
+            case '/':
+            case '%': return 2;
+            default:throw new OperationNotSupportedException();
+        }
+    }
+
+    private boolean operation(char sign){
+        switch(sign){
+            case '+':
+            case '-':
+            case '/':
+            case '%':
+            case '*': return true;
+            default: return false;
+        }
+    }
+
+    private boolean numberOrVariable(char sign){
+        if(Character.isLetter(sign)||Character.isDigit(sign))
+            return true;
+        else
+            return false;
+    }
+
+    public void removeUntillBracker() throws DataFormatException{
+        while(!stack.isEmpty() ){
+            if(stack.top() == '(' ){
+                stack.pop();
+                return;
+            }else{
+                str.append(stack.pop()).append(" ");
+            }
+        }
+        throw new DataFormatException();
+    }
+}