Add Knapsack

config.json

@@ -1310,6 +1310,18 @@
           "custom-types"
         ],
         "difficulty": 6
+      },
+      {
+        "slug": "knapsack",
+        "name": "Knapsack",
+        "uuid": "9bf186d3-e904-42f2-a705-dffbe98adb08",
+        "practices": [],
+        "prerequisites": [
+          "comparison",
+          "lists",
+          "records"
+        ],
+        "difficulty": 6
       }
     ]
   },

exercises/practice/knapsack/.docs/instructions.md

@@ -0,0 +1,25 @@
+# Instructions
+
+Your task is to determine which items to take so that the total value of his selection is maximized, taking into account the knapsack's carrying capacity.
+
+Items will be represented as a list of items.
+Each item will have a weight and value.
+All values given will be strictly positive.
+Bob can take only one of each item.
+
+For example:
+
+```text
+Items: [
+  { "weight": 5, "value": 10 },
+  { "weight": 4, "value": 40 },
+  { "weight": 6, "value": 30 },
+  { "weight": 4, "value": 50 }
+]
+
+Knapsack Maximum Weight: 10
+```
+
+For the above, the first item has weight 5 and value 10, the second item has weight 4 and value 40, and so on.
+In this example, Bob should take the second and fourth item to maximize his value, which, in this case, is 90.
+He cannot get more than 90 as his knapsack has a weight limit of 10.

exercises/practice/knapsack/.docs/introduction.md

@@ -0,0 +1,8 @@
+# Introduction
+
+Bob is a thief.
+After months of careful planning, he finally manages to crack the security systems of a fancy store.
+
+In front of him are many items, each with a value and weight.
+Bob would gladly take all of the items, but his knapsack can only hold so much weight.
+Bob has to carefully consider which items to take so that the total value of his selection is maximized.

exercises/practice/knapsack/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "kahgoh"
+  ],
+  "files": {
+    "solution": [
+      "src/Knapsack.elm"
+    ],
+    "test": [
+      "tests/Tests.elm"
+    ],
+    "example": [
+      ".meta/src/Knapsack.example.elm"
+    ]
+  },
+  "blurb": "Given a knapsack that can only carry a certain weight, determine which items to put in the knapsack in order to maximize their combined value.",
+  "source": "Wikipedia",
+  "source_url": "https://en.wikipedia.org/wiki/Knapsack_problem"
+}

exercises/practice/knapsack/.meta/src/Knapsack.example.elm

@@ -0,0 +1,64 @@
+module Knapsack exposing (Item, maximumValue)
+
+
+type alias Item =
+    { value : Int
+    , weight : Int
+    }
+
+
+maximumValue : Int -> List Item -> Int
+maximumValue capacity items =
+    doMaximumValue items (List.repeat (capacity + 1) 0)
+
+
+last : List Int -> Int
+last list =
+    List.foldl (\x _ -> x) 0 list
+
+
+valueAt : List a -> Int -> Result String a
+valueAt list index =
+    case list of
+        [] -> Err "Index out of bounds"
+        n :: rem -> if index = 0 then n else valueAt rem (index - 1)
+
+
+nextRow : Item -> List Int -> List Int
+nextRow item lastRow =
+    List.indexedMap
+        (\cap val ->
+            let
+                req =
+                    cap - item.weight
+            in
+            if req < 0 then
+                val
+
+            else
+                case valueAt lastRow req of
+                    Ok v ->
+                        let
+                            withItem =
+                                v + item.value
+                        in
+                        if withItem > val then
+                            withItem
+
+                        else
+                            val
+
+                    Err _ ->
+                        val
+        )
+        lastRow
+
+
+doMaximumValue : List Item -> List Int -> Int
+doMaximumValue items lastRow =
+    case items of
+        [] ->
+            last lastRow
+
+        n :: rest ->
+            doMaximumValue rest (nextRow n lastRow)

exercises/practice/knapsack/.meta/tests.toml

@@ -0,0 +1,36 @@
+# 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.
+
+[a4d7d2f0-ad8a-460c-86f3-88ba709d41a7]
+description = "no items"
+include = false
+
+[3993a824-c20e-493d-b3c9-ee8a7753ee59]
+description = "no items"
+reimplements = "a4d7d2f0-ad8a-460c-86f3-88ba709d41a7"
+
+[1d39e98c-6249-4a8b-912f-87cb12e506b0]
+description = "one item, too heavy"
+
+[833ea310-6323-44f2-9d27-a278740ffbd8]
+description = "five items (cannot be greedy by weight)"
+
+[277cdc52-f835-4c7d-872b-bff17bab2456]
+description = "five items (cannot be greedy by value)"
+
+[81d8e679-442b-4f7a-8a59-7278083916c9]
+description = "example knapsack"
+
+[f23a2449-d67c-4c26-bf3e-cde020f27ecc]
+description = "8 items"
+
+[7c682ae9-c385-4241-a197-d2fa02c81a11]
+description = "15 items"

exercises/practice/knapsack/elm.json

@@ -0,0 +1,29 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src"
+    ],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "elm/core": "1.0.5",
+            "elm/json": "1.1.3",
+            "elm/parser": "1.1.0",
+            "elm/random": "1.0.0",
+            "elm/regex": "1.0.0",
+            "elm/time": "1.0.0"
+        },
+        "indirect": {}
+    },
+    "test-dependencies": {
+        "direct": {
+            "elm-explorations/test": "2.1.0",
+            "rtfeldman/elm-iso8601-date-strings": "1.1.4"
+        },
+        "indirect": {
+            "elm/bytes": "1.0.8",
+            "elm/html": "1.0.0",
+            "elm/virtual-dom": "1.0.3"
+        }
+    }
+}

exercises/practice/knapsack/src/Knapsack.elm

@@ -0,0 +1,12 @@
+module Knapsack exposing (Item, maximumValue)
+
+
+type alias Item =
+    { value : Int
+    , weight : Int
+    }
+
+
+maximumValue : Int -> List Item -> Int
+maximumValue capacity items =
+    Debug.todo "Please implement this function"

exercises/practice/knapsack/tests/Tests.elm

@@ -0,0 +1,85 @@
+module Tests exposing (tests)
+
+import Expect
+import Knapsack exposing (..)
+import Test exposing (..)
+
+
+tests : Test
+tests =
+    describe "Knapsack"
+        [ test "no items" <|
+            \() ->
+                Expect.equal 0 <| maximumValue 100 []
+        , skip <|
+            test "one item, too heavy" <|
+                \() ->
+                    Expect.equal 0 <| maximumValue 10 [ { weight = 100, value = 1 } ]
+        , skip <|
+            test "five items (cannot be greedy by weight)" <|
+                \() ->
+                    Expect.equal 21 <|
+                        maximumValue 10
+                            [ { weight = 2, value = 5 }
+                            , { weight = 2, value = 5 }
+                            , { weight = 2, value = 5 }
+                            , { weight = 2, value = 5 }
+                            , { weight = 10, value = 21 }
+                            ]
+        , skip <|
+            test "five items (cannot be greedy by value)" <|
+                \() ->
+                    Expect.equal 80 <|
+                        maximumValue 10
+                            [ { weight = 2, value = 20 }
+                            , { weight = 2, value = 20 }
+                            , { weight = 2, value = 20 }
+                            , { weight = 2, value = 20 }
+                            , { weight = 10, value = 50 }
+                            ]
+        , skip <|
+            test "example knapsack" <|
+                \() ->
+                    Expect.equal 90 <|
+                        maximumValue 10
+                            [ { weight = 5, value = 10 }
+                            , { weight = 4, value = 40 }
+                            , { weight = 6, value = 30 }
+                            , { weight = 4, value = 50 }
+                            ]
+        , skip <|
+            test "8 items" <|
+                \() ->
+                    Expect.equal 900 <|
+                        maximumValue 104
+                            [ { weight = 25, value = 350 }
+                            , { weight = 35, value = 400 }
+                            , { weight = 45, value = 450 }
+                            , { weight = 5, value = 20 }
+                            , { weight = 25, value = 70 }
+                            , { weight = 3, value = 8 }
+                            , { weight = 2, value = 5 }
+                            , { weight = 2, value = 5 }
+                            ]
+        , skip <|
+            test "15 items" <|
+                \() ->
+                    Expect.equal 1458 <|
+                        maximumValue 750
+                            [ { weight = 70, value = 135 }
+                            , { weight = 73, value = 139 }
+                            , { weight = 77, value = 149 }
+                            , { weight = 80, value = 150 }
+                            , { weight = 82, value = 156 }
+                            , { weight = 87, value = 163 }
+                            , { weight = 90, value = 173 }
+                            , { weight = 94, value = 184 }
+                            , { weight = 98, value = 192 }
+                            , { weight = 106, value = 201 }
+                            , { weight = 110, value = 210 }
+                            , { weight = 113, value = 214 }
+                            , { weight = 115, value = 221 }
+                            , { weight = 118, value = 229 }
+                            , { weight = 120, value = 240 }
+                            ]
+        ]