New practice exercise killer-sudoku-helper (#1116)

Author: jiegillet

config.json

@@ -1806,6 +1806,22 @@
         ],
         "difficulty": 4
       },
+      {
+        "slug": "killer-sudoku-helper",
+        "name": "Killer Sudoku Helper",
+        "uuid": "ac7f32a8-920b-4132-b904-76131b344f12",
+        "prerequisites": [
+          "integers",
+          "lists",
+          "ranges",
+          "enum",
+          "maps",
+          "pattern-matching",
+          "recursion"
+        ],
+        "practices": [],
+        "difficulty": 4
+      },
       {
         "slug": "largest-series-product",
         "name": "Largest Series Product",

exercises/practice/killer-sudoku-helper/.docs/instructions.md

@@ -0,0 +1,55 @@
+# Instructions
+
+A friend of yours is learning how to solve Killer Sudokus (rules below) but struggling to figure out which digits can go in a cage.
+They ask you to help them out by writing a small program that lists all valid combinations for a given cage, and any constraints that affect the cage.
+
+To make the output of your program easy to read, the combinations it returns must be sorted.
+
+## Killer Sudoku Rules
+
+- [Standard Sudoku rules](https://masteringsudoku.com/sudoku-rules-beginners/) apply.
+- The digits in a cage, usually marked by a dotted line, add up to the small number given in the corner of the cage.
+- A digit may only occur once in a cage.
+
+For a more detailed explanation, check out [this guide](https://masteringsudoku.com/killer-sudoku/).
+
+## Example 1: Cage with only 1 possible combination
+
+In a 3-digit cage with a sum of 7, there is only one valid combination: 124.
+
+- 1 + 2 + 4 = 7
+- Any other combination that adds up to 7, e.g. 232, would violate the rule of not repeating digits within a cage.
+
+![Sudoku grid, with three killer cages that are marked as grouped together. The first killer cage is in the 3×3 box in the top left corner of the grid. The middle column of that box forms the cage, with the followings cells from top to bottom: first cell contains a 1 and a pencil mark of 7, indicating a cage sum of 7, second cell contains a 2, third cell contains a 5. The numbers are highlighted in red to indicate a mistake. The second killer cage is in the central 3×3 box of the grid. The middle column of that box forms the cage, with the followings cells from top to bottom: first cell contains a 1 and a pencil mark of 7, indicating a cage sum of 7, second cell contains a 2, third cell contains a 4. None of the numbers in this cage are highlighted and therefore don't contain any mistakes. The third killer cage follows the outside corner of the central 3×3 box of the grid. It is made up of the following three cells: the top left cell of the cage contains a 2, highlighted in red, and a cage sum of 7. The top right cell of the cage contains a 3. The bottom right cell of the cage contains a 2, highlighted in red. All other cells are empty.](https://media.githubusercontent.com/media/exercism/v3-files/main/julia/killer-sudoku-helper/example1.png)
+
+## Example 2: Cage with several combinations
+
+In a 2-digit cage with a sum 10, there are 4 possible combinations:
+
+- 19
+- 28
+- 37
+- 46
+
+![Sudoku grid, all squares empty except for the middle column, column 5, which has 8 rows filled. Each continguous two rows form a killer cage and are marked as grouped together. From top to bottom: first group is a cell with value 1 and a pencil mark indicating a cage sum of 10, cell with value 9. Second group is a cell with value 2 and a pencil mark of 10, cell with value 8. Third group is a cell with value 3 and a pencil mark of 10, cell with value 7. Fourth group is a cell with value 4 and a pencil mark of 10, cell with value 6. The last cell in the column is empty.](https://media.githubusercontent.com/media/exercism/v3-files/main/julia/killer-sudoku-helper/example2.png)
+
+## Example 3: Cage with several combinations that is restricted
+
+In a 2-digit cage with a sum 10, where the column already contains a 1 and a 4, there are 2 possible combinations:
+
+- 28
+- 37
+
+19 and 46 are not possible due to the 1 and 4 in the column according to standard Sudoku rules.
+
+![Sudoku grid, all squares empty except for the middle column, column 5, which has 8 rows filled. The first row contains a 4, the second is empty, and the third contains a 1. The 1 is highlighted in red to indicate a mistake. The last 6 rows in the column form killer cages of two cells each. From top to bottom: first group is a cell with value 2 and a pencil mark indicating a cage sum of 10, cell with value 8. Second group is a cell with value 3 and a pencil mark of 10, cell with value 7. Third group is a cell with value 1, highlighted in red, and a pencil mark of 10, cell with value 9.](https://media.githubusercontent.com/media/exercism/v3-files/main/julia/killer-sudoku-helper/example3.png)
+
+## Trying it yourself
+
+If you want to give an approachable Killer Sudoku a go, you can try out [this puzzle](https://app.crackingthecryptic.com/sudoku/HqTBn3Pr6R) by Clover, featured by [Mark Goodliffe on Cracking The Cryptic on the 21st of June 2021](https://youtu.be/c_NjEbFEeW0?t=1180).
+
+You can also find Killer Sudokus in varying difficulty in numerous newspapers, as well as Sudoku apps, books and websites.
+
+## Credit
+
+The screenshots above have been generated using [F-Puzzles.com](https://www.f-puzzles.com/), a Puzzle Setting Tool by Eric Fox.

exercises/practice/killer-sudoku-helper/.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

exercises/practice/killer-sudoku-helper/.gitignore

@@ -0,0 +1,24 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+killer_sudoku_helper-*.tar
+

exercises/practice/killer-sudoku-helper/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "jiegillet"
+  ],
+  "files": {
+    "solution": [
+      "lib/killer_sudoku_helper.ex"
+    ],
+    "test": [
+      "test/killer_sudoku_helper_test.exs"
+    ],
+    "example": [
+      ".meta/example.ex"
+    ]
+  },
+  "blurb": "Write a tool that makes it easier to solve Killer Sudokus",
+  "source": "Created by Sascha Mann, Jeremy Walker, and BethanyG for the Julia track on Exercism.",
+  "source_url": "https://github.com/exercism/julia/pull/413"
+}

exercises/practice/killer-sudoku-helper/.meta/example.ex

@@ -0,0 +1,26 @@
+defmodule KillerSudokuHelper do
+  @doc """
+  Return the possible combinations of `size` distinct numbers from 1-9 excluding `exclude` that sum up to `sum`.
+  """
+  @spec combinations(cage :: %{exclude: [integer], size: integer, sum: integer}) :: [[integer]]
+  def combinations(%{exclude: exclude, size: size, sum: sum}) do
+    numbers = [9, 8, 7, 6, 5, 4, 3, 2, 1] -- exclude
+
+    do_combinations(numbers, size, [[]])
+    |> Enum.filter(&(Enum.sum(&1) == sum))
+  end
+
+  defp do_combinations(_numbers, 0, list), do: list
+
+  defp do_combinations(numbers, size, list) do
+    numbers
+    |> tails()
+    |> Enum.map(fn [head | tail] ->
+      do_combinations(tail, size - 1, Enum.map(list, &[head | &1]))
+    end)
+    |> Enum.concat()
+  end
+
+  defp tails([]), do: []
+  defp tails([_ | tail] = list), do: [list | tails(tail)]
+end

exercises/practice/killer-sudoku-helper/.meta/tests.toml

@@ -0,0 +1,49 @@
+# 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.
+
+[2aaa8f13-11b5-4054-b95c-a906e4d79fb6]
+description = "Trivial 1-digit cages -> 1"
+
+[4645da19-9fdd-4087-a910-a6ed66823563]
+description = "Trivial 1-digit cages -> 2"
+
+[07cfc704-f8aa-41b2-8f9a-cbefb674cb48]
+description = "Trivial 1-digit cages -> 3"
+
+[22b8b2ba-c4fd-40b3-b1bf-40aa5e7b5f24]
+description = "Trivial 1-digit cages -> 4"
+
+[b75d16e2-ff9b-464d-8578-71f73094cea7]
+description = "Trivial 1-digit cages -> 5"
+
+[bcbf5afc-4c89-4ff6-9357-07ab4d42788f]
+description = "Trivial 1-digit cages -> 6"
+
+[511b3bf8-186f-4e35-844f-c804d86f4a7a]
+description = "Trivial 1-digit cages -> 7"
+
+[bd09a60d-3aca-43bd-b6aa-6ccad01bedda]
+description = "Trivial 1-digit cages -> 8"
+
+[9b539f27-44ea-4ff8-bd3d-c7e136bee677]
+description = "Trivial 1-digit cages -> 9"
+
+[0a8b2078-b3a4-4dbd-be0d-b180f503d5c3]
+description = "Cage with sum 45 contains all digits 1:9"
+
+[2635d7c9-c716-4da1-84f1-c96e03900142]
+description = "Cage with only 1 possible combination"
+
+[a5bde743-e3a2-4a0c-8aac-e64fceea4228]
+description = "Cage with several combinations"
+
+[dfbf411c-737d-465a-a873-ca556360c274]
+description = "Cage with several combinations that is restricted"

exercises/practice/killer-sudoku-helper/lib/killer_sudoku_helper.ex

@@ -0,0 +1,8 @@
+defmodule KillerSudokuHelper do
+  @doc """
+  Return the possible combinations of `size` distinct numbers from 1-9 excluding `exclude` that sum up to `sum`.
+  """
+  @spec combinations(cage :: %{exclude: [integer], size: integer, sum: integer}) :: [[integer]]
+  def combinations(cage) do
+  end
+end

exercises/practice/killer-sudoku-helper/mix.exs

@@ -0,0 +1,28 @@
+defmodule KillerSudokuHelper.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :killer_sudoku_helper,
+      version: "0.1.0",
+      # elixir: "~> 1.8",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      # {:dep_from_hexpm, "~> 0.3.0"},
+      # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"}
+    ]
+  end
+end

exercises/practice/killer-sudoku-helper/test/killer_sudoku_helper_test.exs

@@ -0,0 +1,83 @@
+defmodule KillerSudokuHelperTest do
+  use ExUnit.Case
+
+  describe "Trivial 1-digit cages" do
+    # @tag :pending
+    test "1" do
+      cage = %{exclude: [], size: 1, sum: 1}
+      assert KillerSudokuHelper.combinations(cage) == [[1]]
+    end
+
+    @tag :pending
+    test "2" do
+      cage = %{exclude: [], size: 1, sum: 2}
+      assert KillerSudokuHelper.combinations(cage) == [[2]]
+    end
+
+    @tag :pending
+    test "3" do
+      cage = %{exclude: [], size: 1, sum: 3}
+      assert KillerSudokuHelper.combinations(cage) == [[3]]
+    end
+
+    @tag :pending
+    test "4" do
+      cage = %{exclude: [], size: 1, sum: 4}
+      assert KillerSudokuHelper.combinations(cage) == [[4]]
+    end
+
+    @tag :pending
+    test "5" do
+      cage = %{exclude: [], size: 1, sum: 5}
+      assert KillerSudokuHelper.combinations(cage) == [[5]]
+    end
+
+    @tag :pending
+    test "6" do
+      cage = %{exclude: [], size: 1, sum: 6}
+      assert KillerSudokuHelper.combinations(cage) == [[6]]
+    end
+
+    @tag :pending
+    test "7" do
+      cage = %{exclude: [], size: 1, sum: 7}
+      assert KillerSudokuHelper.combinations(cage) == [[7]]
+    end
+
+    @tag :pending
+    test "8" do
+      cage = %{exclude: [], size: 1, sum: 8}
+      assert KillerSudokuHelper.combinations(cage) == [[8]]
+    end
+
+    @tag :pending
+    test "9" do
+      cage = %{exclude: [], size: 1, sum: 9}
+      assert KillerSudokuHelper.combinations(cage) == [[9]]
+    end
+  end
+
+  @tag :pending
+  test "Cage with sum 45 contains all digits 1:9" do
+    cage = %{exclude: [], size: 9, sum: 45}
+    assert KillerSudokuHelper.combinations(cage) == [[1, 2, 3, 4, 5, 6, 7, 8, 9]]
+  end
+
+  @tag :pending
+  test "Cage with only 1 possible combination" do
+    cage = %{exclude: [], size: 3, sum: 7}
+    assert KillerSudokuHelper.combinations(cage) == [[1, 2, 4]]
+  end
+
+  @tag :pending
+  test "Cage with several combinations" do
+    cage = %{exclude: [], size: 2, sum: 10}
+    assert KillerSudokuHelper.combinations(cage) == [[1, 9], [2, 8], [3, 7], [4, 6]]
+  end
+
+  @tag :pending
+  test "Cage with several combinations that is restricted" do
+    cage = %{exclude: [1, 4], size: 2, sum: 10}
+    assert KillerSudokuHelper.combinations(cage) == [[2, 8], [3, 7]]
+  end
+end