trackler 2.2.1.44 → 2.2.1.45

data/tracks/elm/config.json

@@ -322,6 +322,26 @@
 
       ]
     },
+    {
+      "uuid": "1f52ab74-02d5-db80-8f95-521aba04d183e704422",
+      "slug": "collatz-conjecture",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+
+      ]
+    },
+    {
+      "uuid": "7890045d-0cf5-1980-21ae-7bd0228ad2a2993ae82",
+      "slug": "all-your-base",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "a730ca85-057d-db80-e44e-25b8028acede6337cca",
       "slug": "pascals-triangle",
@@ -332,6 +352,16 @@
         "Lists",
         "Control-flow"
       ]
+    },
+    {
+      "uuid": "5f540090-061e-2f80-40a8-d9782700ed2efdf8965",
+      "slug": "isogram",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "Lists"
+      ]
     }
   ],
   "foregone": [

data/tracks/elm/exercises/all-your-base/AllYourBase.elm

@@ -0,0 +1 @@
+module AllYourBase exposing (..)

data/tracks/elm/exercises/all-your-base/AllYourBase.example.elm

@@ -0,0 +1,68 @@
+module AllYourBase exposing (..)
+
+import List
+
+
+fromBase : Int -> List Int -> Maybe Int
+fromBase base =
+    let
+        f x m =
+            case m of
+                Nothing ->
+                    Nothing
+
+                Just n ->
+                    if x >= 0 && x < base then
+                        Just (n * base + x)
+                    else
+                        Nothing
+    in
+        List.foldl f (Just 0)
+
+
+toBase : Int -> Int -> List Int
+toBase base =
+    let
+        divMod a b =
+            ( a // b, a % b )
+
+        swap ( a, b ) =
+            ( b, a )
+
+        unfold f b =
+            case f b of
+                Just ( a, b_ ) ->
+                    a :: unfold f b_
+
+                Nothing ->
+                    []
+
+        f x =
+            case x of
+                0 ->
+                    Nothing
+
+                _ ->
+                    Just (swap (divMod x base))
+    in
+        List.reverse << (unfold f)
+
+
+rebase : Int -> List Int -> Int -> Maybe (List Int)
+rebase inBase digits outBase =
+    let
+        length =
+            List.length digits
+
+        numZeros =
+            List.length (List.filter (\x -> x == 0) digits)
+    in
+        if inBase < 2 || outBase < 2 || length == 0 || length == numZeros then
+            Nothing
+        else
+            case fromBase inBase digits of
+                Just v ->
+                    Just (toBase outBase v)
+
+                Nothing ->
+                    Nothing

data/tracks/elm/exercises/all-your-base/README.md

@@ -0,0 +1,65 @@
+# All Your Base
+
+Convert a number, represented as a sequence of digits in one base, to any other base.
+
+Implement general base conversion. Given a number in base **a**,
+represented as a sequence of digits, convert it to base **b**.
+
+## Note
+
+- Try to implement the conversion yourself.
+  Do not use something else to perform the conversion for you.
+
+## About [Positional Notation](https://en.wikipedia.org/wiki/Positional_notation)
+
+In positional notation, a number in base **b** can be understood as a linear
+combination of powers of **b**.
+
+The number 42, *in base 10*, means:
+
+(4 * 10^1) + (2 * 10^0)
+
+The number 101010, *in base 2*, means:
+
+(1 * 2^5) + (0 * 2^4) + (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (0 * 2^0)
+
+The number 1120, *in base 3*, means:
+
+(1 * 3^3) + (1 * 3^2) + (2 * 3^1) + (0 * 3^0)
+
+I think you got the idea!
+
+*Yes. Those three numbers above are exactly the same. Congratulations!*
+
+## 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!
+
+
+## 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/all-your-base/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/all-your-base/tests/Tests.elm

@@ -0,0 +1,53 @@
+module Tests exposing (..)
+
+import Test exposing (..)
+import Expect
+import AllYourBase exposing (rebase)
+
+
+tests : Test
+tests =
+    describe "all-your-base"
+        [ test "single bit one to decimal" <|
+            \() -> Expect.equal (Just [ 1 ]) (rebase 2 [ 1 ] 10)
+        , test "binary to single decimal" <|
+            \() -> Expect.equal (Just [ 5 ]) (rebase 2 [ 1, 0, 1 ] 10)
+        , test "single decimal to binary" <|
+            \() -> Expect.equal (Just [ 1, 0, 1 ]) (rebase 10 [ 5 ] 2)
+        , test "binary to multiple decimal" <|
+            \() -> Expect.equal (Just [ 4, 2 ]) (rebase 2 [ 1, 0, 1, 0, 1, 0 ] 10)
+        , test "decimal to binary" <|
+            \() -> Expect.equal (Just [ 1, 0, 1, 0, 1, 0 ]) (rebase 10 [ 4, 2 ] 2)
+        , test "trinary to hexadecimal" <|
+            \() -> Expect.equal (Just [ 2, 10 ]) (rebase 3 [ 1, 1, 2, 0 ] 16)
+        , test "hexadecimal to trinary" <|
+            \() -> Expect.equal (Just [ 1, 1, 2, 0 ]) (rebase 16 [ 2, 10 ] 3)
+        , test "15-bit integer" <|
+            \() -> Expect.equal (Just [ 6, 10, 45 ]) (rebase 97 [ 3, 46, 60 ] 73)
+        , test "empty list" <|
+            \() -> Expect.equal Nothing (rebase 2 [] 10)
+        , test "single zero" <|
+            \() -> Expect.equal Nothing (rebase 10 [ 0 ] 2)
+        , test "multiple zeros" <|
+            \() -> Expect.equal Nothing (rebase 10 [ 0, 0, 0 ] 2)
+        , test "leading zeros" <|
+            \() -> Expect.equal (Just [ 4, 2 ]) (rebase 7 [ 0, 6, 0 ] 10)
+        , test "first base is one" <|
+            \() -> Expect.equal Nothing (rebase 1 [] 10)
+        , test "first base is zero" <|
+            \() -> Expect.equal Nothing (rebase 0 [] 10)
+        , test "first base is negative" <|
+            \() -> Expect.equal Nothing (rebase -1 [] 10)
+        , test "negative digit" <|
+            \() -> Expect.equal Nothing (rebase 2 [ 1, -1, 1, 0, 1, 0 ] 10)
+        , test "invalid positive digit" <|
+            \() -> Expect.equal Nothing (rebase 2 [ 1, 2, 1, 0, 1, 0 ] 10)
+        , test "second base is one" <|
+            \() -> Expect.equal Nothing (rebase 10 [] 1)
+        , test "second base is zero" <|
+            \() -> Expect.equal Nothing (rebase 10 [ 1 ] 0)
+        , test "second base is negative" <|
+            \() -> Expect.equal Nothing (rebase 10 [ 1 ] -1)
+        , test "both bases are negative" <|
+            \() -> Expect.equal Nothing (rebase -1 [ 1 ] -1)
+        ]

data/tracks/elm/exercises/all-your-base/tests/elm-package.json

@@ -0,0 +1,16 @@
+{
+    "version": "3.0.0",
+    "summary": "Exercism problems in Elm.",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "BSD3",
+    "source-directories": [
+        ".",
+        ".."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0",
+        "elm-community/elm-test": "4.0.0 <= v < 5.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/elm/exercises/collatz-conjecture/CollatzConjecture.elm

@@ -0,0 +1,2 @@
+module CollatzConjecture exposing (..)
+

data/tracks/elm/exercises/collatz-conjecture/CollatzConjecture.example.elm

@@ -0,0 +1,19 @@
+module CollatzConjecture exposing (collatz)
+
+
+collatz : Int -> Result String Int
+collatz start =
+    if start <= 0 then
+        Err "Only positive numbers are allowed"
+    else
+        Ok (collatzHelper 0 start)
+
+
+collatzHelper : Int -> Int -> Int
+collatzHelper steps start =
+    if start == 1 then
+        steps
+    else if start % 2 == 0 then
+        collatzHelper (1 + steps) (start // 2)
+    else
+        collatzHelper (1 + steps) (3 * start + 1)

data/tracks/elm/exercises/collatz-conjecture/elm-package.json

@@ -0,0 +1,15 @@
+{
+    "version": "3.0.0",
+    "summary": "Exercism problems in Elm.",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "BSD3",
+    "source-directories": [
+        "."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}
+

data/tracks/elm/exercises/collatz-conjecture/package.json

@@ -0,0 +1,14 @@
+{
+    "description": "Exercism/Elm",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "MIT",
+    "scripts": {
+        "postinstall": "elm-package install -y",
+        "watch": "elm-test --watch",
+        "test": "elm-test"
+    },
+    "dependencies": {
+        "elm": "0.18.0",
+        "elm-test": "0.18.3"
+    }
+}

data/tracks/elm/exercises/collatz-conjecture/tests/Tests.elm

@@ -0,0 +1,38 @@
+module Tests exposing (..)
+
+import Test exposing (..)
+import Expect
+import CollatzConjecture exposing (collatz)
+
+
+tests : Test
+tests =
+    describe "CollatzConjecture tests"
+        [ test "zero steps for one" <|
+            \() ->
+                Expect.equal (Ok 0) (collatz 1)
+
+        -- Once you get the first test passing, remove the
+        -- `skip <|` (just leave the comma) on the next
+        -- lines to continue!
+        , skip <|
+            test "divide if even" <|
+                \() ->
+                    Expect.equal (Ok 4) (collatz 16)
+        , skip <|
+            test "even and odd step" <|
+                \() ->
+                    Expect.equal (Ok 9) (collatz 12)
+        , skip <|
+            test "Large number of even and odd step" <|
+                \() ->
+                    Expect.equal (Ok 152) (collatz 1000000)
+        , skip <|
+            test "zero is an error" <|
+                \() ->
+                    Expect.equal (Err "Only positive numbers are allowed") (collatz 0)
+        , skip <|
+            test "negative values is an error" <|
+                \() ->
+                    Expect.equal (Err "Only positive numbers are allowed") (collatz -15)
+        ]

data/tracks/elm/exercises/collatz-conjecture/tests/elm-package.json

@@ -0,0 +1,16 @@
+{
+    "version": "3.0.0",
+    "summary": "Exercism problems in Elm.",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "BSD3",
+    "source-directories": [
+        ".",
+        ".."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0",
+        "elm-community/elm-test": "4.0.0 <= v < 5.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/elm/exercises/isogram/Isogram.elm

@@ -0,0 +1 @@
+module Isogram exposing (..)

data/tracks/elm/exercises/isogram/Isogram.example.elm

@@ -0,0 +1,76 @@
+module Isogram exposing (isIsogram)
+
+import String
+import List
+import Char
+
+
+isLetter : Char -> Bool
+isLetter c =
+    Char.isHexDigit c && (not <| Char.isDigit c)
+
+
+isIsogram : String -> Bool
+isIsogram sentence =
+    let
+        sanitized =
+            String.filter isLetter sentence
+                |> String.toLower
+                |> String.toList
+                |> List.sort
+                |> group
+    in
+        List.all (\x -> List.length x == 1) sanitized
+
+
+
+-- Adapted from https://github.com/elm-community/list-extra
+
+
+group : List a -> List (List a)
+group list =
+    case list of
+        [] ->
+            []
+
+        x :: xs ->
+            let
+                ( ys, zs ) =
+                    span ((==) x) xs
+            in
+                (x :: ys) :: group zs
+
+
+span : (a -> Bool) -> List a -> ( List a, List a )
+span p xs =
+    ( takeWhile p xs, dropWhile p xs )
+
+
+takeWhile : (a -> Bool) -> List a -> List a
+takeWhile predicate =
+    let
+        takeWhileHelper acc list =
+            case list of
+                [] ->
+                    List.reverse acc
+
+                x :: xs ->
+                    if (predicate x) then
+                        takeWhileHelper (x :: acc) xs
+                    else
+                        List.reverse acc
+    in
+        takeWhileHelper []
+
+
+dropWhile : (a -> Bool) -> List a -> List a
+dropWhile predicate list =
+    case list of
+        [] ->
+            []
+
+        x :: xs ->
+            if (predicate x) then
+                dropWhile predicate xs
+            else
+                list

data/tracks/elm/exercises/isogram/README.md

@@ -0,0 +1,50 @@
+# Isogram
+
+Determine if a word or phrase is an isogram.
+
+An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter, however spaces and hyphens are allowed to appear multiple times.
+
+Examples of isograms:
+
+- lumberjacks
+- background
+- downstream
+- six-year-old
+
+The word *isograms*, however, is not an isogram, because the s repeats.
+
+## 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 [https://en.wikipedia.org/wiki/Isogram](https://en.wikipedia.org/wiki/Isogram)
+
+## 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/isogram/elm-package.json

@@ -0,0 +1,14 @@
+{
+    "version": "3.0.0",
+    "summary": "Exercism problems in Elm.",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "BSD3",
+    "source-directories": [
+        "."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/elm/exercises/isogram/package.json

@@ -0,0 +1,14 @@
+{
+    "description": "Exercism/Elm",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "MIT",
+    "scripts": {
+        "postinstall": "elm-package install -y",
+        "watch": "elm-test --watch",
+        "test": "elm-test"
+    },
+    "dependencies": {
+        "elm": "0.18.0",
+        "elm-test": "0.18.3"
+    }
+}

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

@@ -0,0 +1,46 @@
+module Tests exposing (..)
+
+import Test exposing (..)
+import Expect
+import Isogram exposing (isIsogram)
+
+
+tests : Test
+tests =
+    describe "Isogram"
+        [ test "empty string" <|
+            \() ->
+                Expect.equal True <| isIsogram ""
+        , skip <|
+            test "isogram with only lower case characters" <|
+                \() ->
+                    Expect.equal True <| isIsogram "isogram"
+        , skip <|
+            test "word with one duplicated character" <|
+                \() ->
+                    Expect.equal False <| isIsogram "eleven"
+        , skip <|
+            test "longest reported english isogram" <|
+                \() ->
+                    Expect.equal True <| isIsogram "subdermatoglyphic"
+        , skip <|
+            test "word with duplicated character in mixed case" <|
+                \() ->
+                    Expect.equal False <| isIsogram "Alphabet"
+        , skip <|
+            test "hypothetical isogrammic word with hyphen" <|
+                \() ->
+                    Expect.equal True <| isIsogram "thumbscrew-japingly"
+        , skip <|
+            test "isogram with duplicated non letter character" <|
+                \() ->
+                    Expect.equal True <| isIsogram "Hjelmqvist-Gryb-Zock-Pfund-Wax"
+        , skip <|
+            test "made-up name that is an isogram" <|
+                \() ->
+                    Expect.equal True <| isIsogram "Emily Jung Schwartzkopf"
+        , skip <|
+            test "duplicated character in the middle" <|
+                \() ->
+                    Expect.equal False <| isIsogram "accentor"
+        ]

data/tracks/elm/exercises/isogram/tests/elm-package.json

@@ -0,0 +1,16 @@
+{
+    "version": "3.0.0",
+    "summary": "Exercism problems in Elm.",
+    "repository": "https://github.com/exercism/elm.git",
+    "license": "BSD3",
+    "source-directories": [
+        ".",
+        ".."
+    ],
+    "exposed-modules": [],
+    "dependencies": {
+        "elm-lang/core": "5.0.0 <= v < 6.0.0",
+        "elm-community/elm-test": "4.0.0 <= v < 5.0.0"
+    },
+    "elm-version": "0.18.0 <= v < 0.19.0"
+}

data/tracks/fsharp/.gitignore

@@ -8,4 +8,5 @@ tools/
 .paket/paket.exe
 paket-files
 .idea/
-.vs/
+.vs/
+.vscode/

data/tracks/fsharp/exercises/accumulate/Accumulate.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>

data/tracks/fsharp/exercises/acronym/Acronym.fs

@@ -1,3 +1,3 @@
 module Acronym
 
-let acronym phrase = failwith "You need to implement this function."
+let abbreviate phrase = failwith "You need to implement this function."

data/tracks/fsharp/exercises/acronym/Acronym.fsproj

@@ -14,9 +14,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
-    <PackageReference Include="xunit" Version="2.3.0-beta5-build3769" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta5-build3769" />
+    <PackageReference Include="xunit" Version="2.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0" />
     <PackageReference Include="FsUnit.xUnit" Version="3.0.0" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0" />
   </ItemGroup>
 
 </Project>