trackler 2.1.0.19 → 2.1.0.20

data/tracks/r/exercises/word-count/test_word-count.R

@@ -1,49 +1,70 @@
-source('./word-count.R')
+source("./word-count.R")
 library(testthat)
 
 # When comparing lists, all.equal expects the objects to be in the same order
-# This expectation instead checks that a) the set of names are the same and b) each named object is equal
+# This expectation instead checks that a) the set of names are the same and
+# b) each named object is equal
 expect_equal_pairs <- function(object, expected) {
-  expect_equal(sort(names(object)), sort(names(expected)), info="names in lists differ")
-  for(name in names(expected)) {
-    expect_equal(object[name], expected[name], info="list element missing")
+  expect_equal(sort(names(object)),
+               sort(names(expected)),
+               info = "names in lists differ")
+  for (name in names(expected)) {
+    expect_equal(object[name], expected[name], info = "list element missing")
   }
 }
 
 test_that("count one word", {
   expect_equal_pairs(word_count("word"),
-    list("word" = 1)
-  )
+                     list("word" = 1))
 })
 
 test_that("count one of each word", {
   expect_equal_pairs(word_count("one of each"),
-    list("one" = 1, "of" = 1, "each" = 1)
-  )
+                     list(
+                       "one" = 1,
+                       "of" = 1,
+                       "each" = 1
+                     ))
 })
 
 test_that("multiple occurrences of a word", {
-  expect_equal_pairs(word_count("one fish two fish red fish blue fish"),
-    list("one" = 1, "fish" = 4, "two" = 1, "red" = 1, "blue" = 1)
+  expect_equal_pairs(
+    word_count("one fish two fish red fish blue fish"),
+    list(
+      "one" = 1,
+      "fish" = 4,
+      "two" = 1,
+      "red" = 1,
+      "blue" = 1
+    )
   )
 })
 
 test_that("ignore punctuation", {
-  expect_equal_pairs(word_count("car : carpet as java : javascript!!&@$%^&"),
-    list("car" = 1, "carpet" = 1, "as" = 1, "java" = 1, "javascript" = 1)
+  expect_equal_pairs(
+    word_count("car : carpet as java : javascript!!&@$%^&"),
+    list(
+      "car" = 1,
+      "carpet" = 1,
+      "as" = 1,
+      "java" = 1,
+      "javascript" = 1
+    )
   )
 })
 
 test_that("include numbers", {
   expect_equal_pairs(word_count("testing, 1, 2 testing"),
-    list("testing" = 2, "1" = 1, "2" = 1)
-  )
+                     list(
+                       "testing" = 2,
+                       "1" = 1,
+                       "2" = 1
+                     ))
 })
 
 test_that("normalize case", {
   expect_equal_pairs(word_count("go Go GO Stop stop"),
-    list("go" = 3, "stop" = 2)
-  )
+                     list("go" = 3, "stop" = 2))
 })
 
 print("All tests passed!")

data/tracks/vimscript/config.json

@@ -23,6 +23,29 @@
       "slug": "bob",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "rna-transcription",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "anagram",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "difference-of-squares",
+      "difficulty": 1,
+      "topics": [
+      ]
+    },
+    {
+      "slug": "raindrops",
+      "difficulty": 1,
+      "topics": [
+      ]
     }
   ],
   "deprecated": [],

data/tracks/vimscript/exercises/anagram/anagram.vader

@@ -0,0 +1,95 @@
+Execute (no matches):
+  let word       = 'diaper'
+  let candidates = ['hello', 'world', 'zombies', 'pants']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects simple anagram):
+  let word       = 'ant'
+  let candidates = ['tan', 'stand', 'at']
+  let expected   = ['tan']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (does not detect false positives):
+  let word       = 'galea'
+  let candidates = ['eagle']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects two anagrams):
+  let word       = 'master'
+  let candidates = ['stream', 'pigeon', 'maters']
+  let expected   = ['maters', 'stream']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (does not detect anagram subsets):
+  let word       = 'good'
+  let candidates = ['dog', 'goody']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects anagram):
+  let word       = 'listen'
+  let candidates = ['enlists', 'google', 'inlets', 'banana']
+  let expected   = ['inlets']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects three anagrams):
+  let word       = 'allergy'
+  let candidates = ['gallery', 'ballerina', 'regally', 'clergy', 'largely', 'leading']
+  let expected   = ['gallery', 'largely', 'regally']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (does not detect identical words):
+  let word       = 'corn'
+  let candidates = ['corn', 'dark', 'Corn', 'rank', 'CORN', 'cron', 'park']
+  let expected   = ['cron']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (does not detect non-anagrams with identical checksum):
+  let word       = 'mass'
+  let candidates = ['last']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects anagrams case insensitively):
+  let word       = 'Orchestra'
+  let candidates = ['cashregister', 'Carthorse', 'radishes']
+  let expected   = ['Carthorse']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects anagrams using case insensitive subject):
+  let word       = 'Orchestra'
+  let candidates = ['cashregister', 'carthorse', 'radishes']
+  let expected   = ['carthorse']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (detects anagrams using case insensitive possible matches):
+  let word       = 'orchestra'
+  let candidates = ['cashregister', 'Carthorse', 'radishes']
+  let expected   = ['Carthorse']
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (does not detect a word as its own anagram):
+  let word       = 'banana'
+  let candidates = ['Banana']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (does not detect an anagramif the original word is repeated):
+  let word       = 'go'
+  let candidates = ['go Go GO']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (anagrams must use all letters exactly once):
+  let word       = 'tapper'
+  let candidates = ['patter']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)
+
+Execute (capital word is not own anagram):
+  let word       = 'BANANA'
+  let candidates = ['Banana']
+  let expected   = []
+  AssertEqual expected, Anagram(word, candidates)

data/tracks/vimscript/exercises/anagram/anagram.vim

@@ -0,0 +1,19 @@
+"
+" Given a word and a list of possible anagrams, select the correct sublist.
+"
+" Hints:
+"
+"   - Same words don't match.
+"   - Cases are treated insensitivley.
+"   - The returned list is sorted.
+"
+" Example:
+"
+"   :echo Anagram('foo', ['foo', 'bar', 'oof', 'Ofo'])
+"   ['Ofo', 'oof']
+"
+function! Anagram(word, candidates) abort
+
+  " your solution goes here
+
+endfunction

data/tracks/vimscript/exercises/anagram/example.vim

@@ -0,0 +1,18 @@
+function! Anagram(word, candidates) abort
+  let fp = s:fingerprint(a:word)
+  let matches = []
+
+  for cand in a:candidates
+    if cand ==? a:word
+      continue
+    elseif s:fingerprint(cand) ==? fp
+      let matches += [cand]
+    endif
+  endfor
+
+  return sort(matches)
+endfunction
+
+function! s:fingerprint(word) abort
+  return sort(reverse(split(tolower(a:word), '\zs')))
+endfunction

data/tracks/vimscript/exercises/difference-of-squares/difference_of_squares.vader

@@ -0,0 +1,35 @@
+Execute (square of sum 0):
+  AssertEqual 0, SquareOfSum(0)
+
+Execute (square of sum 1):
+  AssertEqual 1, SquareOfSum(1)
+
+Execute (square of sum 5):
+  AssertEqual 225, SquareOfSum(5)
+
+Execute (square of sum 100):
+  AssertEqual 25502500, SquareOfSum(100)
+
+Execute (sum of squares 0):
+  AssertEqual 0, SumOfSquares(0)
+
+Execute (sum of squares 1):
+  AssertEqual 1, SumOfSquares(1)
+
+Execute (sum of squares 5):
+  AssertEqual 55, SumOfSquares(5)
+
+Execute (sum of squares 100):
+  AssertEqual 338350, SumOfSquares(100)
+
+Execute (differences of squares 0):
+  AssertEqual 0, Difference(0)
+
+Execute (differences of squares 1):
+  AssertEqual 0, Difference(1)
+
+Execute (differences of squares 5):
+  AssertEqual 170, Difference(5)
+
+Execute (differences of squares 100):
+  AssertEqual 25164150, Difference(100)

data/tracks/vimscript/exercises/difference-of-squares/difference_of_squares.vim

@@ -0,0 +1,24 @@
+"
+" Find the difference between the square of the sum and the sum of the squares
+" of the first N natural numbers.
+"
+" Examples:
+"
+"   :echo SquareOfSum(3)
+"   36
+"   :echo SumOfSquares(3)
+"   14
+"   :echo Difference(3)
+"   22
+"
+function! Difference(number) abort
+  " your implemention goes here
+endfunction
+
+function! SquareOfSum(number) abort
+  " your implemention goes here
+endfunction
+
+function! SumOfSquares(number) abort
+  " your implemention goes here
+endfunction

data/tracks/vimscript/exercises/difference-of-squares/example.vim

@@ -0,0 +1,19 @@
+function! Difference(number) abort
+  return SquareOfSum(a:number) - SumOfSquares(a:number)
+endfunction
+
+function! SquareOfSum(number) abort
+  let sum = 0
+  for n in range(1, a:number)
+    let sum += n
+  endfor
+  return float2nr(pow(sum, 2))
+endfunction
+
+function! SumOfSquares(number) abort
+  let sum = 0
+  for n in range(1, a:number)
+    let sum += float2nr(pow(n, 2))
+  endfor
+  return sum
+endfunction

data/tracks/vimscript/exercises/raindrops/example.vim

@@ -0,0 +1,9 @@
+function! Raindrops(number) abort
+  let s = ''
+
+  if a:number % 3 == 0 | let s .= 'Pling' | endif
+  if a:number % 5 == 0 | let s .= 'Plang' | endif
+  if a:number % 7 == 0 | let s .= 'Plong' | endif
+
+  return empty(s) ? string(a:number) : s
+endfunction

data/tracks/vimscript/exercises/raindrops/raindrops.vader

@@ -0,0 +1,53 @@
+Execute (the sound for 1 is 1):
+  AssertEqual '1', Raindrops(1)
+
+Execute (the sound for 3 is Pling):
+  AssertEqual 'Pling', Raindrops(3)
+
+Execute (the sound for 5 is Plang):
+  AssertEqual 'Plang', Raindrops(5)
+
+Execute (the sound for 7 is Plong):
+  AssertEqual 'Plong', Raindrops(7)
+
+Execute (the sound for 6 is Pling as it has a factor 3):
+  AssertEqual 'Pling', Raindrops(6)
+
+Execute (2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base):
+  AssertEqual '8', Raindrops(8)
+
+Execute (the sound for 9 is Pling as it has a factor 3):
+  AssertEqual 'Pling', Raindrops(9)
+
+Execute (the sound for 10 is Plang as it has a factor 5):
+  AssertEqual 'Plang', Raindrops(10)
+
+Execute (the sound for 14 is Plong as it has a factor 7):
+  AssertEqual 'Plong', Raindrops(14)
+
+Execute (the sound for 15 is PlingPlang as it has factors 3 and 5):
+  AssertEqual 'PlingPlang', Raindrops(15)
+
+Execute (the sound for 21 is PlingPlong as it has factors 3 and 7):
+  AssertEqual 'PlingPlong', Raindrops(21)
+
+Execute (the sound for 25 is Plang as it has factor 5):
+  AssertEqual 'Plang', Raindrops(5)
+
+Execute (the sound for 27 is Pling as it has factor 3):
+  AssertEqual 'Pling', Raindrops(27)
+
+Execute (the sound for 35 is PlangPlong as it has factors 5 and 7):
+  AssertEqual 'PlangPlong', Raindrops(35)
+
+Execute (the sound for 49 is Plong as it has factor 7):
+  AssertEqual 'Plong', Raindrops(49)
+
+Execute (the sound for 52 is 52):
+  AssertEqual '52', Raindrops(52)
+
+Execute (the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7):
+  AssertEqual 'PlingPlangPlong', Raindrops(105)
+
+Execute (the sound for 3125 is Plang as it has factor 5):
+  AssertEqual 'Plang', Raindrops(3125)

data/tracks/vimscript/exercises/raindrops/raindrops.vim

@@ -0,0 +1,18 @@
+"
+" Convert a number to a string, the contents of which depend on the number's
+" factors.
+"
+"   - If the number has 3 as a factor, output 'Pling'.
+"   - If the number has 5 as a factor, output 'Plang'.
+"   - If the number has 7 as a factor, output 'Plong'.
+"   - If the number does not have 3, 5, or 7 as a factor, just pass
+"     the number's digits straight through.
+"
+" Example:
+"
+"   :echo Raindrops(15)
+"   PlingPlang
+"
+function! Raindrops(number) abort
+  " your solution goes here
+endfunction

data/tracks/vimscript/exercises/rna-transcription/example.vim

@@ -0,0 +1,3 @@
+function! OfDNA(strand) abort
+  return a:strand =~# '[^CGTA]' ? '' : tr(a:strand, 'CGTA', 'GCAU')
+endfunction

data/tracks/vimscript/exercises/rna-transcription/rna_transcription.vader

@@ -0,0 +1,23 @@
+Execute (complement of cytosine is guanine):
+  AssertEqual 'G', OfDNA('C')
+
+Execute (complement of guanine is cytosine):
+  AssertEqual 'C', OfDNA('G')
+
+Execute (complement of thymine is adenine):
+  AssertEqual 'A', OfDNA('T')
+
+Execute (complement of adenine is uracil):
+  AssertEqual 'U', OfDNA('A')
+
+Execute (rna complement):
+  AssertEqual 'UGCACCAGAAUU', OfDNA('ACGTGGTCTTAA')
+
+Execute (dna correctly handles invalid input):
+  AssertEqual '', OfDNA('U')
+
+Execute (dna correctly handles completely invalid input):
+  AssertEqual '', OfDNA('XXX')
+
+Execute (dna correctly handles partially invalid input):
+  AssertEqual '', OfDNA('ACGTXXXCTAA')