trackler 2.2.1.172 → 2.2.1.173

data/tracks/nim/exercises/hamming/hamming_test.nim

@@ -2,23 +2,25 @@ import unittest
 
 import hamming
 
-test "no difference between identical strands":
-  check distance("A", "A") == 0
+suite "Hamming":
+  
+  test "no difference between identical strands":
+    check distance("A", "A") == 0
 
-test "complate Hamming distance for single nucleotide strand":
-  check distance("A", "G") == 1
+  test "complate Hamming distance for single nucleotide strand":
+    check distance("A", "G") == 1
 
-test "complete Hamming distance for small strand":
-  check distance("AG", "CT") == 2
+  test "complete Hamming distance for small strand":
+    check distance("AG", "CT") == 2
 
-test "small Hamming distance":
-  check distance("AT", "CT") == 1
+  test "small Hamming distance":
+    check distance("AT", "CT") == 1
 
-test "small Hamming distance in longer strand":
-  check distance("GGACG", "GGTCG") == 1
+  test "small Hamming distance in longer strand":
+    check distance("GGACG", "GGTCG") == 1
 
-test "large Hamming distance":
-  check distance("GATACA", "GCATAA") == 4
+  test "large Hamming distance":
+    check distance("GATACA", "GCATAA") == 4
 
-test "Hamming distance in a very large strand":
-  check distance("GGACGGATTCTG", "AGGACGGATTCT") == 9
+  test "Hamming distance in a very large strand":
+    check distance("GGACGGATTCTG", "AGGACGGATTCT") == 9

data/tracks/nim/exercises/hello-world/helloworld_test.nim

@@ -2,11 +2,13 @@ import unittest
 
 import helloworld
 
-test "no name":
-  check helloworld() == "Hello, World!"
+suite "Hello World":
+  
+  test "no name":
+    check helloworld() == "Hello, World!"
 
-test "sample name":
-  check helloworld("Alice") == "Hello, Alice!"
+  test "sample name":
+    check helloworld("Alice") == "Hello, Alice!"
 
-test "other sample name":
-  check helloworld("Bob") == "Hello, Bob!"
+  test "other sample name":
+    check helloworld("Bob") == "Hello, Bob!"

data/tracks/nim/exercises/leap/example.nim

@@ -1,6 +1,6 @@
 proc isLeapYear*(y: int): bool {.noSideEffect, procvar.} =
   ## Returns true if `y` is a leap year.
   ##
-  ## .. code-block:: nimrod
+  ## .. code-block:: nim
   ##   assert isLeapYear(2012)
   y mod 4 == 0 and (y mod 100 != 0 or y mod 400 == 0)

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

@@ -2,25 +2,27 @@ import tables
 import unittest
 import nucleotide_count
 
-test "count empty string":
-  check count('A', "") == 0
+suite "Nucleotide":
+  
+  test "count empty string":
+    check count('A', "") == 0
 
-test "count repetitive cytosine":
-  check count('C', "CCCCC") == 5
+  test "count repetitive cytosine":
+    check count('C', "CCCCC") == 5
 
-test "count only thymine":
-  check count('T', "GGGGGTAACCCGG") == 1
+  test "count only thymine":
+    check count('T', "GGGGGTAACCCGG") == 1
 
-test "countDna empty":
-  check len(countDna("")) == 0
+  test "countDna empty":
+    check len(countDna("")) == 0
 
-test "countDna only guanine":
-  let counts = countDna("GGGGGGGG")
-  check counts['G'] == 8
+  test "countDna only guanine":
+    let counts = countDna("GGGGGGGG")
+    check counts['G'] == 8
 
-test "countDna counts all":
-  let counts = countDna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC")
-  check counts['A'] == 20
-  check counts['C'] == 12
-  check counts['T'] == 21
-  check counts['G'] == 17
+  test "countDna counts all":
+    let counts = countDna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC")
+    check counts['A'] == 20
+    check counts['C'] == 12
+    check counts['T'] == 21
+    check counts['G'] == 17

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

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

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

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

data/tracks/nim/exercises/raindrops/raindrops_test.nim

@@ -1,51 +1,53 @@
-import tables
 import unittest
+
 import raindrops
 
-test "convert 1":
-  check convert(1) == "1"
+suite "Raindrops":
+  
+  test "convert 1":
+    check convert(1) == "1"
 
-test "convert 3":
-  check convert(3) == "Pling"
+  test "convert 3":
+    check convert(3) == "Pling"
 
-test "convert 5":
-  check convert(5) == "Plang"
+  test "convert 5":
+    check convert(5) == "Plang"
 
-test "convert 7":
-  check convert(7) == "Plong"
+  test "convert 7":
+    check convert(7) == "Plong"
 
-test "convert 6":
-  check convert(6) == "Pling"
+  test "convert 6":
+    check convert(6) == "Pling"
 
-test "convert 9":
-  check convert(9) == "Pling"
+  test "convert 9":
+    check convert(9) == "Pling"
 
-test "convert 10":
-  check convert(10) == "Plang"
+  test "convert 10":
+    check convert(10) == "Plang"
 
-test "convert 14":
-  check convert(14) == "Plong"
+  test "convert 14":
+    check convert(14) == "Plong"
 
-test "convert 15":
-  check convert(15) == "PlingPlang"
+  test "convert 15":
+    check convert(15) == "PlingPlang"
 
-test "convert 21":
-  check convert(21) == "PlingPlong"
+  test "convert 21":
+    check convert(21) == "PlingPlong"
 
-test "convert 25":
-  check convert(25) == "Plang"
+  test "convert 25":
+    check convert(25) == "Plang"
 
-test "convert 35":
-  check convert(35) == "PlangPlong"
+  test "convert 35":
+    check convert(35) == "PlangPlong"
 
-test "convert 49":
-  check convert(49) == "Plong"
+  test "convert 49":
+    check convert(49) == "Plong"
 
-test "convert 52":
-  check convert(52) == "52"
+  test "convert 52":
+    check convert(52) == "52"
 
-test "convert 105":
-  check convert(105) == "PlingPlangPlong"
+  test "convert 105":
+    check convert(105) == "PlingPlangPlong"
 
-test "convert 12121":
-  check convert(12121) == "12121"
+  test "convert 12121":
+    check convert(12121) == "12121"

data/tracks/nim/exercises/rna-transcription/rna_transcription_test.nim

@@ -2,21 +2,23 @@ import unittest
 
 import rna_transcription
 
-test "transcribes G to C":
-  check toRna("G") == "C"
+suite "RNA Transcription":
+  
+  test "transcribes G to C":
+    check toRna("G") == "C"
 
-test "transcribes C to G":
-  check toRna("C") == "G"
+  test "transcribes C to G":
+    check toRna("C") == "G"
 
-test "transcribes T to A":
-  check toRna("T") == "A"
+  test "transcribes T to A":
+    check toRna("T") == "A"
 
-test "transcribes A to U":
-  check toRna("A") == "U"
+  test "transcribes A to U":
+    check toRna("A") == "U"
 
-test "transcribe all occurrences":
-  check toRna("ACGTGGTCTTAA") == "UGCACCAGAAUU"
+  test "transcribe all occurrences":
+    check toRna("ACGTGGTCTTAA") == "UGCACCAGAAUU"
 
-test "raise ValueError on invalid nucleotide":
-  expect(ValueError):
-    discard toRna("Q")
+  test "raise ValueError on invalid nucleotide":
+    expect(ValueError):
+      discard toRna("Q")

data/tracks/nim/exercises/roman-numerals/example.nim

@@ -1,30 +1,29 @@
 type
-    Numeral = tuple[number: int, roman: string]
-    NumeralArray = array[13, Numeral]
+  Numeral = tuple[number: int, roman: string]
+  NumeralArray = array[13, Numeral]
 
 let
-    numeral_mapping: NumeralArray = [
-        (1000, "M"),
-        (900, "CM"),
-        (500, "D"),
-        (400, "CD"),
-        (100, "C"),
-        (90, "XC"),
-        (50, "L"),
-        (40, "XL"),
-        (10, "X"),
-        (9, "IX"),
-        (5, "V"),
-        (4, "IV"),
-        (1, "I")
-    ]
+  numeral_mapping: NumeralArray = [
+    (1000, "M"),
+    (900, "CM"),
+    (500, "D"),
+    (400, "CD"),
+    (100, "C"),
+    (90, "XC"),
+    (50, "L"),
+    (40, "XL"),
+    (10, "X"),
+    (9, "IX"),
+    (5, "V"),
+    (4, "IV"),
+    (1, "I")
+  ]
 
 
-proc numeral*(number: int): string =
-    var s = ""
-    var n = number
-    for numeral in numeral_mapping:
-        while n >= numeral.number:
-            s = s & numeral.roman
-            n = n - numeral.number
-    return s
+proc roman*(number: int): string =
+  result = ""
+  var n = number
+  for numeral in numeral_mapping:
+    while n >= numeral.number:
+      result = result & numeral.roman
+      n = n - numeral.number

data/tracks/nim/exercises/roman-numerals/roman_numerals_test.nim

@@ -1,28 +1,62 @@
-import 
-    roman_numerals, unittest, tables
-
-let numerals = {
-    1: "I",
-    2: "II",
-    3: "III",
-    4: "IV",
-    5: "V",
-    6: "VI",
-    9: "IX",
-    27: "XXVII",
-    48: "XLVIII",
-    49: "XLIX",
-    59: "LIX",
-    93: "XCIII",
-    141: "CXLI",
-    163: "CLXIII",
-    402: "CDII",
-    575: "DLXXV",
-    911: "CMXI",
-    1024: "MXXIV",
-    3000: "MMM",
-}.toTable
-
-test "test numerals":
-    for arabic, numeral in numerals.pairs:
-        check numeral(arabic) == numeral
+import unittest
+
+import roman_numerals
+
+suite "Roman Numerals":
+
+  test "1 is a single I":
+    check roman(1) == "I"
+
+  test "2 is two I's":
+    check roman(2) == "II"
+
+  test "3 is three I's":
+    check roman(3) == "III"
+
+  test "4, being 5 - 1, is IV":
+    check roman(4) == "IV"
+
+  test "5 is a single V":
+    check roman(5) == "V"
+
+  test "6, being 5 + 1, is VI":
+    check roman(6) == "VI"
+
+  test "9, being 10 - 1, is IX":
+    check roman(9) == "IX"
+
+  test "20 is two X's":
+    check roman(27) == "XXVII"
+
+  test "48 is not 50 - 2 but rather 40 + 8":
+    check roman(48) == "XLVIII"
+
+  test "49 is not 40 + 5 + 4 but rather 50 - 10 + 10 - 1":
+    check roman(49) == "XLIX"
+
+  test "50 is a single L":
+    check roman(59) == "LIX"
+
+  test "90, being 100 - 10, is XC":
+    check roman(93) == "XCIII"
+
+  test "100 is a single C":
+    check roman(141) == "CXLI"
+
+  test "60, being 50 + 10, is LX":
+    check roman(163) == "CLXIII"
+
+  test "400, being 500 - 100, is CD":
+    check roman(402) == "CDII"
+
+  test "500 is a single D":
+    check roman(575) == "DLXXV"
+
+  test "900, being 1000 - 100, is CM":
+    check roman(911) == "CMXI"
+
+  test "1000 is a single M":
+    check roman(1024) == "MXXIV"
+
+  test "3000 is three M's":
+    check roman(3000) == "MMM"

data/tracks/nim/exercises/scrabble-score/example.nim

@@ -1,13 +1,15 @@
-import tables, sequtils, strutils, math
+import
+  tables, sequtils, strutils, math
 
-let points = {
+let
+  points = {
     'a': 1, 'b': 3, 'c': 3, 'd': 2, 'e': 1,
     'f': 4, 'g': 2, 'h': 4, 'i': 1, 'j': 8,
     'k': 5, 'l': 1, 'm': 3, 'n': 1, 'o': 1,
     'p': 3, 'q': 10, 'r': 1, 's': 1, 't': 1,
     'u': 1, 'v': 4, 'w': 4, 'x': 8, 'y': 4,
     'z': 10
-}.toTable
+  }.toTable
 
 proc score*(word: string): int =
-    sum(word.toLowerAscii.map(proc(x: char): int = points[x]))
+  word.toLowerAscii.mapIt(points[it]).sum

data/tracks/nim/exercises/scrabble-score/scrabble_score_test.nim

@@ -2,36 +2,37 @@ import unittest
 
 from scrabble_score import score
 
+suite "Scrabble Score":
 
-test "lowercase letter":
+  test "lowercase letter":
     check score("a") == 1
 
-test "uppercase letter":
+  test "uppercase letter":
     check score("A") == 1
 
-test "valuable letter":
+  test "valuable letter":
     check score("f") == 4
 
-test "short word":
+  test "short word":
     check score("at") == 2
 
-test "short valuable word":
+  test "short valuable word":
     check score("zoo") == 12
 
-test "medium word":
+  test "medium word":
     check score("street") == 6
 
-test "medium valuable word":
+  test "medium valuable word":
     check score("quirky") == 22
 
-test "long mixed case word":
+  test "long mixed case word":
     check score("OxyphenButazone") == 41
 
-test "english like word":
+  test "english like word":
     check score("pinata") == 8
 
-test "empty input":
+  test "empty input":
     check score("") == 0
 
-test "entire alphabet available":
-    check score("abcdefghijklmnopqrstuvwxyz") == 87
+  test "entire alphabet available":
+    check score("abcdefghijklmnopqrstuvwxyz") == 87

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

@@ -1,25 +1,25 @@
 import sequtils
 
 proc valid(a, b, c: int): bool =
-    let greatThenZero = all([a, b, c], proc (x: int): bool = return x > 0)
-    let equalityCheck = (a + b >= c) and (a + c >= b) and (b + c >= a)
+  let greatThenZero = all([a, b, c], proc (x: int): bool = return x > 0)
+  let equalityCheck = (a + b >= c) and (a + c >= b) and (b + c >= a)
 
-    greatThenZero and equalityCheck
+  greatThenZero and equalityCheck
 
 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)
+  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 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)
+  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 isScalene*(sides: array[3, int]): bool =
-    let a = sides[0]
-    let b = sides[1]
-    let c = sides[2]
-    valid(a, b, c) and not isIsosceles(sides)
+  let a = sides[0]
+  let b = sides[1]
+  let c = sides[2]
+  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 isEquilateral([2, 2, 2]) == true
+    check isEquilateral([2, 2, 2]) == true
 
   test "false if any side is unequal":
-      check isEquilateral([2, 3, 2]) == false
+    check isEquilateral([2, 3, 2]) == false
 
   test "false if no sides are equal":
-      check isEquilateral([5, 4, 6]) == false
+    check isEquilateral([5, 4, 6]) == false
 
   test "false if all sides are zero":
-      check isEquilateral([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 isIsosceles([3, 4, 4]) == true
+    check isIsosceles([3, 4, 4]) == true
 
   test "true if first two sides are equal":
-      check isIsosceles([4, 4, 3]) == true
+    check isIsosceles([4, 4, 3]) == true
 
   test "true if first and last sides are equal":
-      check isIsosceles([4, 3, 4]) == true
+    check isIsosceles([4, 3, 4]) == true
 
   test "is equilateral triangles are also is isosceles":
-      check isIsosceles([4, 4, 4]) == true
+    check isIsosceles([4, 4, 4]) == true
 
   test "false if no sides are equal":
-      check isIsosceles([2, 3, 4]) == false
+    check isIsosceles([2, 3, 4]) == false
 
   test "violation of triangle inequality not is isosceles":
-      check isIsosceles([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 isScalene([5, 4, 6]) == true
+    check isScalene([5, 4, 6]) == true
 
   test "false if all sides are equal":
-      check isScalene([4, 4, 4]) == false
+    check isScalene([4, 4, 4]) == false
 
   test "false if two sides are equal":
-      check isScalene([4, 4, 3]) == false
+    check isScalene([4, 4, 3]) == false
 
   test "violation of triangle inequality not is scalene":
-      check isScalene([7, 3, 2]) == false
+    check isScalene([7, 3, 2]) == false

data/tracks/python/exercises/simple-cipher/simple_cipher_test.py

@@ -4,7 +4,7 @@ import re
 from simple_cipher import Cipher
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
 
 class SimpleCipherTest(unittest.TestCase):
     # Utility functions
@@ -21,7 +21,8 @@ class SimpleCipherTest(unittest.TestCase):
 class RandomKeyCipherTest(SimpleCipherTest):
     def test_can_encode(self):
         cipher = Cipher()
-        self.assertEqual(cipher.encode('aaaaaaaaaa'), cipher.key[:10])
+        plaintext = 'aaaaaaaaaa'
+        self.assertEqual(cipher.encode(plaintext), cipher.key[:len(plaintext)])
 
     def test_can_decode(self):
         cipher = Cipher()

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.172
+  version: 2.2.1.173
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-21 00:00:00.000000000 Z
+date: 2018-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip