trackler 2.2.1.175 → 2.2.1.176

data/tracks/perl6/config.json

@@ -10,6 +10,7 @@
       "slug": "hello-world",
       "uuid": "2803dd22-3a92-4fa9-ae7c-4354e80fe423",
       "core": false,
+      "auto_approve": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": []

data/tracks/powershell/config.json

@@ -1,5 +1,5 @@
 {
-  "language": "Windows PowerShell",
+  "language": "PowerShell",
   "active": false,
   "blurb": "Task-based command-line shell and scripting language designed especially for system administration.",
   "checklist_issue": 4,

data/tracks/python/exercises/hello-world/example.py

@@ -1,5 +1,2 @@
-def hello(name=''):
-    if name:
-        return u'Hello, {}!'.format(name)
-    else:
-        return 'Hello, World!'
+def hello():
+    return 'Hello, World!'

data/tracks/python/exercises/hello-world/hello_world.py

@@ -1,2 +1,2 @@
-def hello(name=''):
+def hello():
     pass

data/tracks/reasonml/.gitignore

@@ -8,3 +8,4 @@ bin/configlet.exe
 **/*.bs.js
 .merlin
 .bsb.lock
+tmp

data/tracks/reasonml/Makefile

@@ -9,19 +9,22 @@ OUTDIR ?= "tmp"
 
 # language specific config (tweakable per language)
 FILEEXT := "re"
+SIGFILEEXT := "rei"
 EXAMPLE := "Example.$(FILEEXT)"
 SRCFILE := "$(shell echo $(EXERCISE) | sed -r 's/(^|-)([a-z])/\U\2/g')"
 TSTFILE := "$(SRCFILE)_test.$(FILEEXT)"
+SIGFILE := "$(SRCFILE).$(SIGFILEEXT)"
 # Any additional arguments, such as -p for pretty output and others
 ARGS ?= ""
 
-# copy example and test file for single exercise to OUTDIR
+# copy example, interface and test files for single exercise to OUTDIR
 # Rename Example.re to ExerciseName.re in the process
 copy-exercise:
-	@cp exercises/$(EXERCISE)/__tests__/$(TSTFILE) $(OUTDIR)/__tests__/
 	@cp exercises/$(EXERCISE)/src/$(EXAMPLE) $(OUTDIR)/src/$(SRCFILE).$(FILEEXT)
+	@cp exercises/$(EXERCISE)/src/$(SIGFILE) $(OUTDIR)/src/
+	@cp exercises/$(EXERCISE)/__tests__/$(TSTFILE) $(OUTDIR)/__tests__/
 
-# copy all source files to OUTDIR - easier to compile from there
+# copy source files for all exercises to OUTDIR - easier to compile from there
 copy-all-exercises:
 	@echo "Copying files..."
 	@mkdir -p $(OUTDIR)/src

data/tracks/reasonml/config.json

@@ -102,6 +102,16 @@
         "list_map_function"
       ]
     },
+    {
+      "slug": "pangram",
+      "uuid": "dddf877a-a8d4-45d7-8543-882c08bad2e8",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "strings"
+      ]
+    },
     {
       "slug": "binary-search",
       "uuid": "eb635d37-a70b-47b2-883b-8ec9ca6098ef",
@@ -135,6 +145,17 @@
         "recursion",
         "dynamic_programming"
       ]
+    },
+    {
+      "slug": "phone-number",
+      "uuid": "2721c31b-773e-43c5-93ab-f704d62e5cde",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "strings",
+        "regular_expressions"
+      ]
     }
   ]
 }

data/tracks/reasonml/exercises/anagram/src/Anagram.rei

@@ -0,0 +1 @@
+let anagrams: (string, list(string)) => list(string);

data/tracks/reasonml/exercises/anagram/src/Example.re

@@ -1,26 +1,24 @@
-let stringToCharArray = (s) => {
+let stringToCharArray = s => {
   let len = String.length(s);
   Array.init(len, n => s.[n]);
-}
+};
 
-let isAnagram = (base, word) => {
-  if(String.length(base) != String.length(word)) {
-    false
+let isAnagram = (base, word) =>
+  if (String.length(base) != String.length(word)) {
+    false;
   } else {
     let base = String.lowercase(base);
     let word = String.lowercase(word);
-    if(base == word) {
-      false
+    if (base == word) {
+      false;
     } else {
       let base = stringToCharArray(base);
       Array.sort(Char.compare, base);
       let word = stringToCharArray(word);
       Array.sort(Char.compare, word);
       base == word;
-    }
-  }
-};
+    };
+  };
 
-let anagrams = (base, candidates) => {
+let anagrams = (base, candidates) =>
   List.filter(isAnagram(base), candidates);
-};

data/tracks/reasonml/exercises/binary-search/src/BinarySearch.rei

@@ -0,0 +1 @@
+let find: (array(int), int) => option(int);

data/tracks/reasonml/exercises/bob/src/Bob.rei

@@ -0,0 +1 @@
+let hey: string => string;

data/tracks/reasonml/exercises/change/src/Change.rei

@@ -0,0 +1,2 @@
+type coins = list(int);
+let makeChange: (int, coins) => option(coins);

data/tracks/reasonml/exercises/change/src/Example.re

@@ -1,31 +1,32 @@
-let intCompare = (n1: int, n2: int) => {
-  if(n1 == n2) {
-    0
-  } else if(n1 > n2) {
-    1
+type coins = list(int);
+
+let intCompare = (n1: int, n2: int) =>
+  if (n1 == n2) {
+    0;
+  } else if (n1 > n2) {
+    1;
   } else {
-    -1
-  }
-};
+    (-1);
+  };
 
 let findSmallestCoinsListMeetingTarget =
-    (cache: array(option(list(int))), coins: list(int), target: int)
+    (cache: array(option(coins)), coins, target: int)
     : option(list(int)) => {
-  let findCoinsMeetingTargetMinusCoin = (coin) =>
+  let findCoinsMeetingTargetMinusCoin = coin =>
     if (target == coin) {
       Some([coin]);
     } else {
-      Belt.Option.map(cache[target - coin], (cs) => [coin, ...cs]);
+      Belt.Option.map(cache[target - coin], cs => [coin, ...cs]);
     };
-  List.filter((x) => x <= target, coins)
+  List.filter(x => x <= target, coins)
   |> List.map(findCoinsMeetingTargetMinusCoin)
-  |> Belt.List.keepMap(_, (x) => x)
+  |> Belt.List.keepMap(_, x => x)
   |> List.sort((xs, ys) => intCompare(List.length(xs), List.length(ys)))
   |> Belt.List.head;
 };
 
-let makeChange = (target: int, coins: list(int)): option(list(int)) =>
-  switch(target) {
+let makeChange = (target: int, coins) : option(coins) =>
+  switch (target) {
   | 0 => Some([])
   | _ when target < 0 => None
   | _ =>

data/tracks/reasonml/exercises/hello-world/src/HelloWorld.rei

@@ -0,0 +1 @@
+let hello: unit => string;

data/tracks/reasonml/exercises/leap/src/Leap.rei

@@ -0,0 +1 @@
+let isLeapYear: int => bool;

data/tracks/reasonml/exercises/pangram/README.md

@@ -0,0 +1,21 @@
+# Pangram
+
+Determine if a sentence is a pangram. A pangram (Greek: παν γράμμα, pan gramma,
+"every letter") is a sentence using every letter of the alphabet at least once.
+The best known English pangram is:
+> The quick brown fox jumps over the lazy dog.
+
+The alphabet used consists of ASCII letters `a` to `z`, inclusive, and is case
+insensitive. Input will not contain non-ASCII symbols.
+
+# Build + Watch
+
+```
+npm start
+```
+
+# Test + Watch
+
+```
+npm test
+```

data/tracks/reasonml/exercises/pangram/__tests__/Pangram_test.re

@@ -0,0 +1,36 @@
+open Jest;
+open Expect;
+open Pangram;
+
+describe("Pangram", () => {
+  test("sentence empty", () =>
+    expect(isPangram("")) |> toEqual(false) 
+  );
+  test("recognizes a perfect lower case pangram", () =>
+    expect(isPangram("abcdefghijklmnopqrstuvwxyz")) |> toEqual(true) 
+  );
+  test("pangram with only lower case", () =>
+    expect(isPangram("the quick brown fox jumps over the lazy dog")) |> toEqual(true) 
+  );
+  test("missing character 'x'", () =>
+    expect(isPangram("a quick movement of the enemy will jeopardize five gunboats")) |> toEqual(false) 
+  );
+  test("another missing character, e.g. 'h'", () =>
+    expect(isPangram("five boxing wizards jump quickly at it")) |> toEqual(false) 
+  );
+  test("pangram with underscores", () =>
+    expect(isPangram("the_quick_brown_fox_jumps_over_the_lazy_dog")) |> toEqual(true) 
+  );
+  test("pangram with numbers", () =>
+    expect(isPangram("the 1 quick brown fox jumps over the 2 lazy dogs")) |> toEqual(true) 
+  );
+  test("missing letters replaced by numbers", () =>
+    expect(isPangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog")) |> toEqual(false) 
+  );
+  test("pangram with mixed case and punctuation", () =>
+    expect(isPangram("\"Five quacking Zephyrs jolt my wax bed.\"")) |> toEqual(true) 
+  );
+  test("upper and lower case versions of the same character should not be counted separately", () =>
+    expect(isPangram("the quick brown fox jumps over with lazy FX")) |> toEqual(false) 
+  );
+});

data/tracks/reasonml/exercises/pangram/bsconfig.json

@@ -0,0 +1,30 @@
+// This is the configuration file used by BuckleScript's build system bsb. Its documentation lives here: http://bucklescript.github.io/bucklescript/docson/#build-schema.json
+// BuckleScript comes with its own parser for bsconfig.json, which is normal JSON, with the extra support of comments and trailing commas.
+{
+  "name": "pangram",
+  "version": "0.1.0",
+  "sources": [
+    {
+      "dir" : "src",
+      "subdirs" : true
+    },
+    {
+      "dir": "__tests__",
+      "type": "dev"
+    }
+  ],
+  "package-specs": {
+    "module": "commonjs",
+    "in-source": true
+  },
+  "suffix": ".bs.js",
+  "bs-dependencies": [
+      // add your dependencies here. You'd usually install them normally through `npm install my-dependency`. If my-dependency has a bsconfig.json too, then everything will work seamlessly.
+  ],
+  "bs-dev-dependencies": ["@glennsl/bs-jest"],
+  "warnings": {
+    "error" : "+101"
+  },
+  "namespace": true,
+  "refmt": 3
+}

data/tracks/reasonml/exercises/pangram/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "pangram",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "bsb -make-world",
+    "start": "bsb -make-world -w",
+    "clean": "bsb -clean-world",
+    "test": "jest --watchAll",
+    "test:ci": "jest --ci --bail --no-cache"
+  },
+  "keywords": [
+    "BuckleScript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@glennsl/bs-jest": "^0.4.2",
+    "bs-platform": "^3.1.5"
+  }
+}

data/tracks/reasonml/exercises/pangram/src/Example.re

@@ -0,0 +1,36 @@
+exception Finished(int);
+
+let rec stringFold = (s: string, init: 'a, step: ('a, char) => 'a): 'a => {
+  switch(String.length(s)) {
+    | 0 => init;
+    | _ => {
+      let tail = String.sub(s, 1, String.length(s) - 1);
+      let next = step(init, s.[0]);
+      stringFold(tail, next, step);
+    }
+  }
+};
+
+let isUppercaseAlpha = (ch) => Char.code(ch) >= 65 && Char.code(ch) <= 90;
+
+let isPangram = (s: string) => {
+  let alphabetBits = 1 lsl 26 - 1;
+  let updateBits = (b, ch) => {
+    let updated = {
+      let ch = Char.uppercase(ch);
+      if (isUppercaseAlpha(ch)) {
+        b lor 1 lsl (Char.code(ch) - Char.code('A'));
+      } else {
+        b;
+      };
+    };
+    if (updated == alphabetBits) {
+      raise(Finished(alphabetBits));
+    } else {
+      updated;
+    };
+  };
+  try (stringFold(s, 0, updateBits) == alphabetBits) {
+  | Finished(bitSet) => bitSet == alphabetBits
+  };
+};

data/tracks/reasonml/exercises/pangram/src/Pangram.rei

@@ -0,0 +1 @@
+let isPangram: string => bool;

data/tracks/reasonml/exercises/phone-number/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+.merlin
+.bsb.lock
+npm-debug.log
+/lib/bs/
+/node_modules/

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

@@ -0,0 +1,43 @@
+# 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.
+
+# Build
+```
+npm run build
+```
+
+# Build + Watch
+
+```
+npm run start
+```
+
+
+# Editor
+If you use `vscode`, Press `Windows + Shift + B` it will build automatically

data/tracks/reasonml/exercises/phone-number/__tests__/PhoneNumber_test.re

@@ -0,0 +1,48 @@
+open Jest;
+open Expect;
+open PhoneNumber;
+
+describe("PhoneNumber", () => {
+  test("cleans the number", () =>
+    expect(phoneNumber("(223) 456-7890")) |> toEqual(Some("2234567890"))
+  );
+  test("cleans numbers with dots", () =>
+    expect(phoneNumber("223.456.7890")) |> toEqual(Some("2234567890"))
+  );
+  test("cleans numbers with multiple spaces", () =>
+    expect(phoneNumber("223 456   7890   ")) |> toEqual(Some("2234567890"))
+  );
+  test("invalid when 9 digits", () =>
+    expect(phoneNumber("123456789")) |> toEqual(None)
+  );
+  test("invalid when 11 digits does not start with a 1", () =>
+    expect(phoneNumber("22234567890")) |> toEqual(None)
+  );
+  test("valid when 11 digits and starting with 1", () =>
+    expect(phoneNumber("12234567890")) |> toEqual(Some("2234567890"))
+  );
+  test("valid when 11 digits and starting with 1 even with punctuation", () =>
+    expect(phoneNumber("+1 (223) 456-7890")) |> toEqual(Some("2234567890"))
+  );
+  test("invalid when more than 11 digits", () =>
+    expect(phoneNumber("321234567890")) |> toEqual(None)
+  );
+  test("invalid with letters", () =>
+    expect(phoneNumber("123-abc-7890")) |> toEqual(None)
+  );
+  test("invalid with punctuations", () =>
+    expect(phoneNumber("123-@:!-7890")) |> toEqual(None)
+  );
+  test("invalid if area code starts with 0", () =>
+    expect(phoneNumber("(023) 456-7890")) |> toEqual(None)
+  );
+  test("invalid if area code starts with 1", () =>
+    expect(phoneNumber("(123) 456-7890")) |> toEqual(None)
+  );
+  test("invalid if exchange code starts with 0", () =>
+    expect(phoneNumber("(123) 056-7890")) |> toEqual(None)
+  );
+  test("invalid if exchange code starts with 1", () =>
+    expect(phoneNumber("(123) 156-7890")) |> toEqual(None)
+  );
+});