trackler 2.2.1.129 → 2.2.1.130

data/tracks/fsharp/exercises/go-counting/GoCountingTest.fs

@@ -1,78 +1,137 @@
-// This file was created manually and its version is 1.0.0.
+// This file was auto-generated based on version 1.0.0 of the canonical data.
 
 module GoCountingTest
 
-open System
-
-open Xunit
 open FsUnit.Xunit
+open Xunit
 
 open GoCounting
 
-let board5x5 =
-    ["  B  ";
-     " B B ";
-     "B W B";
-     " W W ";
-     "  W  "]
-
-let board9x9 =
-    ["  B   B  ";
-     "B   B   B";
-     "WBBBWBBBW";
-     "W W W W W";
-     "         ";
-     " W W W W ";
-     "B B   B B";
-     " W BBB W ";
-     "   B B   "]
-
 [<Fact>]
-let ``5x5 territory for black`` () =
-    let expected = Some (Some Black, [(0, 0); (0, 1); (1, 0)])
-    territoryFor board5x5 (0, 1) |> should equal expected
+let ``Black corner territory on 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (0, 1)
+    let expected = Option.Some (Owner.Black, [(0, 0); (0, 1); (1, 0)])
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``5x5 territory for white`` () =
-    let expected = Some (Some White, [(2, 3)])
-    territoryFor board5x5 (2, 3) |> should equal expected
+let ``White center territory on 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (2, 3)
+    let expected = Option.Some (Owner.White, [(2, 3)])
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``5x5 open territory`` () =
-    let expected = Some ((None: Color option), [(0, 3); (0, 4); (1, 4)])
-    territoryFor board5x5 (1, 4) |> should equal expected
+let ``Open corner territory on 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (1, 4)
+    let expected = Option.Some (Owner.None, [(0, 3); (0, 4); (1, 4)])
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``5x5 non-territory (stone)`` () =
-    territoryFor board5x5 (1, 1) |> should equal None
+let ``A stone and not a territory on 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (1, 1)
+    let expected: (Owner * (int * int) list) option = Option.Some (Owner.None, [])
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``5x5 non-territory (too low coordinate)`` () =
-    territoryFor board5x5 (-1, 1) |> should equal None
+let ``Invalid because X is too low for 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (-1, 1)
+    let expected = Option.None
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``5x5 non-territory (too high coordinate)`` () =
-    territoryFor board5x5 (1, 5) |> should equal None
+let ``Invalid because X is too high for 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (5, 1)
+    let expected = Option.None
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Minimal board, no territories`` () =
-    let input = ["B"]
-    let expected = []
+let ``Invalid because Y is too low for 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (1, -1)
+    let expected = Option.None
+    territory board position |> should equal expected
 
-    territories input |> should be Empty
+[<Fact(Skip = "Remove to run test")>]
+let ``Invalid because Y is too high for 5x5 board`` () =
+    let board = 
+        [ "  B  ";
+          " B B ";
+          "B W B";
+          " W W ";
+          "  W  " ]
+    let position = (1, 5)
+    let expected = Option.None
+    territory board position |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``One territory, covering the whole board`` () =
-    let input = [" "]
-    let expected = [((None: Color option), [(0, 0)])] |> Map.ofList
+let ``One territory is the whole board`` () =
+    let board = [" "]
+    let expected = 
+        [ (Owner.Black, []);
+          (Owner.White, []);
+          (Owner.None, [(0, 0)]) ]
+        |> Map.ofList
+    territories board |> should equal expected
 
-    territories input |> should equal expected
+[<Fact(Skip = "Remove to run test")>]
+let ``Two territory rectangular board`` () =
+    let board = 
+        [ " BW ";
+          " BW " ]
+    let expected = 
+        [ (Owner.Black, [(0, 0); (0, 1)]);
+          (Owner.White, [(3, 0); (3, 1)]);
+          (Owner.None, []) ]
+        |> Map.ofList
+    territories board |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``Two territories, rectangular board`` () =
-    let input = [" BW "; " BW "]
-    let expected = [(Some Black, [(0, 0); (0, 1)]);
-                    (Some White, [(3, 0); (3, 1)])]
-                   |> Map.ofList
+let ``Two region rectangular board`` () =
+    let board = [" B "]
+    let expected = 
+        [ (Owner.Black, [(0, 0); (2, 0)]);
+          (Owner.White, []);
+          (Owner.None, []) ]
+        |> Map.ofList
+    territories board |> should equal expected
 
-    territories input |> should equal expected

data/tracks/fsharp/generators/Generators.fs

@@ -536,6 +536,90 @@ type Gigasecond() =
 
     override __.AdditionalNamespaces = [typeof<DateTime>.Namespace]
 
+type GoCounting() =
+    inherit GeneratorExercise()
+
+    let renderOwner (value: JToken) = 
+        value
+        |> string
+        |> String.toLower
+        |> String.upperCaseFirst
+        |> sprintf "Owner.%s"
+
+    let renderTerritoryPosition (value: JToken) =
+        let arr = value :?> JArray
+        (arr.[0].ToObject<int>(), arr.[1].ToObject<int>())
+        |> formatValue
+
+    let renderTerritory (value: JToken) = 
+        value :?> JArray
+        |> Seq.map renderTerritoryPosition
+        |> formatList
+
+    let renderTerritoryWithOwner (value: obj) =
+        let expected = value :?> JObject
+        let owner = expected.["owner"] |> renderOwner
+        let territory = expected.["territory"] |> renderTerritory
+        sprintf "(%s, %s)" owner territory
+
+    let renderExpectedTerritory (value: obj) = 
+        match Option.ofNonError value with
+        | None -> "Option.None"
+        | Some expected -> expected |> renderTerritoryWithOwner |> sprintf "Option.Some %s"
+    
+    let renderExpectedTerritories (value: obj) = 
+        let expected = value :?> JObject
+        let black = sprintf "(Owner.Black, %s)" (expected.["territoryBlack"] |> renderTerritory)
+        let white = sprintf "(Owner.White, %s)" (expected.["territoryWhite"] |> renderTerritory)
+        let none  = sprintf "(Owner.None, %s)"  (expected.["territoryNone"]  |> renderTerritory)
+
+        let formattedList = formatMultiLineList [black; white; none]
+        sprintf "%s\n%s" formattedList (indent 2 "|> Map.ofList")
+
+    let territoryPosition (input: Map<string, obj>) =
+        let valueToInt key = input |> Map.find key |> string |> int
+        (valueToInt "x", valueToInt "y") |> box
+
+    let mapTerritoryInput (input: Map<string, obj>) =
+        input
+        |> Map.remove "x"
+        |> Map.remove "y"
+        |> Map.add "position" (territoryPosition input)
+
+    override __.MapCanonicalDataCaseInput (canonicalDataCase, input) =
+        match canonicalDataCase.Property with
+        | "territory" -> mapTerritoryInput input
+        | _ -> base.MapCanonicalDataCaseInput(canonicalDataCase, input)
+
+    override __.RenderInput (canonicalDataCase, key, value) =
+        match key with
+        | "board" -> 
+            value :?> JArray 
+            |> Seq.map formatValue 
+            |> formatMultiLineList
+        | _ -> 
+            base.RenderInput (canonicalDataCase, key, value)
+
+    override __.RenderExpected (canonicalDataCase, key, value) =
+        match canonicalDataCase.Property with
+        | "territory" -> renderExpectedTerritory value
+        | "territories" -> renderExpectedTerritories value
+        | _ -> base.RenderExpected(canonicalDataCase, key, value)
+
+    override __.PropertiesWithIdentifier canonicalDataCase = base.Properties canonicalDataCase
+
+    override __.IdentifierTypeAnnotation (canonicalDataCase, key, value) = 
+        match canonicalDataCase.Property, key with 
+        | "territory", "expected" -> 
+            match Option.ofNonError value with
+            | None -> None
+            | Some _ ->
+                if (value :?> JObject).["territory"] :?> JArray |> Seq.isEmpty then
+                    Some "(Owner * (int * int) list) option"
+                else
+                    None            
+        | _ -> None
+
 type Grains() =
     inherit GeneratorExercise()
 

data/tracks/java/config.json

@@ -638,19 +638,6 @@
       "unlocked_by": "rotational-cipher",
       "uuid": "d36ce010-210f-4e9a-9d6c-cb933e0a59af"
     },
-    {
-      "core": false,
-      "difficulty": 5,
-      "slug": "two-bucket",
-      "topics": [
-        "algorithms",
-        "loops",
-        "conditionals",
-        "mathematics"
-      ],
-      "unlocked_by": "triangle",
-      "uuid": "210bf628-b385-443b-8329-3483cc6e8d7e"
-    },
     {
       "core": false,
       "difficulty": 6,
@@ -937,6 +924,19 @@
       "unlocked_by": "rotational-cipher",
       "uuid": "6e4ad4ed-cc02-4132-973d-b9163ba0ea3d"
     },
+    {
+      "core": false,
+      "difficulty": 7,
+      "slug": "two-bucket",
+      "topics": [
+        "algorithms",
+        "loops",
+        "conditionals",
+        "mathematics"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "210bf628-b385-443b-8329-3483cc6e8d7e"
+    },
     {
       "core": false,
       "difficulty": 7,

data/tracks/purescript/config.json

@@ -284,6 +284,18 @@
         "maybe",
         "strings"
       ]
+    },
+    {
+      "uuid": "09a9ab8e-acaf-4f3d-96ff-789321a53785",
+      "slug": "phone-number",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "pattern_matching",
+        "conditionals",
+        "strings"
+      ]
     }
   ],
   "foregone": [

data/tracks/purescript/exercises/phone-number/README.md

@@ -0,0 +1,36 @@
+# Phone Number
+
+Clean up user-entered phone numbers so that they can be sent SMS messages.
+
+The **North American Numbering Plan (NANP)** is a telephone numbering system used by many countries in North America like the United States, Canada or Bermuda. All NANP-countries share the same international country code: `1`.
+
+NANP numbers are ten-digit numbers consisting of a three-digit Numbering Plan Area code, commonly known as *area code*, followed by a seven-digit local number. The first three digits of the local number represent the *exchange code*, followed by the unique four-digit number which is the *subscriber number*.
+
+The format is usually represented as
+
+```text
+(NXX)-NXX-XXXX
+```
+
+where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
+
+Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code (1) if present.
+
+For example, the inputs
+- `+1 (613)-995-0253`
+- `613-995-0253`
+- `1 613 995 0253`
+- `613.995.0253`
+
+should all produce the output
+
+`6139950253`
+
+**Note:** As this exercise only deals with telephone numbers used in NANP-countries, only 1 is considered a valid country code.
+
+## Source
+
+Event Manager by JumpstartLab [http://tutorials.jumpstartlab.com/projects/eventmanager.html](http://tutorials.jumpstartlab.com/projects/eventmanager.html)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/purescript/exercises/phone-number/bower.json

@@ -0,0 +1,26 @@
+{
+  "name": "phone-number",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-console": "^3.0.0",
+    "purescript-datetime": "^3.4.0",
+    "purescript-either": "^3.1.0",
+    "purescript-enums": "^3.2.1",
+    "purescript-integers": "^3.1.0",
+    "purescript-lists": "^4.10.0",
+    "purescript-maps": "^3.5.2",
+    "purescript-prelude": "^3.1.0",
+    "purescript-sets": "^3.0.0",
+    "purescript-strings": "^3.3.1",
+    "purescript-unicode": "^3.0.1"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^13.0.0"
+  }
+}

data/tracks/purescript/exercises/phone-number/examples/src/PhoneNumber.purs

@@ -0,0 +1,30 @@
+module PhoneNumber
+    ( phoneNumber
+    )
+    where
+
+import Prelude ((==), (<), (>>=), (&&), ($), otherwise)
+import Data.Char.Unicode (isDigit)
+import Data.Array (filter, head, tail, length, (!!))
+import Data.String (toCharArray, fromCharArray)
+import Data.Maybe (Maybe(..), fromMaybe)
+
+clean :: String -> Maybe (Array Char)
+clean input = go where
+  go
+    | len == 10 = Just digits
+    | len == 11 && head digits == Just '1' = tail digits
+    | otherwise = Nothing
+  digits = filter isDigit $ toCharArray input
+  len = length digits
+
+check:: Array Char -> Maybe String
+check input
+  | input !! 0 < Just '2' = Nothing
+  | input !! 3 < Just '2' = Nothing
+  | otherwise = Just $ fromCharArray input
+
+
+phoneNumber :: String -> String
+phoneNumber input = fromMaybe "None" (clean input >>= check)
+

data/tracks/purescript/exercises/phone-number/src/PhoneNumber.purs

@@ -0,0 +1,6 @@
+module PhoneNumber
+    ( phoneNumber
+    )
+    where
+
+

data/tracks/purescript/exercises/phone-number/test/Main.purs

@@ -0,0 +1,50 @@
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Control.Monad.Aff.AVar (AVAR)
+import Control.Monad.Eff.Console (CONSOLE)
+import Test.Unit (TestSuite, suite, test)
+import Test.Unit.Console (TESTOUTPUT)
+import Test.Unit.Main (runTest)
+import Test.Unit.Assert as Assert
+import PhoneNumber (phoneNumber)
+
+main :: forall eff
+  . Eff ( avar :: AVAR
+        , console :: CONSOLE
+        , testOutput :: TESTOUTPUT
+        | eff
+        )
+        Unit
+main = runTest suites
+
+suites :: forall e. TestSuite e
+suites = do
+  suite "PhoneNumber.phoneNumber" do
+    test "cleans the number" do
+      Assert.equal "2234567890" $ phoneNumber "(223) 456-7890"
+    test "cleans numbers with dots" do
+      Assert.equal "2234567890" $ phoneNumber "223.456.7890"
+    test "cleans numbers with multiple spaces" do
+      Assert.equal "2234567890" $ phoneNumber "223 456   7890   "
+    test "invalid when 9 digits" do
+      Assert.equal "None" $ phoneNumber "123456789"
+    test "invalid when 11 digits does not start with a 1" do
+      Assert.equal "None" $ phoneNumber "22234567890"
+    test "valid when 11 digits and starting with 1" do
+      Assert.equal "2234567890" $ phoneNumber "12234567890"
+    test "valid when 11 digits and starting with 1 even with punctuation" do
+      Assert.equal "2234567890" $ phoneNumber "+1 (223) 456-7890"
+    test "invalid when more than 11 digits" do
+      Assert.equal "None" $ phoneNumber "321234567890"
+    test "invalid with letters" do
+      Assert.equal "None" $ phoneNumber "123-abc-7890"
+    test "invalid with punctuations" do
+      Assert.equal "None" $ phoneNumber "123-@:!-7890"
+    test "invalid if area code does not start with 2-9" do
+      Assert.equal "None" $ phoneNumber "(123) 456-7890"
+    test "invalid if exchange code does not start with 2-9" do
+      Assert.equal "None" $ phoneNumber "(223) 056-7890"
+
+