Merge branch 'main' into add-approach-bob

Author: jagdish-15

.github/workflows/java.yml

@@ -17,7 +17,7 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: Set up JDK 1.17
-        uses: actions/setup-java@7a6d8a8234af8eb26422e24e3006232cccaa061b
+        uses: actions/setup-java@3a4f6e1af504cf6a31855fa899c6aa5355ba6c12
         with:
           java-version: 17
           distribution: "temurin"
@@ -31,7 +31,7 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: Set up JDK 1.17
-        uses: actions/setup-java@7a6d8a8234af8eb26422e24e3006232cccaa061b
+        uses: actions/setup-java@3a4f6e1af504cf6a31855fa899c6aa5355ba6c12
         with:
           java-version: 17
           distribution: "temurin"
@@ -47,7 +47,7 @@ jobs:
       - name: Test all exercises using java-test-runner
         run: bin/test-with-test-runner
       - name: Archive test results
-        uses: actions/upload-artifact@6f51ac03b9356f520e9adb1b1b7802705f340c2b
+        uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08
         with:
           name: test-results
           path: exercises/**/build/results.json

.github/workflows/markdown.yml

@@ -19,4 +19,4 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
       - name: Lint markdown
-        uses: DavidAnson/markdownlint-cli2-action@a23dae216ce3fee4db69da41fed90d2a4af801cf
+        uses: DavidAnson/markdownlint-cli2-action@05f32210e84442804257b2a6f20b273450ec8265

exercises/concept/cars-assemble/.docs/instructions.md

@@ -13,7 +13,7 @@ You have two tasks.
 
 ## 1. Calculate the production rate per hour
 
-Implement the `CarsAssemble.productionRatePerHour()` method to calculate the assembly line's production rate per hour, taking into account its current assembly line's speed :
+Implement the `CarsAssemble.productionRatePerHour()` method to calculate the assembly line's production rate per hour, taking into account its current assembly line's speed and success rate:
 
 ```Java
 CarsAssemble.productionRatePerHour(6)

exercises/practice/parallel-letter-frequency/src/test/java/ParallelLetterFrequencyTest.java

@@ -9,7 +9,7 @@
 
 public class ParallelLetterFrequencyTest {
 
-    private String calculateFrecuencies = 
+    private String calculateFrequencies =
         "There, peeping among the cloud-wrack above a dark tower high up in the mountains," +
         "Sam saw a white star twinkle for a while." +
         "The beauty of it smote his heart," +
@@ -338,7 +338,7 @@ public void testUnicodeLetters() {
     @Disabled("Remove to run test")
     @Test
     public void testCombinationOfLowerAndUppercaseLettersPunctuationAndWhiteSpace() {
-        String[] input = { calculateFrecuencies };
+        String[] input = {calculateFrequencies};
         Map<Character, Integer> expectedOutput = new HashMap<>() {
             {
                 put('a',  32);

exercises/practice/sgf-parsing/.meta/config.json

@@ -2,6 +2,10 @@
   "authors": [
     "tlphat"
   ],
+  "contributors": [
+    "jagdish-15",
+    "kahgoh"
+  ],
   "files": {
     "solution": [
       "src/main/java/SgfParsing.java"

exercises/practice/sgf-parsing/.meta/src/reference/java/SgfParsing.java

@@ -29,26 +29,52 @@ private int parseFromIndex(String input, int index, SgfNode root) throws SgfPars
         StringBuilder buffer = new StringBuilder();
         Map<String, List<String>> properties = new HashMap<>();
         String key = null;
+        boolean escape = false;
+        boolean inValue = false;
         while (index < input.length()) {
-            switch (input.charAt(index)) {
-                case '(':
-                    index = addNewChild(input, index, root);
-                    break;
-                case ')':
-                    break;
-                case '[':
-                    key = loadKeyFromBuffer(buffer, properties);
-                    break;
-                case ']':
-                    properties.get(key).add(popStringFromBuffer(buffer));
-                    if (input.charAt(index + 1) == ')') {
-                        root.setProperties(properties);
-                        return index + 1;
-                    }
-                    index = examineNextNode(input, index, root, properties);
-                    break;
-                default:
-                    index = appendCharToBuffer(input, index, buffer);
+            char nextChar = input.charAt(index);
+            if (escape) {
+                if (nextChar != '\n') {
+                    appendChar(buffer, nextChar);
+                }
+                escape = false;
+            } else {
+                switch (nextChar) {
+                    case '(':
+                        if (inValue) {
+                            buffer.append(nextChar);
+                        } else {
+                            index = addNewChild(input, index, root);
+                        }
+                        break;
+                    case ')':
+                        if (inValue) {
+                            buffer.append(nextChar);
+                        }
+                        break;
+                    case '[':
+                        if (inValue) {
+                            buffer.append(nextChar);
+                        } else {
+                            key = loadKeyFromBuffer(buffer, properties);
+                            inValue = true;
+                        }
+                        break;
+                    case ']':
+                        properties.get(key).add(popStringFromBuffer(buffer));
+                        if (input.charAt(index + 1) == ')') {
+                            root.setProperties(properties);
+                            return index + 1;
+                        }
+                        index = examineNextNode(input, index, root, properties);
+                        inValue = false;
+                        break;
+                    case '\\':
+                        escape = true;
+                        break;
+                    default:
+                        appendChar(buffer, nextChar);
+                }
             }
             ++index;
         }
@@ -101,14 +127,13 @@ private int examineNextNode(String input, int index, SgfNode root, Map<String, L
         }
         return index;
     }
-
-    private int appendCharToBuffer(String input, int index, StringBuilder buffer) {
-        char character = input.charAt(index);
-        while (character == '\\') {
-            character = input.charAt(++index);
+    
+    private void appendChar(StringBuilder builder, char charToAdd) {
+        if (charToAdd != '\n' && Character.isWhitespace(charToAdd)) {
+            builder.append(" ");
+        } else {
+            builder.append(charToAdd);
         }
-        buffer.append(character);
-        return index;
     }
 
     private void checkIfThereAreDelimiters(StringBuilder buffer) throws SgfParsingException {

exercises/practice/sgf-parsing/.meta/tests.toml

@@ -45,5 +45,40 @@ description = "two child trees"
 [724eeda6-00db-41b1-8aa9-4d5238ca0130]
 description = "multiple property values"
 
+[28092c06-275f-4b9f-a6be-95663e69d4db]
+description = "within property values, whitespace characters such as tab are converted to spaces"
+
+[deaecb9d-b6df-4658-aa92-dcd70f4d472a]
+description = "within property values, newlines remain as newlines"
+
+[8e4c970e-42d7-440e-bfef-5d7a296868ef]
+description = "escaped closing bracket within property value becomes just a closing bracket"
+
+[cf371fa8-ba4a-45ec-82fb-38668edcb15f]
+description = "escaped backslash in property value becomes just a backslash"
+
+[dc13ca67-fac0-4b65-b3fe-c584d6a2c523]
+description = "opening bracket within property value doesn't need to be escaped"
+
+[a780b97e-8dbb-474e-8f7e-4031902190e8]
+description = "semicolon in property value doesn't need to be escaped"
+
+[0b57a79e-8d89-49e5-82b6-2eaaa6b88ed7]
+description = "parentheses in property value don't need to be escaped"
+
+[c72a33af-9e04-4cc5-9890-1b92262813ac]
+description = "escaped tab in property value is converted to space"
+
+[3a1023d2-7484-4498-8d73-3666bb386e81]
+description = "escaped newline in property value is converted to nothing at all"
+
+[25abf1a4-5205-46f1-8c72-53273b94d009]
+description = "escaped t and n in property value are just letters, not whitespace"
+
+[08e4b8ba-bb07-4431-a3d9-b1f4cdea6dab]
+description = "mixing various kinds of whitespace and escaped characters in property value"
+reimplements = "11c36323-93fc-495d-bb23-c88ee5844b8c"
+
 [11c36323-93fc-495d-bb23-c88ee5844b8c]
 description = "escaped property"
+include = false

exercises/practice/sgf-parsing/src/test/java/SgfParsingTest.java

@@ -121,11 +121,114 @@ public void multiplePropertyValues() throws SgfParsingException {
 
     @Test
     @Disabled("Remove to run test")
-    public void escapedProperty() throws SgfParsingException {
-        String input = "(;A[\\]b\nc\nd\t\te \n\\]])";
-        SgfNode expected = new SgfNode(Map.of("A", List.of("]b\nc\nd\t\te \n]")));
+    public void withinPropertyValueWhitespace() throws SgfParsingException {
+        String input = "(;A[hello\t\tworld])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("hello  world")));
         SgfNode actual = new SgfParsing().parse(input);
         assertThat(actual).isEqualTo(expected);
     }
 
+    @Test
+    @Disabled("Remove to run test")
+    public void withinPropertyValueNewline() throws SgfParsingException {
+        String input = "(;A[hello\n\nworld])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("hello\n\nworld")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    @Disabled("Remove to run test")
+    public void escapedClosingBracket() throws SgfParsingException {
+        String input = "(;A[\\]])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("]")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    @Disabled("Remove to run test")
+    public void escapedBacklash() throws SgfParsingException {
+        String input = "(;A[\\\\])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("\\")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    @Disabled("Remove to run test")
+    public void openingBracketNeedNotToBeEscaped() throws SgfParsingException {
+        String input = "(;A[x[y\\]z][foo]B[bar];C[baz])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("x[y]z", "foo"),
+                "B", List.of("bar")),
+                List.of(
+                        new SgfNode(Map.of("C", List.of("baz")))
+                ));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    @Disabled("Remove to run test")
+    public void semicolonNeedNotToBeEscaped() throws SgfParsingException {
+        String input = "(;A[a;b][foo]B[bar];C[baz])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("a;b", "foo"),
+                "B", List.of("bar")),
+                List.of(
+                        new SgfNode(Map.of("C", List.of("baz")))
+                ));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    @Disabled("Remove to run test")
+    public void paranthesesNeedNotToBeEscaped() throws SgfParsingException {
+        String input = "(;A[x(y)z][foo]B[bar];C[baz])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("x(y)z", "foo"),
+                "B", List.of("bar")),
+                List.of(
+                        new SgfNode(Map.of("C", List.of("baz")))
+                ));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    @Test
+    @Disabled("Remove to run test")
+    public void escapedTab() throws SgfParsingException {
+        String input = "(;A[hello\\\tworld])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("hello world")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+    
+    @Test
+    @Disabled("Remove to run test")
+    public void escapedNewline() throws SgfParsingException {
+        String input = "(;A[hello\\\nworld])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("helloworld")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    
+    @Test
+    @Disabled("Remove to run test")
+    public void escapedTAndN() throws SgfParsingException {
+        String input = "(;A[\\t = t and \\n = n])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("t = t and n = n")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
+
+    
+    @Test
+    @Disabled("Remove to run test")
+    public void mixOfEscapedCharactersAndWhitespaces() throws SgfParsingException {
+        String input = "(;A[\\]b\nc\\\nd\t\te\\\\ \\\n\\]])";
+        SgfNode expected = new SgfNode(Map.of("A", List.of("]b\ncd  e\\ ]")));
+        SgfNode actual = new SgfParsing().parse(input);
+        assertThat(actual).isEqualTo(expected);
+    }
 }