Add sublist exercise (#82)

Author: keiravillekode

config.json

@@ -233,6 +233,14 @@
         "prerequisites": [],
         "difficulty": 3
       },
+      {
+        "slug": "sublist",
+        "name": "Sublist",
+        "uuid": "05c30dae-f899-4093-9382-45be2a2c455c",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 3
+      },
       {
         "slug": "sum-of-multiples",
         "name": "Sum of Multiples",

exercises/practice/sublist/.docs/instructions.md

@@ -0,0 +1,25 @@
+# Instructions
+
+Given any two lists `A` and `B`, determine if:
+
+- List `A` is equal to list `B`; or
+- List `A` contains list `B` (`A` is a superlist of `B`); or
+- List `A` is contained by list `B` (`A` is a sublist of `B`); or
+- None of the above is true, thus lists `A` and `B` are unequal
+
+Specifically, list `A` is equal to list `B` if both lists have the same values in the same order.
+List `A` is a superlist of `B` if `A` contains a contiguous sub-sequence of values equal to `B`.
+List `A` is a sublist of `B` if `B` contains a contiguous sub-sequence of values equal to `A`.
+
+Examples:
+
+- If `A = []` and `B = []` (both lists are empty), then `A` and `B` are equal
+- If `A = [1, 2, 3]` and `B = []`, then `A` is a superlist of `B`
+- If `A = []` and `B = [1, 2, 3]`, then `A` is a sublist of `B`
+- If `A = [1, 2, 3]` and `B = [1, 2, 3, 4, 5]`, then `A` is a sublist of `B`
+- If `A = [3, 4, 5]` and `B = [1, 2, 3, 4, 5]`, then `A` is a sublist of `B`
+- If `A = [3, 4]` and `B = [1, 2, 3, 4, 5]`, then `A` is a sublist of `B`
+- If `A = [1, 2, 3]` and `B = [1, 2, 3]`, then `A` and `B` are equal
+- If `A = [1, 2, 3, 4, 5]` and `B = [2, 3, 4]`, then `A` is a superlist of `B`
+- If `A = [1, 2, 4]` and `B = [1, 2, 3, 4, 5]`, then `A` and `B` are unequal
+- If `A = [1, 2, 3]` and `B = [1, 3, 2]`, then `A` and `B` are unequal

exercises/practice/sublist/.meta/config.json

@@ -0,0 +1,17 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "sublist.fut"
+    ],
+    "test": [
+      "test.fut"
+    ],
+    "example": [
+      ".meta/example.fut"
+    ]
+  },
+  "blurb": "Write a function to determine if a list is a sublist of another list."
+}

exercises/practice/sublist/.meta/example.fut

@@ -0,0 +1,19 @@
+type relation = #equal | #superlist | #sublist | #unequal
+
+local def is_equal (list_one: []i32) (list_two: []i32): bool =
+  let result = loop result = true for i < length list_one do
+    result && list_one[i] == list_two[i]
+  in
+    result
+
+local def is_sublist [m] [n] (list_one: [m]i32) (list_two: [n]i32): bool =
+  let result = loop result = false for i in 0...(n - m) do
+    result || is_equal list_one list_two[i:i + m]
+  in
+    result
+
+def compare [m] [n] (list_one: [m]i32) (list_two: [n]i32): relation =
+  if m < n && is_sublist list_one list_two then #sublist else
+  if m > n && is_sublist list_two list_one then #superlist else
+  if m == n && is_equal list_one list_two then #equal else
+  #unequal

exercises/practice/sublist/.meta/tests.toml

@@ -0,0 +1,64 @@
+# 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.
+
+[97319c93-ebc5-47ab-a022-02a1980e1d29]
+description = "empty lists"
+
+[de27dbd4-df52-46fe-a336-30be58457382]
+description = "empty list within non empty list"
+
+[5487cfd1-bc7d-429f-ac6f-1177b857d4fb]
+description = "non empty list contains empty list"
+
+[1f390b47-f6b2-4a93-bc23-858ba5dda9a6]
+description = "list equals itself"
+
+[7ed2bfb2-922b-4363-ae75-f3a05e8274f5]
+description = "different lists"
+
+[3b8a2568-6144-4f06-b0a1-9d266b365341]
+description = "false start"
+
+[dc39ed58-6311-4814-be30-05a64bc8d9b1]
+description = "consecutive"
+
+[d1270dab-a1ce-41aa-b29d-b3257241ac26]
+description = "sublist at start"
+
+[81f3d3f7-4f25-4ada-bcdc-897c403de1b6]
+description = "sublist in middle"
+
+[43bcae1e-a9cf-470e-923e-0946e04d8fdd]
+description = "sublist at end"
+
+[76cf99ed-0ff0-4b00-94af-4dfb43fe5caa]
+description = "at start of superlist"
+
+[b83989ec-8bdf-4655-95aa-9f38f3e357fd]
+description = "in middle of superlist"
+
+[26f9f7c3-6cf6-4610-984a-662f71f8689b]
+description = "at end of superlist"
+
+[0a6db763-3588-416a-8f47-76b1cedde31e]
+description = "first list missing element from second list"
+
+[83ffe6d8-a445-4a3c-8795-1e51a95e65c3]
+description = "second list missing element from first list"
+
+[7bc76cb8-5003-49ca-bc47-cdfbe6c2bb89]
+description = "first list missing additional digits from second list"
+
+[0d7ee7c1-0347-45c8-9ef5-b88db152b30b]
+description = "order matters to a list"
+
+[5f47ce86-944e-40f9-9f31-6368aad70aa6]
+description = "same digits but different numbers"

exercises/practice/sublist/sublist.fut

@@ -0,0 +1,3 @@
+type relation = #equal | #superlist | #sublist | #unequal
+
+def compare (list_one: []i32) (list_two: []i32): relation = ???

exercises/practice/sublist/test.fut

@@ -0,0 +1,101 @@
+import "sublist"
+
+-- empty lists
+-- ==
+-- input  { empty([0]i32) empty([0]i32) }
+-- output { "equal" }
+
+-- empty list within non empty list
+-- ==
+-- input  { empty([0]i32) [1, 2, 3] }
+-- output { "sublist" }
+
+-- non empty list contains empty list
+-- ==
+-- input  { [1, 2, 3] empty([0]i32) }
+-- output { "superlist" }
+
+-- list equals itself
+-- ==
+-- input  { [1, 2, 3] [1, 2, 3] }
+-- output { "equal" }
+
+-- different lists
+-- ==
+-- input  { [1, 2, 3] [2, 3, 4] }
+-- output { "unequal" }
+
+-- false start
+-- ==
+-- input  { [1, 2, 5] [0, 1, 2, 3, 1, 2, 5, 6] }
+-- output { "sublist" }
+
+-- consecutive
+-- ==
+-- input  { [1, 1, 2] [0, 1, 1, 1, 2, 1, 2] }
+-- output { "sublist" }
+
+-- sublist at start
+-- ==
+-- input  { [0, 1, 2] [0, 1, 2, 3, 4, 5] }
+-- output { "sublist" }
+
+-- sublist in middle
+-- ==
+-- input  { [2, 3, 4] [0, 1, 2, 3, 4, 5] }
+-- output { "sublist" }
+
+-- sublist at end
+-- ==
+-- input  { [3, 4, 5] [0, 1, 2, 3, 4, 5] }
+-- output { "sublist" }
+
+-- at start of superlist
+-- ==
+-- input  { [0, 1, 2, 3, 4, 5] [0, 1, 2] }
+-- output { "superlist" }
+
+-- in middle of superlist
+-- ==
+-- input  { [0, 1, 2, 3, 4, 5] [2, 3] }
+-- output { "superlist" }
+
+-- at end of superlist
+-- ==
+-- input  { [0, 1, 2, 3, 4, 5] [3, 4, 5] }
+-- output { "superlist" }
+
+-- first list missing element from second list
+-- ==
+-- input  { [1, 3] [1, 2, 3] }
+-- output { "unequal" }
+
+-- second list missing element from first list
+-- ==
+-- input  { [1, 2, 3] [1, 3] }
+-- output { "unequal" }
+
+-- first list missing additional digits from second list
+-- ==
+-- input  { [1, 2] [1, 22] }
+-- output { "unequal" }
+
+-- order matters to a list
+-- ==
+-- input  { [1, 2, 3] [3, 2, 1] }
+-- output { "unequal" }
+
+-- same digits but different numbers
+-- ==
+-- input  { [1, 0, 1] [10, 1] }
+-- output { "unequal" }
+
+local def name (r: relation): []u8 =
+  match r
+    case #equal     -> "equal"
+    case #superlist -> "superlist"
+    case #sublist   -> "sublist"
+    case #unequal   -> "unequal"
+
+def main (list_one: []i32) (list_two: []i32): []u8 =
+  name (compare list_one list_two)

generators/exercises/sublist.py

@@ -0,0 +1,25 @@
+def gen_test_case(prop, description, inp, expected, f):
+    def serialize_list(values):
+        if values == []:
+            return "empty([0]i32)"
+        return str(values)
+
+    list_one = serialize_list(inp["listOne"])
+    list_two = serialize_list(inp["listTwo"])
+
+    f.write(f"-- {description}\n")
+    f.write("-- ==\n")
+    f.write("-- input  {" + f" {list_one} {list_two} " + "}\n")
+    f.write('-- output { "' + expected + '" }\n\n')
+
+
+def gen_main(f):
+    f.write("local def name (r: relation): []u8 =\n")
+    f.write("  match r\n")
+    f.write('    case #equal     -> "equal"\n')
+    f.write('    case #superlist -> "superlist"\n')
+    f.write('    case #sublist   -> "sublist"\n')
+    f.write('    case #unequal   -> "unequal"\n\n')
+
+    f.write("def main (list_one: []i32) (list_two: []i32): []u8 =\n")
+    f.write("  name (compare list_one list_two)\n")