回答編集履歴

コードを整理してみた

2023/02/06 19:46

投稿

jimbe

スコア12612

test CHANGED Viewed

@@ -8,168 +8,172 @@
 public class Main {
   public static void main(String[] args) {
     String[] testdata = { "1+2.5*-3", "100*50/20", "(20+30)*5", "2(3+5)/4" };
-    for(String fomula : testdata) {
+    for(String formula : testdata) {
-      RPN rpn = new RPN(fomula);
+      RPN rpn = new RPN(formula);
       System.out.println(rpn + "=" + rpn.calc());
     }
   }
   private static class RPN {
-    private enum Ope {
+    private interface Element {
-      PLS("+",1) {
-        String calc(String a, String b) {
+      void operate(Deque<String> stack);
-          return "" + (Double.parseDouble(a) + Double.parseDouble(b));
-        }
+    }
-      },
-      MIN("-",1) {
+    private static class Value implements Element {
-        String calc(String a, String b) {
+      private final String v;
-          return "" + (Double.parseDouble(a) - Double.parseDouble(b));
+      Value(String v) {
+        this.v = v;
-        }
+      }
-      },
-      MUL("*",2) {
+      @Override
-        String calc(String a, String b) {
+      public void operate(Deque<String> stack) {
-          return "" + (Double.parseDouble(a) * Double.parseDouble(b));
+        stack.push(v);
-        }
+      }
-      },
-      DIV("/",2) {
+      @Override
-        String calc(String a, String b) {
+      public String toString() {
-          return "" + (Double.parseDouble(a) / Double.parseDouble(b));
+        return v;
-        }
+      }
-      },
+    }
+    private enum Operator implements Element {
+      PLS("+",1) { @Override protected double calc(double a, double b) { return a + b; } },
+      MIN("-",1) { @Override protected double calc(double a, double b) { return a - b; } },
+      MUL("*",2) { @Override protected double calc(double a, double b) { return a * b; } },
+      DIV("/",2) { @Override protected double calc(double a, double b) { return a / b; } },
       BS("(",0),
       BE(")",0);
-      private final String s;
+      private final String text;
       private final int pri;
-      Ope(String s, int pri) {
+      Operator(String text, int pri) {
-        this.s = s;
+        this.text = text;
         this.pri = pri;
       }
-      static Ope of(char c) {
+      static Operator of(char c) {
-        for(Ope ope : values()) if(ope.s.charAt(0) == c) return ope;
+        for(Operator ope : values()) if(ope.text.charAt(0) == c) return ope;
-        throw new IllegalArgumentException("Ope Error: c=" + c);
+        return null;
       }
+      @Override
+      public void operate(Deque<String> stack) {
+        double b = Double.parseDouble(stack.pop());
+        double a = Double.parseDouble(stack.pop());
+        stack.push("" + calc(a, b));
+      }
-      String calc(String a, String b) {
+      protected double calc(double a, double b) {
         throw new UnsupportedOperationException();
       }
       @Override
       public String toString() {
-        return s;
+        return text;
       }
     }
     private static class Translator {
+      private static class Source {
+        private static Pattern NUM_PATTERN = Pattern.compile("-?\\d+(:?\\.\\d+)?");
+        private final String formula;
+        private int index;
+        Source(String formula) {
+          this.formula = formula;
+        }
+        boolean isEnd() { return index >= formula.length(); }
+        char getChar() { return formula.charAt(index); }
+        Operator nextOperator() {
+          Operator op = Operator.of(formula.charAt(index++));
+          if(op == null) throw new IllegalArgumentException("Operator Error: index=" + index);
+          return op;
+        }
+        Value nextNumber() {
+          Matcher m = NUM_PATTERN.matcher(formula.substring(index));
+          if(!m.find() || m.start() != 0) throw new IllegalArgumentException("Number Error: index=" + index);
+          index += m.group().length();
+          return new Value(m.group());
+        }
+      }
+      private static class Destination {
+        private Deque<Operator> stack = new ArrayDeque<>();
+        private List<Element> list = new ArrayList<>();
+        void put(Operator op) {
+          if(op == Operator.BE) {
+            while(!stack.isEmpty() && (op=stack.pop()) != Operator.BS) list.add(op);
+            if(op != Operator.BS) throw new IllegalStateException("Formula Error: Unmatched parentheses.");
+            return;
+          }
+          if(op != Operator.BS) {
+            while(!stack.isEmpty() && stack.peek().pri >= op.pri) list.add(stack.pop());
+          }
+          stack.push(op);
+        }
+        void put(Value v) {
+          list.add(v);
+        }
+        List<Element> complete() {
+          while(!stack.isEmpty()) list.add(stack.pop());
+          return new ArrayList<>(list);
+        }
+      }
       private enum Mode {
         NUM {
-          Pattern numPatten = Pattern.compile("-?\\d+(:?\\.\\d+)?");
-          Mode translate(Translator translator) {
+          Mode translate(Source src, Destination dst) {
-            if(translator.target() == '(') {
+            if(src.getChar() == '(') {
-              translator.putOpe(Ope.of(translator.target()));
+              dst.put(src.nextOperator());
-            } else {
-              Matcher m = numPatten.matcher(translator.substring());
-              if(m.find() && m.start() == 0) {
-                translator.putValue(m.group(), m.group().length()-1);
-              } else {
-                throw new IllegalArgumentException("fomula Error: index=" + translator.index);
-              }
-              return OP;
+              return this;
             }
+            dst.put(src.nextNumber());
-            return this;
+            return OP;
           }
         },
         OP {
-          Mode translate(Translator translator) {
+          Mode translate(Source src, Destination dst) {
-            char c = translator.target();
+            Operator op = src.nextOperator();
-            if(c == '+' || c == '-' || c == '*' || c == '/') {
-              translator.putOpe(Ope.of(c));
-              return NUM;
-            }
-            if(c == '(') {
+            if(op == Operator.BE) {
-              translator.putOpe(Ope.of('*'));
-              translator.putOpe(Ope.of('('));
-              return NUM;
+              dst.put(op);
-            }
-            if(c == ')') {
-              translator.putOpe(Ope.of(')'));
               return this;
             }
-            throw new IllegalArgumentException("fomula Error: index=" + translator.index);
+            if(op == Operator.BS) dst.put(Operator.MUL);
+            dst.put(op);
+            return NUM;
           }
         };
-        abstract Mode translate(Translator translator);
+        abstract Mode translate(Source src, Destination dst);
       }
-      private final String fomula;
-      private int index;
-      private Deque<Ope> opeList = new ArrayDeque<>();
-      private List<Object> list = new ArrayList<>();
-      Translator(String fomula) {
-        this.fomula = fomula;
-      }
-      List<Object> translate() {
+      static List<Element> translate(String formula) {
         Mode mode = Mode.NUM;
-        opeList.clear();
+        Source src = new Source(formula);
-        list.clear();
-        for(index=0; index<fomula.length(); index++) mode = mode.translate(this);
+        Destination dst = new Destination();
-        while(!opeList.isEmpty()) list.add(opeList.pop());
+        while(!src.isEnd()) mode = mode.translate(src, dst);
-        return list;
-      }
-      private char target() {
-        return fomula.charAt(index);
+        return dst.complete();
-      }
-      private String substring() {
-        return fomula.substring(index);
-      }
-      private void putOpe(Ope ope) {
-        if(ope == Ope.BE) {
-          while(!opeList.isEmpty() && (ope=opeList.pop()) != Ope.BS) list.add(ope);
-          return;
-        }
-        if(ope != Ope.BS) {
-          while(!opeList.isEmpty() && opeList.peek().pri >= ope.pri) list.add(opeList.pop());
-        }
-        opeList.push(ope);
-      }
-      private void putValue(String v, int di) {
-        index += di;
-        list.add(v);
       }
     }
-    private final String fomula;
+    private final String formula;
-    private List<Object> list;
+    private List<Element> list;
-    RPN(String fomula) {
+    RPN(String formula) {
-      this.fomula = fomula;
+      this.formula = formula;
-      list = new Translator(fomula).translate();
+      list = Translator.translate(formula);
     }
     String calc() {
       Deque<String> stack = new ArrayDeque<>();
-      for(Object obj : list) {
+      for(Element elm : list) elm.operate(stack);
-        if(obj instanceof Ope) {
-          String b = stack.pop();
-          String a = stack.pop();
-          stack.push(((Ope)obj).calc(a, b));
-        } else /*if(obj instanceof String)*/ {
-          stack.push((String)obj);
-        }
-      }
       return stack.pop();
     }
     @Override
     public String toString() {
-      return fomula + "=" + list;
+      return formula + "=" + list;
     }
   }
 }