trackler 2.2.1.159 → 2.2.1.160

data/tracks/nim/exercises/allergies/allergies_test.nim

@@ -5,19 +5,19 @@ import allergies
 
 test "no allergies means not allergic":
     let allergies = Allergies(score: 0)
-    check allergies.is_allergic_to("peanuts") == false
-    check allergies.is_allergic_to("cats") == false
-    check allergies.is_allergic_to("strawberries") == false
+    check allergies.isAllergicTo("peanuts") == false
+    check allergies.isAllergicTo("cats") == false
+    check allergies.isAllergicTo("strawberries") == false
 
 test "is allergic to eggs":
     let allergies = Allergies(score: 1)
-    check allergies.is_allergic_to("eggs") == true
+    check allergies.isAllergicTo("eggs") == true
 
 test "allergic to eggs in addition to other stuff":
     let allergies = Allergies(score: 5)
-    check allergies.is_allergic_to("eggs") == true
-    check allergies.is_allergic_to("shellfish") == true
-    check allergies.is_allergic_to("strawberries") == false
+    check allergies.isAllergicTo("eggs") == true
+    check allergies.isAllergicTo("shellfish") == true
+    check allergies.isAllergicTo("strawberries") == false
 
 test "no allergies at all":
     let allergies = Allergies(score: 0)

data/tracks/nim/exercises/allergies/example.nim

@@ -17,8 +17,8 @@ var
     ]
 
 
-proc is_allergic_to*(allergies: Allergies, allergy: string): bool =
+proc isAllergicTo*(allergies: Allergies, allergy: string): bool =
     (allergies.score and 1 shl allergiesList.find(allergy)) != 0
 
 proc lst*(allergies: Allergies): seq[string] =
-    allergiesList.filterIt(allergies.is_allergic_to(it))
+    allergiesList.filterIt(allergies.isAllergicTo(it))

data/tracks/nim/exercises/difference-of-squares/difference_of_squares_test.nim

@@ -2,19 +2,19 @@ import unittest
 import difference_of_squares
 
 test "square of sum, 5":
-  check square_of_sum(5) == 225
+  check squareOfSum(5) == 225
 
 test "sum of squares, 5":
-  check sum_of_squares(5) == 55
+  check sumOfSquares(5) == 55
 
 test "difference, 5":
   check difference(5) == 170
 
 test "square of sum, 100":
-  check square_of_sum(100) == 25502500
+  check squareOfSum(100) == 25502500
 
 test "sum of squares, 100":
-  check sum_of_squares(100) == 338350
+  check sumOfSquares(100) == 338350
 
 test "difference, 100":
   check difference(100) == 25164150

data/tracks/nim/exercises/difference-of-squares/example.nim

@@ -4,11 +4,11 @@ proc `**`(base, exponent: int): int =
     power *= base
   power
 
-proc square_of_sum*(n: int): int =
+proc squareOfSum*(n: int): int =
   (n * (n + 1) div 2) ** 2
 
-proc sum_of_squares*(n: int): int =
+proc sumOfSquares*(n: int): int =
   (n * (n + 1) * ((2 * n) + 1)) div 6
 
 proc difference*(n: int): int =
-  abs(sum_of_squares(n) - square_of_sum(n))
+  abs(sumOfSquares(n) - squareOfSum(n))

data/tracks/nim/exercises/gigasecond/example.nim

@@ -1,4 +1,4 @@
 import times
 
-proc add_gigasecond*(date: DateTime): DateTime =
+proc addGigasecond*(date: DateTime): DateTime =
     date + initInterval(seconds=1_000_000_000)

data/tracks/nim/exercises/gigasecond/gigasecond_test.nim

@@ -7,26 +7,26 @@ suite "Gigasecond":
     test "date only specification of time":
         let birthday = initDateTime(25, mApr, 2011, 0, 0, 0, utc())
         let expected = initDateTime(1, mJan, 2043, 1, 46, 40, utc())
-        check add_gigasecond(birthday) == expected
+        check addGigasecond(birthday) == expected
 
     test "second test for date only specification of time":
         let birthday = initDateTime(13, mJun, 1977, 0, 0, 0, utc())
         let expected = initDateTime(19, mFeb, 2009, 1, 46, 40, utc())
-        check add_gigasecond(birthday) == expected
+        check addGigasecond(birthday) == expected
 
     test "third test for date only specification of time":
         let birthday = initDateTime(19, mJul, 1959, 0, 0, 0, utc())
         let expected = initDateTime(27, mMar, 1991, 1, 46, 40, utc())
-        check add_gigasecond(birthday) == expected
+        check addGigasecond(birthday) == expected
 
     test "full time specified":
         let birthday = initDateTime(24, mJan, 2015, 22, 0, 0, utc())
         let expected = initDateTime(2, mOct, 2046, 23, 46, 40, utc())
-        check add_gigasecond(birthday) == expected
+        check addGigasecond(birthday) == expected
 
     test "full time with day roll-over":
         let birthday = initDateTime(24, mJan, 2015, 23, 59, 59, utc())
         let expected = initDateTime(3, mOct, 2046, 1, 46, 39, utc())
-        check add_gigasecond(birthday) == expected
+        check addGigasecond(birthday) == expected
 
 

data/tracks/nim/exercises/nucleotide-count/example.nim

@@ -11,7 +11,7 @@ proc count*(nt: char, dna: string): int =
 
   nt_count
 
-proc count_dna*(dna: string): CountTable[char] =
+proc countDna*(dna: string): CountTable[char] =
   var counts = initCountTable[char]()
 
   for nt in toSeq(dna.items):

data/tracks/nim/exercises/nucleotide-count/nucleotide_count_test.nim

@@ -11,15 +11,15 @@ test "count repetitive cytosine":
 test "count only thymine":
   check count('T', "GGGGGTAACCCGG") == 1
 
-test "count_dna empty":
-  check len(count_dna("")) == 0
+test "countDna empty":
+  check len(countDna("")) == 0
 
-test "count_dna only guanine":
-  let counts = count_dna("GGGGGGGG")
+test "countDna only guanine":
+  let counts = countDna("GGGGGGGG")
   check counts['G'] == 8
 
-test "count_dna counts all":
-  let counts = count_dna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC")
+test "countDna counts all":
+  let counts = countDna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC")
   check counts['A'] == 20
   check counts['C'] == 12
   check counts['T'] == 21

data/tracks/nim/exercises/pangram/example.nim

@@ -3,7 +3,7 @@ import strutils
 const
     ascii_lowercase = {'a'..'z'}
 
-proc is_pangram*(sentence:string): bool =
+proc isPangram*(sentence:string): bool =
     for c in ascii_lowercase:
         if c notin sentence.toLowerAscii: return false
     return true

data/tracks/nim/exercises/pangram/pangram_test.nim

@@ -1,35 +1,35 @@
 import unittest
 
-from pangram import is_pangram
+from pangram import isPangram
 
 
 test "sentence empty":
-    check is_pangram("") == false
+    check isPangram("") == false
 
 test "recognizes a perfect lower case pangram":
-    check is_pangram("abcdefghijklmnopqrstuvwxyz") == true
+    check isPangram("abcdefghijklmnopqrstuvwxyz") == true
 
 test "test pangram with only lower case":
-    check is_pangram("the quick brown fox jumps over the lazy dog") == true
+    check isPangram("the quick brown fox jumps over the lazy dog") == true
 
 test "missing character x":
-    check is_pangram("a quick movement of the enemy will jeopardize five gunboats") == false
+    check isPangram("a quick movement of the enemy will jeopardize five gunboats") == false
 
 test "another missing character":
-    check is_pangram("five boxing wizards jump quickly at it") == false
+    check isPangram("five boxing wizards jump quickly at it") == false
 
 test "pangram with underscores":
-    check is_pangram("the_quick_brown_fox_jumps_over_the_lazy_dog") == true
+    check isPangram("the_quick_brown_fox_jumps_over_the_lazy_dog") == true
 
 test "pangram with numbers":
-    check is_pangram("the 1 quick brown fox jumps over the 2 lazy dogs") == true
+    check isPangram("the 1 quick brown fox jumps over the 2 lazy dogs") == true
 
 test "missing letters replaced by numbers":
-    check is_pangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog") == false
+    check isPangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog") == false
 
 test "pangram with mixedcase and punctuation":
-    check is_pangram("Five quacking Zephyrs jolt my wax bed.") == true
+    check isPangram("Five quacking Zephyrs jolt my wax bed.") == true
 
 test "upper and lower case versions of the same character":
-    check is_pangram("the quick brown fox jumped over the lazy FX") == false
+    check isPangram("the quick brown fox jumped over the lazy FX") == false
 

data/tracks/nim/exercises/triangle/example.nim

@@ -6,20 +6,20 @@ proc valid(a, b, c: int): bool =
 
     greatThenZero and equalityCheck
 
-proc is_equilateral*(sides: array[3, int]): bool =
+proc isEquilateral*(sides: array[3, int]): bool =
     let a = sides[0]
     let b = sides[1]
     let c = sides[2]
     valid(a, b, c) and all(sides, proc (x: int): bool = return a == x)
 
-proc is_isosceles*(sides: array[3, int]): bool =
+proc isIsosceles*(sides: array[3, int]): bool =
     let a = sides[0]
     let b = sides[1]
     let c = sides[2]
     valid(a, b, c) and (a == b or b == c or a == c)
 
-proc is_scalene*(sides: array[3, int]): bool =
+proc isScalene*(sides: array[3, int]): bool =
     let a = sides[0]
     let b = sides[1]
     let c = sides[2]
-    valid(a, b, c) and not is_isosceles(sides)
+    valid(a, b, c) and not isIsosceles(sides)

data/tracks/nim/exercises/triangle/triangle_test.nim

@@ -5,49 +5,49 @@ import triangle
 suite "returns true if the triangle is equilateral":
 
   test "true if all sides are equal":
-      check is_equilateral([2, 2, 2]) == true
+      check isEquilateral([2, 2, 2]) == true
 
   test "false if any side is unequal":
-      check is_equilateral([2, 3, 2]) == false
+      check isEquilateral([2, 3, 2]) == false
 
   test "false if no sides are equal":
-      check is_equilateral([5, 4, 6]) == false
+      check isEquilateral([5, 4, 6]) == false
 
   test "false if all sides are zero":
-      check is_equilateral([0, 0, 0]) == false
+      check isEquilateral([0, 0, 0]) == false
 
 
 suite "returns true if the triangle is isosceles":
 
   test "true if last two sides are equal":
-      check is_isosceles([3, 4, 4]) == true
+      check isIsosceles([3, 4, 4]) == true
 
   test "true if first two sides are equal":
-      check is_isosceles([4, 4, 3]) == true
+      check isIsosceles([4, 4, 3]) == true
 
   test "true if first and last sides are equal":
-      check is_isosceles([4, 3, 4]) == true
+      check isIsosceles([4, 3, 4]) == true
 
   test "is equilateral triangles are also is isosceles":
-      check is_isosceles([4, 4, 4]) == true
+      check isIsosceles([4, 4, 4]) == true
 
   test "false if no sides are equal":
-      check is_isosceles([2, 3, 4]) == false
+      check isIsosceles([2, 3, 4]) == false
 
   test "violation of triangle inequality not is isosceles":
-      check is_isosceles([1, 1, 3]) == false
+      check isIsosceles([1, 1, 3]) == false
 
 
 suite "returns true if the triangle is scalene":
 
   test "true if no sides are equal":
-      check is_scalene([5, 4, 6]) == true
+      check isScalene([5, 4, 6]) == true
 
   test "false if all sides are equal":
-      check is_scalene([4, 4, 4]) == false
+      check isScalene([4, 4, 4]) == false
 
   test "false if two sides are equal":
-      check is_scalene([4, 4, 3]) == false
+      check isScalene([4, 4, 3]) == false
 
   test "violation of triangle inequality not is scalene":
-      check is_scalene([7, 3, 2]) == false
+      check isScalene([7, 3, 2]) == false

data/tracks/nim/exercises/word-count/HINT.md

@@ -0,0 +1,8 @@
+The return from `countWords` is a `TableRef[string, int]`, which is a hash table (or dictionary in other programming languages) with a key of `string` and a value of `int`. Look at Nim's documentation on `tables` at https://nim-lang.org/docs/tables.html
+
+For the procedure signature, the return will be of type `TableRef[string, int]`
+
+```nim
+proc countWords*(sentence: string): TableRef[string, int] =
+  ...
+```

data/tracks/nim/exercises/word-count/example.nim

@@ -1,19 +1,12 @@
 import
-  critbits, strutils
+  tables, strutils, re
 
-type TWordCount* = CritBitTree[int]
-  ## A mapping from strings (`words`) to ints (`counts`).
-
-iterator words(s: string): string =
-  for word in s.split(AllChars - Letters - Digits - {'\0'}):
+iterator words(sentence: string): string = 
+  for word in sentence.findAll(re"[a-zA-Z0-9]+(['][a-z]+)?"):
     yield toLowerAscii(word)
 
-proc wordCount*(s: string): TWordCount {.noSideEffect.} =
-  ## Returns a mapping from the words (alphanumeric sequences) in `s` to their
-  ## respective counts.
-  for word in words(s):
-    if word.len == 0:
-      continue
-    if not result.hasKey(word):
-      result[word] = 0
-    result[word] = result[word] + 1
+proc countWords*(sentence: string): TableRef[string, int] =
+  result = newTable[string, int]()
+  for word in words(sentence):
+    let count = result.getOrDefault(word)
+    result[word] = count + 1

data/tracks/nim/exercises/word-count/word_count_test.nim

@@ -1,66 +1,74 @@
 import
- critbits, unittest
-import wordcount
+  unittest, tables
 
-proc `==`(a, b: TWordCount): bool =
-  if a.len != b.len:
-    return
-  for key, count in a:
-    if b[key] != count:
-      return
-  return true
+import word_count
 
-proc fromPairs(pairs: seq[tuple[word: string, count: int]]): TWordCount =
-  for p in pairs:
-    result[p.word] = p.count
+# For each word in the input, count the number of times it appears in the entire sentence.
+suite "Word Count":
 
-test "count one word":
-  let
-    expected = fromPairs(@[("word", 1)])
-    result = wordCount("word")
-  check result == expected
+  test "count one word":
+    let
+      expected: TableRef[string, int] = {"word": 1}.newTable
+      result: TableRef[string, int] = countWords("word")
+    check result == expected
 
-test "count one of each":
-  let
-    expected = fromPairs(@[("one", 1), ("of", 1), ("each", 1)])
-    result = wordCount("one of each")
-  check result == expected
+  test "count one of each":
+    let
+      expected = {"one": 1, "of": 1, "each": 1}.newTable
+      result = countWords("one of each")
+    check result == expected
 
-test "count multiple occurrences":
-  let
-    expected = fromPairs(@[("one", 1), ("fish", 4), ("two", 1),
-                           ("red", 1), ("blue", 1)])
-    result = wordCount("one fish two fish red fish blue fish")
-  check result == expected
+  test "multiple occurrences of a word":
+    let
+      expected = {"one": 1, "fish": 4, "two": 1, "red": 1, "blue": 1}.newTable
+      result = countWords("one fish two fish red fish blue fish")
+    check result == expected
 
-test "ignore punctuation":
-  let
-    expected = fromPairs(@[("car", 1), ("carpet", 1), ("as", 1),
-                           ("java", 1), ("javascript", 1)])
-    result = wordCount("car : carpet as java : javascript!!&@$%^&")
-  check result == expected
+  test "handles cramped lists":
+    let
+      expected = {"one": 1, "two": 1, "three": 1 }.newTable
+      result = countWords("one,two,three")
+    check result == expected
 
-test "include numbers":
-  let
-    expected = fromPairs(@[("testing", 2), ("1", 1), ("2", 1)])
-    result = wordCount("testing, 1, 2 testing")
-  check result == expected
+  test "handles expanded lists":
+    let
+      expected = {"one": 1, "two": 1, "three": 1 }.newTable
+      result = countWords("one,\ntwo,\nthree")
+    check result == expected
 
-test "normalize case":
-  let
-    result = wordCount("go Go GO")
-    expected = fromPairs(@[("go", 3)])
-  check result == expected
+  test "ignore punctuation":
+    let
+      expected = {"car": 1, "carpet": 1, "as": 1, "java": 1, "javascript": 1}.newTable
+      result = countWords("car: carpet as java: javascript!!&@$%^&")
+    check result == expected
+  
+  test "include numbers":
+    let
+      expected = {"testing": 2, "1": 1, "2": 1}.newTable
+      result = countWords("testing, 1, 2 testing")
+    check result == expected
+  
+  test "normalize case":
+    let
+      expected = {"go": 3, "stop": 2}.newTable
+      result = countWords("go Go GO Stop stop")
+    check result == expected
 
-test "prefix punctuation":
-  let
-    expected = fromPairs(@[("testing", 2), ("1", 1), ("2", 1)])
-    result = wordCount("!%%#testing, 1, 2 testing")
-  check result == expected
+  test "with apostrophes":
+    let
+      expected = {"first": 1, "don't": 2, "laugh": 1, "then": 1, "cry": 1}.newTable
+      result = countWords("First: don't laugh. Then: don't cry.")
+    check result == expected
 
-test "symbols are separators":
-  let
-    expected = fromPairs(@[("hey", 1), ("my", 1), ("spacebar", 1),
-                           ("is", 1), ("broken", 1)])
-    result = wordCount("hey,my_spacebar_is_broken.")
-  check result == expected
+  test "with quotations":
+    let
+      expected = {"joe": 1, "can't": 1, "tell": 1,
+                  "between": 1, "large": 2, "and": 1}.newTable
+      result = countWords("Joe can't tell between 'large' and large.")
+    check result == expected
+
+  test "multiple spaces not detected as a word":
+    let
+      expected = {"multiple": 1, "whitespaces": 1}.newTable
+      result = countWords(" multiple   whitespaces")
+    check result == expected

data/tracks/perl6/Dockerfile

@@ -1,4 +1,4 @@
 FROM rakudo-star:latest
 RUN apt-get update && \
     apt-get install -y make gcc libyaml-dev && \
-    zef install YAML::Parser::LibYAML
+    zef install YAML::Parser::LibYAML --force-build

data/tracks/perl6/config/maintainers.json

@@ -1,25 +1,25 @@
 {
+  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md",
   "maintainers": [
     {
       "github_username": "kotp",
-      "show_on_website": false,
       "alumnus": false,
+      "show_on_website": false,
       "name": null,
-      "bio": null,
       "link_text": null,
       "link_url": null,
-      "avatar_url": null
+      "avatar_url": null,
+      "bio": null
     },
     {
       "github_username": "mienaikage",
-      "show_on_website": true,
       "alumnus": false,
+      "show_on_website": true,
       "name": null,
-      "bio": "My first adventure in coding was creating userscripts by trial and error (many errors...). Somewhere down the line I accidentally found myself employed in my first coding role as a Perl developer, after attempting pair programming in Haskell.",
       "link_text": "dango.space",
       "link_url": "http://dango.space/",
-      "avatar_url": null
+      "avatar_url": null,
+      "bio": "My first adventure in coding was creating userscripts by trial and error (many errors...). Somewhere down the line I accidentally found myself employed in my first coding role as a Perl developer, after attempting pair programming in Haskell."
     }
-  ],
-  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md"
+  ]
 }