trackler 2.2.1.107 → 2.2.1.108

data/tracks/ecmascript/exercises/strain/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/sublist/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/sum-of-multiples/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/transpose/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/triangle/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/trinary/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/twelve-days/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/two-bucket/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/two-fer/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/word-count/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/word-search/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/exercises/wordy/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/ecmascript/package.json

@@ -25,8 +25,7 @@
     ]
   },
   "babel": {
-    "presets": [
-      "env"
+    "presets": [["env",{"node": "current"}]
     ],
     "plugins": [
       [

data/tracks/elm/config.json

@@ -354,7 +354,7 @@
       ]
     },
     {
-      "uuid": "6b6e9f4d-9c45-4d8c-9e8e-b2144204d2da",
+      "uuid": "5f540090-061e-2f80-40a8-d9782700ed2efdf8965",
       "slug": "isogram",
       "core": false,
       "unlocked_by": null,
@@ -362,6 +362,18 @@
       "topics": [
         "Lists"
       ]
+    },
+    {
+      "uuid": "1F9FE5BC-8213-44FD-B7D1-5D4CC7F3A475",
+      "slug": "binary-search",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 7,
+      "topics": [
+        "algorithms",
+        "arrays",
+        "recursion"
+      ]
     }
   ],
   "foregone": [

data/tracks/elm/exercises/binary-search/BinarySearch.elm

@@ -0,0 +1,9 @@
+module BinarySearch exposing (find)
+
+import Array exposing (Array)
+
+
+find : Int -> Array Int -> Int
+find target xs =
+    -- TODO:
+    -1

data/tracks/elm/exercises/binary-search/BinarySearch.example.elm

@@ -0,0 +1,36 @@
+module BinarySearch exposing (find)
+
+import Array exposing (Array)
+
+
+find : Int -> Array Int -> Int
+find target xs =
+    find_ 0 (Array.length xs) target xs
+
+
+find_ : Int -> Int -> Int -> Array Int -> Int
+find_ i0 i1 target xs =
+    let
+        i =
+            (i1 + i0) // 2
+
+        isEqual =
+            Array.get i xs
+                |> (==) (Just target)
+
+        isLessThan =
+            Array.get i xs
+                |> Maybe.map ((<) target)
+    in
+    case ( isEqual, isLessThan, i0 > i1 ) of
+        ( True, _, _ ) ->
+            i
+
+        ( False, Just True, False ) ->
+            find_ i0 (i - 1) target xs
+
+        ( False, Just False, False ) ->
+            find_ (i + 1) i1 target xs
+
+        _ ->
+            -1

data/tracks/elm/exercises/binary-search/README.md

@@ -0,0 +1,71 @@
+# Binary Search
+
+Implement a binary search algorithm.
+
+Searching a sorted collection is a common task. A dictionary is a sorted
+list of word definitions. Given a word, one can find its definition. A
+telephone book is a sorted list of people's names, addresses, and
+telephone numbers. Knowing someone's name allows one to quickly find
+their telephone number and address.
+
+If the list to be searched contains more than a few items (a dozen, say)
+a binary search will require far fewer comparisons than a linear search,
+but it imposes the requirement that the list be sorted.
+
+In computer science, a binary search or half-interval search algorithm
+finds the position of a specified input value (the search "key") within
+an array sorted by key value.
+
+In each step, the algorithm compares the search key value with the key
+value of the middle element of the array.
+
+If the keys match, then a matching element has been found and its index,
+or position, is returned.
+
+Otherwise, if the search key is less than the middle element's key, then
+the algorithm repeats its action on the sub-array to the left of the
+middle element or, if the search key is greater, on the sub-array to the
+right.
+
+If the remaining array to be searched is empty, then the key cannot be
+found in the array and a special "not found" indication is returned.
+
+A binary search halves the number of items to check with each iteration,
+so locating an item (or determining its absence) takes logarithmic time.
+A binary search is a dichotomic divide and conquer search algorithm.
+
+## Elm Installation
+
+Refer to the [Exercism help page](http://exercism.io/languages/elm) for Elm
+installation and learning resources.
+
+## Writing the Code
+
+The first time you start an exercise, you'll need to ensure you have the
+appropriate dependencies installed.
+
+```bash
+$ npm install
+```
+
+Execute the tests with:
+
+```bash
+$ npm test
+```
+
+Automatically run tests again when you save changes:
+
+```bash
+$ npm run watch
+```
+
+As you work your way through the test suite, be sure to remove the `skip <|`
+calls from each test until you get them all passing!
+
+## Source
+
+Wikipedia [http://en.wikipedia.org/wiki/Binary_search_algorithm](http://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elm/exercises/binary-search/elm-package.json

@@ -0,0 +1,15 @@
+{
+    "version": "1.0.0",
+    "summary": "helpful summary of your project, less than 80 characters",
+    "repository": "https://github.com/user/project.git",
+    "license": "BSD3",
+    "source-directories": [
+        "."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.1.1 <= v < 6.0.0",
+        "elm-lang/html": "2.0.0 <= v < 3.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/elm/exercises/binary-search/tests/Tests.elm

@@ -0,0 +1,66 @@
+module Tests exposing (tests)
+
+import Array
+import BinarySearch exposing (find)
+import Expect
+import Fuzz exposing (Fuzzer)
+import Test exposing (Test, describe, skip, test)
+
+
+tests : Test
+tests =
+    describe "binarySearch"
+        [ test "finds a value in an array with one element" <|
+            \() ->
+                Array.fromList [ 6 ]
+                    |> find 6
+                    |> Expect.equal 0
+        , skip <|
+            test "finds a value in the middle of an array" <|
+                \() ->
+                    Array.fromList [ 1, 3, 4, 6, 8, 9, 11 ]
+                        |> find 6
+                        |> Expect.equal 3
+        , skip <|
+            test "finds a value at the beginning of an array" <|
+                \() ->
+                    Array.fromList [ 1, 3, 4, 6, 8, 9, 11 ]
+                        |> find 1
+                        |> Expect.equal 0
+        , skip <|
+            test "finds a value in an array of odd length" <|
+                \() ->
+                    Array.fromList [ 1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 634 ]
+                        |> find 144
+                        |> Expect.equal 9
+        , skip <|
+            test "finds a value in an array of even length" <|
+                \() ->
+                    Array.fromList [ 1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377 ]
+                        |> find 21
+                        |> Expect.equal 5
+        , skip <|
+            test "identifies that a value is not included in the array" <|
+                \() ->
+                    Array.fromList [ 1, 3, 4, 6, 8, 9, 11 ]
+                        |> find 7
+                        |> Expect.equal -1
+        , skip <|
+            test "a value smaller than the array's smallest value is not included" <|
+                \() ->
+                    Array.fromList [ 1, 3, 4, 6, 8, 9, 11 ]
+                        |> find 0
+                        |> Expect.equal -1
+        , skip <|
+            test "a value larger than the array's largest value is not included" <|
+                \() ->
+                    Array.fromList [ 1, 3, 4, 6, 8, 9, 11 ]
+                        |> find 13
+                        |> Expect.equal -1
+        , skip <|
+            test "nothing is included in an empty array" <|
+                \() ->
+                    Array.empty
+                        |> find 1
+                        |> Expect.equal -1
+        ]

data/tracks/elm/exercises/binary-search/tests/elm-package.json

@@ -0,0 +1,17 @@
+{
+    "version": "1.0.0",
+    "summary": "helpful summary of your project, less than 80 characters",
+    "repository": "https://github.com/user/project.git",
+    "license": "BSD3",
+    "source-directories": [
+        ".",
+        ".."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-community/elm-test": "4.2.0 <= v < 5.0.0",
+        "elm-lang/core": "5.1.1 <= v < 6.0.0",
+        "elm-lang/html": "2.0.0 <= v < 3.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/elm/exercises/hamming/Hamming.example.elm

@@ -3,12 +3,12 @@ module Hamming exposing (..)
 import String exposing (length, toList)
 
 
-distance : String -> String -> Maybe Int
+distance : String -> String -> Result String Int
 distance left right =
     if length left /= length right then
-        Nothing
+        Err "left and right strands must be of equal length"
     else
         List.map2 (\l r -> l /= r) (toList left) (toList right)
             |> List.filter identity
             |> List.length
-            |> Just
+            |> Ok

data/tracks/elm/exercises/hamming/tests/Tests.elm

@@ -9,44 +9,44 @@ tests : Test
 tests =
     describe "Hamming"
         [ test "identical strands" <|
-            \() -> Expect.equal (Just 0) (distance "A" "A")
+            \() -> Expect.equal (Ok 0) (distance "A" "A")
         , skip <|
             test "long identical strands" <|
-                \() -> Expect.equal (Just 0) (distance "GGACTGA" "GGACTGA")
+                \() -> Expect.equal (Ok 0) (distance "GGACTGA" "GGACTGA")
         , skip <|
             test "complete distance in single nucleotide strands" <|
-                \() -> Expect.equal (Just 1) (distance "A" "G")
+                \() -> Expect.equal (Ok 1) (distance "A" "G")
         , skip <|
             test "complete distance in small strands" <|
-                \() -> Expect.equal (Just 2) (distance "AG" "CT")
+                \() -> Expect.equal (Ok 2) (distance "AG" "CT")
         , skip <|
             test "small distance in small strands" <|
-                \() -> Expect.equal (Just 1) (distance "AT" "CT")
+                \() -> Expect.equal (Ok 1) (distance "AT" "CT")
         , skip <|
             test "small distance" <|
-                \() -> Expect.equal (Just 1) (distance "GGACG" "GGTCG")
+                \() -> Expect.equal (Ok 1) (distance "GGACG" "GGTCG")
         , skip <|
             test "small distance in long strands" <|
-                \() -> Expect.equal (Just 2) (distance "ACCAGGG" "ACTATGG")
+                \() -> Expect.equal (Ok 2) (distance "ACCAGGG" "ACTATGG")
         , skip <|
             test "non-unique character in first strand" <|
-                \() -> Expect.equal (Just 1) (distance "AGA" "AGG")
+                \() -> Expect.equal (Ok 1) (distance "AGA" "AGG")
         , skip <|
             test "non-unique character in second strand" <|
-                \() -> Expect.equal (Just 1) (distance "AGG" "AGA")
+                \() -> Expect.equal (Ok 1) (distance "AGG" "AGA")
         , skip <|
             test "large distance" <|
-                \() -> Expect.equal (Just 4) (distance "GATACA" "GCATAA")
+                \() -> Expect.equal (Ok 4) (distance "GATACA" "GCATAA")
         , skip <|
             test "large distance in off-by-one strand" <|
-                \() -> Expect.equal (Just 9) (distance "GGACGGATTCTG" "AGGACGGATTCT")
+                \() -> Expect.equal (Ok 9) (distance "GGACGGATTCTG" "AGGACGGATTCT")
         , skip <|
             test "empty strands" <|
-                \() -> Expect.equal (Just 0) (distance "" "")
+                \() -> Expect.equal (Ok 0) (distance "" "")
         , skip <|
             test "disallow first strand longer" <|
-                \() -> Expect.equal Nothing (distance "AATG" "AAA")
+                \() -> Expect.equal (Err "left and right strands must be of equal length") (distance "AATG" "AAA")
         , skip <|
             test "disallow second strand longer" <|
-                \() -> Expect.equal Nothing (distance "ATA" "AGTG")
+                \() -> Expect.equal (Err "left and right strands must be of equal length") (distance "ATA" "AGTG")
         ]