Add matching-brackets

config.json

@@ -191,6 +191,14 @@
         "practices": [],
         "prerequisites": [],
         "difficulty": 3
+      },
+      {
+        "slug": "matching-brackets",
+        "name": "Matching Brackets",
+        "uuid": "400942bf-b57d-41f9-84cd-4cdff3528ac3",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4
       }
     ]
   },

exercises/practice/matching-brackets/.docs/instructions.md

@@ -0,0 +1,5 @@
+# Instructions
+
+Given a string containing brackets `[]`, braces `{}`, parentheses `()`, or any combination thereof, verify that any and all pairs are matched and nested correctly.
+Any other characters should be ignored.
+For example, `"{what is (42)}?"` is balanced and `"[text}"` is not.

exercises/practice/matching-brackets/.docs/introduction.md

@@ -0,0 +1,8 @@
+# Introduction
+
+You're given the opportunity to write software for the Bracketeer™, an ancient but powerful mainframe.
+The software that runs on it is written in a proprietary language.
+Much of its syntax is familiar, but you notice _lots_ of brackets, braces and parentheses.
+Despite the Bracketeer™ being powerful, it lacks flexibility.
+If the source code has any unbalanced brackets, braces or parentheses, the Bracketeer™ crashes and must be rebooted.
+To avoid such a scenario, you start writing code that can verify that brackets, braces, and parentheses are balanced before attempting to run it on the Bracketeer™.

exercises/practice/matching-brackets/.meta/config.json

@@ -0,0 +1,18 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "src/MatchingBrackets.idr"
+    ],
+    "test": [
+      "test/src/Main.idr"
+    ],
+    "example": [
+      "example/MatchingBrackets.idr"
+    ]
+  },
+  "blurb": "Make sure the brackets and braces all match.",
+  "source": "Ginna Baker"
+}

exercises/practice/matching-brackets/.meta/tests.toml

@@ -0,0 +1,70 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[81ec11da-38dd-442a-bcf9-3de7754609a5]
+description = "paired square brackets"
+
+[287f0167-ac60-4b64-8452-a0aa8f4e5238]
+description = "empty string"
+
+[6c3615a3-df01-4130-a731-8ef5f5d78dac]
+description = "unpaired brackets"
+
+[9d414171-9b98-4cac-a4e5-941039a97a77]
+description = "wrong ordered brackets"
+
+[f0f97c94-a149-4736-bc61-f2c5148ffb85]
+description = "wrong closing bracket"
+
+[754468e0-4696-4582-a30e-534d47d69756]
+description = "paired with whitespace"
+
+[ba84f6ee-8164-434a-9c3e-b02c7f8e8545]
+description = "partially paired brackets"
+
+[3c86c897-5ff3-4a2b-ad9b-47ac3a30651d]
+description = "simple nested brackets"
+
+[2d137f2c-a19e-4993-9830-83967a2d4726]
+description = "several paired brackets"
+
+[2e1f7b56-c137-4c92-9781-958638885a44]
+description = "paired and nested brackets"
+
+[84f6233b-e0f7-4077-8966-8085d295c19b]
+description = "unopened closing brackets"
+
+[9b18c67d-7595-4982-b2c5-4cb949745d49]
+description = "unpaired and nested brackets"
+
+[a0205e34-c2ac-49e6-a88a-899508d7d68e]
+description = "paired and wrong nested brackets"
+
+[1d5c093f-fc84-41fb-8c2a-e052f9581602]
+description = "paired and wrong nested brackets but innermost are correct"
+
+[ef47c21b-bcfd-4998-844c-7ad5daad90a8]
+description = "paired and incomplete brackets"
+
+[a4675a40-a8be-4fc2-bc47-2a282ce6edbe]
+description = "too many closing brackets"
+
+[a345a753-d889-4b7e-99ae-34ac85910d1a]
+description = "early unexpected brackets"
+
+[21f81d61-1608-465a-b850-baa44c5def83]
+description = "early mismatched brackets"
+
+[99255f93-261b-4435-a352-02bdecc9bdf2]
+description = "math expression"
+
+[8e357d79-f302-469a-8515-2561877256a1]
+description = "complex latex expression"

exercises/practice/matching-brackets/example/MatchingBrackets.idr

@@ -0,0 +1,15 @@
+module MatchingBrackets
+
+export
+isPaired : String -> Bool
+isPaired = loop [] . filter isBracket . unpack
+  where isBracket : Char -> Bool
+        isBracket ch = ch == '[' || ch == ']' || ch == '{' || ch == '}' || ch == '(' || ch == ')'
+        loop : List Char -> List Char -> Bool
+        loop []        []        = True
+        loop _         []        = False
+        loop []        (y :: ys) = if y == '[' || y == '{' || y == '(' then loop (y :: []) ys
+                                   else False
+        loop (x :: xs) (y :: ys) = if y == '[' || y == '{' || y == '(' then loop (y :: x :: xs) ys
+                                   else if (x == '[' && y == ']') || (x == '{' && y == '}') || (x == '(' && y == ')') then loop xs ys
+                                   else False

exercises/practice/matching-brackets/matching-brackets.ipkg

@@ -0,0 +1,3 @@
+package matching-brackets
+modules = MatchingBrackets
+sourcedir = "src"

exercises/practice/matching-brackets/pack.toml

@@ -0,0 +1,10 @@
+[custom.all.matching-brackets]
+type = "local"
+path = "."
+ipkg = "matching-brackets.ipkg"
+test = "test/test.ipkg"
+
+[custom.all.matching-brackets-test]
+type = "local"
+path = "test"
+ipkg = "test.ipkg"

exercises/practice/matching-brackets/src/MatchingBrackets.idr

@@ -0,0 +1,5 @@
+module MatchingBrackets
+
+export
+isPaired : String -> Bool
+isPaired value = ?isPaired_rhs

exercises/practice/matching-brackets/test/src/Main.idr

@@ -0,0 +1,39 @@
+module Main
+
+import System
+import Tester
+import Tester.Runner
+
+import MatchingBrackets
+
+tests : List Test
+tests =
+  [ test "paired square brackets"                                     (assert $       isPaired "[]")
+  , test "empty string"                                               (assert $       isPaired "")
+  , test "unpaired brackets"                                          (assert $ not $ isPaired "[[")
+  , test "wrong ordered brackets"                                     (assert $ not $ isPaired "}{")
+  , test "wrong closing bracket"                                      (assert $ not $ isPaired "{]")
+  , test "paired with whitespace"                                     (assert $       isPaired "{ }")
+  , test "partially paired brackets"                                  (assert $ not $ isPaired "{[])")
+  , test "simple nested brackets"                                     (assert $       isPaired "{[]}")
+  , test "several paired brackets"                                    (assert $       isPaired "{}[]")
+  , test "paired and nested brackets"                                 (assert $       isPaired "([{}({}[])])")
+  , test "unopened closing brackets"                                  (assert $ not $ isPaired "{[)][]}")
+  , test "unpaired and nested brackets"                               (assert $ not $ isPaired "([{])")
+  , test "paired and wrong nested brackets"                           (assert $ not $ isPaired "[({]})")
+  , test "paired and wrong nested brackets but innermost are correct" (assert $ not $ isPaired "[({}])")
+  , test "paired and incomplete brackets"                             (assert $ not $ isPaired "{}[")
+  , test "too many closing brackets"                                  (assert $ not $ isPaired "[]]")
+  , test "early unexpected brackets"                                  (assert $ not $ isPaired ")()")
+  , test "early mismatched brackets"                                  (assert $ not $ isPaired "{)()")
+  , test "math expression"                                            (assert $       isPaired "(((185 + 223.85) * 15) - 543)/2")
+  , test "complex latex expression"                                   (assert $       isPaired "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)")
+  ]
+
+export
+main : IO ()
+main = do
+  success <- runTests tests
+  if success
+     then putStrLn "All tests passed"
+     else exitFailure

exercises/practice/matching-brackets/test/test.ipkg

@@ -0,0 +1,6 @@
+package matching-brackets-test
+depends = matching-brackets
+  , tester
+main = Main
+executable = "matching-brackets-test"
+sourcedir = "src"

generators/exercises/matching_brackets.py

@@ -0,0 +1,12 @@
+from json import dumps
+
+def generate_test(case):
+    property = case["property"]
+    value = dumps(case["input"]["value"])
+    expected = case["expected"]
+    if expected:
+        prefix = 'assert $      '
+    else:
+        prefix = 'assert $ not $'
+
+    return f'{prefix} {property} {value}'