week3 machines lahendused

Author: sim642

sols/week3/machines/FormatMachine.java

@@ -0,0 +1,50 @@
+package week3.machines;
+
+public class FormatMachine {
+
+    private enum State {
+        INIT, PUNC, MIDW
+    }
+    private State state = State.INIT;
+
+    private static boolean isPunct(char c) {
+        return (c == ',' || c == '.' || c == ':' || c == ';' || c == '!' || c == '?');
+    }
+
+    public String process(char c) {
+        boolean space = false;
+        if (c == '(') {
+            space = state != State.INIT;
+            state = State.INIT;
+        } else if (c == ')' || isPunct(c)) {
+            state = State.PUNC;
+        } else if (c == '\n') {
+            state = State.INIT;
+        } else if (c == ' ') {
+            if (state == State.MIDW) state = State.PUNC;
+            return "";
+        } else {
+            space = state == State.PUNC;
+            state = State.MIDW;
+        }
+        return (space ? " " : "") + c;
+    }
+
+    // Masina kasutamine
+    static void main() {
+        String input =
+                """
+                        This     text (all of it   )has occasional lapses .. .in
+                          punctuation( sometimes,pretty bad ; sometimes ,not so).
+
+                        ( Ha ! )Is this  :fun ! ? !  Or   what  ?""";
+        System.out.println(cleanUp(input));
+    }
+
+    public static String cleanUp(String s) {
+        StringBuilder sb = new StringBuilder();
+        FormatMachine machine = new FormatMachine();
+        for (char c : s.toCharArray()) sb.append(machine.process(c));
+        return sb.toString();
+    }
+}

sols/week3/machines/HtmlStripMachine.java

@@ -0,0 +1,46 @@
+package week3.machines;
+
+import static week3.machines.HtmlStripMachine.State.*;
+
+public class HtmlStripMachine {
+
+    enum State {
+        INI, TAG, QTE, DQT
+    }
+    private State state = INI;
+
+    public String process(char c) {
+        // Väljastamine toimub ainult algseisundis!
+        boolean echo = state == INI;
+        switch (c) {
+            case '<':
+                if (state == INI) state = TAG;
+                return "";
+            case '>':
+                if (state == TAG) state = INI;
+                break;
+            case '\'':
+                if (state == QTE) state = TAG;
+                else if (state == TAG) state = QTE;
+                break;
+            case '"':
+                if (state == DQT) state = TAG;
+                else if (state == TAG) state = DQT;
+                break;
+        }
+        return echo ? Character.toString(c) : "";
+    }
+
+    // Masina kasutamine
+    static void main() {
+        String input = "<a href='>'>foo</a>";
+        System.out.println(cleanUp(input));
+    }
+
+    private static String cleanUp(String s) {
+        StringBuilder sb = new StringBuilder();
+        HtmlStripMachine machine = new HtmlStripMachine();
+        for (char c : s.toCharArray()) sb.append(machine.process(c));
+        return sb.toString();
+    }
+}

sols/week3/machines/MiniAktkMachines.java

@@ -0,0 +1,88 @@
+package week3.machines;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MiniAktkMachines {
+
+    public static List<String> tokenize(String input) {
+        List<String> tokens = new ArrayList<>();
+        StringBuilder currentToken = new StringBuilder();         // Tühi sõne tähistab seisundit ￢TOK
+        for (char c : input.toCharArray()) {
+            if (c == '#') break;
+            if (c == '+' || c == '-' || c == '=' || c == ' ') {   // lisame siia '=' ja tühikud.
+                if (!currentToken.isEmpty()) {
+                    tokens.add(currentToken.toString());          // push
+                    currentToken = new StringBuilder();
+                }
+                if (c != ' ') tokens.add(Character.toString(c));  // echo (v.a. tühikud)
+            } else {
+                currentToken.append(c);                           // acc
+            }
+        }
+        // Ja lõpuks EOF puhul ka push seisundis TOK:
+        if (!currentToken.isEmpty()) tokens.add(currentToken.toString());
+        return tokens;
+    }
+
+    public static int compute(List<String> tokens, Map<Character, Integer> environment) {
+        int sign = 1;
+        int sum = 0;
+        boolean wasValue = false; // was the previous token a value
+        for (String token : tokens) {
+            switch (token) {
+                case "-":
+                    sign *= -1;
+                    // intentional fallthrough
+                case "+":
+                    wasValue = false;
+                    break;
+                default:
+                    if (wasValue) throw new RuntimeException("Expected operator!");
+                    sum += sign * getValue(token, environment);
+                    sign = 1;
+                    wasValue = true;
+            }
+        }
+        if (!wasValue) throw new RuntimeException("Malformed expression!");
+        return sum;
+    }
+
+    private static int getValue(String token, Map<Character, Integer> environment) {
+        try {
+            return Integer.parseInt(token);
+        } catch (NumberFormatException e) {
+            char variableName = token.charAt(0);
+            return environment.get(variableName);
+        }
+    }
+
+    static void main(String[] args) throws IOException {
+        Map<Character, Integer> environment = new HashMap<>();
+        try (BufferedReader reader = Files.newBufferedReader(Paths.get(args[0]), StandardCharsets.UTF_8)) {
+            for (String line; (line = reader.readLine()) != null; ) {
+                if (!line.isEmpty() && line.charAt(0) == ' ') throw new RuntimeException("Begins with space!");
+                List<String> tokens = tokenize(line);
+                if (tokens.isEmpty()) continue;
+                String firstToken = tokens.get(0);
+                if (firstToken.equals("print")) {
+                    System.out.println(compute(tokens.subList(1, tokens.size()), environment));
+                } else if (tokens.get(1).equals("=")) {
+                    if (firstToken.length() > 1) throw new RuntimeException("Too long var!");
+                    char variableName = firstToken.charAt(0);
+                    if (!Character.isLetter(variableName)) throw new RuntimeException("Invalid var name.");
+                    environment.put(variableName, compute(tokens.subList(2, tokens.size()), environment));
+                } else {
+                    throw new RuntimeException("Unexpected operation!");
+                }
+            }
+        }
+    }
+}