trackler 2.0.8.37 → 2.0.8.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c28e37a5a6924f0b2314b13b0e818be4a92899d
-  data.tar.gz: 1f18eafff4c0a2354304c60ee5c782966640ce8a
+  metadata.gz: fcc166e36a7b734f6e7c78d015a93311bb78eb39
+  data.tar.gz: f7439a7ec5b911ba95a279186d799368c895db5e
 SHA512:
-  metadata.gz: 24d534b00d118d16ce985e1a90c064ca4e91268164e6e844d8e7c74d54d454efb16a8916fa9239b2336978794802f9a0f2b0b59410ecfc04a660598b94beb205
-  data.tar.gz: 70dfabb60b6dec8f2eb045ccb6699d55560269f7b09f65a0daa97a9b811deb2d560cb1e610c8fedf6e39d14fc9230e3bdb724715d8f8f60956f71872f0e1d744
+  metadata.gz: bee112127f3bd191392aadd16e0a8b7d6f7b245debddf91f48b8066ec12d79b3890e78d8a5149807e9ce1a38f4356942a99ee43a28ce769aac5bad86c4b358a5
+  data.tar.gz: a73867dadaf36325e0e92a64bc6638541f105fffd3b60e30bb8534beb86cd3f37df6821bd1c1b7edbc5b38cec31075ba7285c1e6b4a4e309bf6c04e85bf71b5e

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.37"
+  VERSION = "2.0.8.38"
 end

data/tracks/delphi/config.json

@@ -2,7 +2,7 @@
   "slug": "delphi",
   "language": "Delphi Pascal",
   "repository": "https://github.com/exercism/xdelphi",
-  "active": false,
+  "active": true,
   "exercises": [
      {
 	  "slug": "hello-world",

data/tracks/delphi/docs/ABOUT.md

@@ -1,7 +1,7 @@
 ## Delphi (programming language) ##
 *From Wikipedia, the free encyclopedia*
 
-**Embarcadero Delphi** is a [programming language](https://en.wikipedia.org/wiki/Programming_language) and [software development kit](https://en.wikipedia.org/wiki/Software_development_kit) (SDK) for [desktop](https://en.wikipedia.org/wiki/Graphical_user_interface), [mobile](https://en.wikipedia.org/wiki/Mobile_app), [web](https://en.wikipedia.org/wiki/Web_application), and [console](https://en.wikipedia.org/wiki/Console_application) applications.[[1]](https://en.wikipedia.org/wiki/Delphi_(programming_language)#cite_note-Buchanan2003-1) Delphi's compilers use their own [Object Pascal](https://en.wikipedia.org/wiki/Object_Pascal) dialect of [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) and generate native code for several platforms: Windows ([x86](https://en.wikipedia.org/wiki/IA-32) and [x64](https://en.wikipedia.org/wiki/X86-64)), [OS X](https://en.wikipedia.org/wiki/MacOS) (32-bit only), [iOS](https://en.wikipedia.org/wiki/IOS) (32 and 64-bit) and [Android](https://en.wikipedia.org/wiki/Android_(operating_system)).
+**Embarcadero Delphi** is a [programming language](https://en.wikipedia.org/wiki/Programming_language) and [software development kit](https://en.wikipedia.org/wiki/Software_development_kit) (SDK) for [desktop](https://en.wikipedia.org/wiki/Graphical_user_interface), [mobile](https://en.wikipedia.org/wiki/Mobile_app), [web](https://en.wikipedia.org/wiki/Web_application), and [console](https://en.wikipedia.org/wiki/Console_application) applications.[[1]](https://en.wikipedia.org/wiki/Delphi_(programming_language)#cite_note-Buchanan2003-1) Delphi's compilers use their own [Object Pascal](https://en.wikipedia.org/wiki/Object_Pascal) dialect of [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) and generate native code for several platforms: Windows ([x86](https://en.wikipedia.org/wiki/IA-32) and [x64](https://en.wikipedia.org/wiki/X86-64)), [OS X](https://en.wikipedia.org/wiki/MacOS) (32-bit only), [iOS](https://en.wikipedia.org/wiki/IOS) (32 and 64-bit), [Android](https://en.wikipedia.org/wiki/Android_(operating_system)), and 64 bit [Linux](https://en.wikipedia.org/wiki/Linux).
 
 Delphi, part of [RAD Studio](https://en.wikipedia.org/wiki/Delphi_(programming_language)#RAD_Studio), includes a code editor with [Code Insight](https://en.wikipedia.org/wiki/Code_Insight) ([code completion](https://en.wikipedia.org/wiki/Autocomplete#In_source_code_editors)), [Error Insight](https://en.wikipedia.org/wiki/Error_Insight) (real-time error-checking), and other features; [refactoring](https://en.wikipedia.org/wiki/Code_refactoring); a visual forms designer for both [VCL](https://en.wikipedia.org/wiki/Visual_Component_Library) (native Windows) and [FMX](https://en.wikipedia.org/wiki/FireMonkey) (cross-platform, partially native per platform); an integrated debugger for all platforms including mobile; source control ([SVN](https://en.wikipedia.org/wiki/Apache_Subversion), [git](https://en.wikipedia.org/wiki/Git), and [Mercurial](https://en.wikipedia.org/wiki/Mercurial)); and support for third-party plugins. It has strong database support. Delphi is remarkably fast to compile:[[2]](https://en.wikipedia.org/wiki/Delphi_(programming_language)#cite_note-2) unlike any other common languages, including C# and Swift, it is not unusual for a Delphi project of a million lines to compile in a few seconds – one benchmark gave 170,000 lines per second.[[3]](https://en.wikipedia.org/wiki/Delphi_(programming_language)#cite_note-3)[[4]](https://en.wikipedia.org/wiki/Delphi_(programming_language)#cite_note-4) It is under active development, with (in 2016) releases every six months, with new platforms being added approximately every second release.[[5]](https://en.wikipedia.org/wiki/Delphi_(programming_language)#cite_note-5)
 

data/tracks/elm/exercises/nucleotide-count/Tests.elm

@@ -16,7 +16,7 @@ tests =
             \() ->
                 Expect.equal { a = 0, t = 0, c = 0, g = 0 }
                     (nucleotideCounts "")
-        , test "repetitive-sequence-has-only-guanosine" <|
+        , test "repetitive sequence has only guanine" <|
             \() ->
                 Expect.equal { a = 0, t = 0, c = 0, g = 8 }
                     (nucleotideCounts "GGGGGGGG")

data/tracks/r/config.json

@@ -89,6 +89,51 @@
       "difficulty": 1,
       "slug": "sieve",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "prime-factors",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "largest-series-product",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "scrabble-score",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "perfect-numbers",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "pascals-triangle",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "rotational-cipher",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "tournament",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "rna-transcription",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "isogram",
+      "topics": []
     }
   ]
 }

data/tracks/r/exercises/anagram/test_anagram.R

@@ -1,5 +1,5 @@
 source('./anagram.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("no matches", {
   subject <- "diaper"

data/tracks/r/exercises/bob/test_bob.R

@@ -1,5 +1,5 @@
 source('./bob.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("stating something", {
   input <- "Tom-ay-to, tom-aaaah-to."

data/tracks/r/exercises/difference-of-squares/test_difference-of-squares.R

@@ -1,5 +1,5 @@
 source('./difference-of-squares.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("difference of squares 0", {
   input <- 0

data/tracks/r/exercises/grains/test_grains.R

@@ -1,5 +1,5 @@
-source('./square.R')
-suppressPackageStartupMessages({ require(testthat) })
+source('./grains.R')
+library(testthat)
 
 test_that("Case 1", {
   expect_equal(square(1), 1)

data/tracks/r/exercises/hamming/test_hamming.R

@@ -1,5 +1,5 @@
 source('./hamming.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("identical strands", {
   strand1 <-"A"

data/tracks/r/exercises/hello-world/test_hello-world.R

@@ -1,5 +1,5 @@
 source('./hello-world.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("no name", {
   expect_equal(hello_world(), "Hello, World!")

data/tracks/r/exercises/isogram/example.R

@@ -0,0 +1,9 @@
+is_isogram <- function(word) {
+  
+  func <- function(x) {
+    sum(x == unlist(strsplit(tolower(word), "")))
+  }
+  
+  all(lapply(letters, FUN = func)<=1)
+  
+}

data/tracks/r/exercises/isogram/isogram.R

@@ -0,0 +1,3 @@
+is_isogram <- function(word) {
+  
+}

data/tracks/r/exercises/isogram/test_isogram.R

@@ -0,0 +1,44 @@
+source('./isogram.R')
+library(testthat)
+
+test_that("empty string", {
+  word <- ""
+  expect_equal(is_isogram(word), TRUE)
+})
+
+test_that("isogram with only lower case characters", {
+  word <- "isogram"
+  expect_equal(is_isogram(word), TRUE)
+})
+
+test_that("word with one duplicated character", {
+  word <- "eleven"
+  expect_equal(is_isogram(word), FALSE)
+})
+
+test_that("longest reported english isogram", {
+  word <- "subdermatoglyphic"
+  expect_equal(is_isogram(word), TRUE)
+})
+
+test_that("word with duplicated character in mixed case", {
+  word <- "Alphabet"
+  expect_equal(is_isogram(word), FALSE)
+})
+
+test_that("hypothetical isogrammic word with hyphen", {
+  word <- "thumbscrew-japingly"
+  expect_equal(is_isogram(word), TRUE)
+})
+
+test_that("isogram with duplicated non letter character", {
+  word <- "Hjelmqvist-Gryb-Zock-Pfund-Wax"
+  expect_equal(is_isogram(word), TRUE)
+})
+
+test_that("made-up name that is an isogram", {
+  word <- "Emily Jung Schwartzkopf"
+  expect_equal(is_isogram(word), TRUE)
+})
+
+print("All tests passed!")

data/tracks/r/exercises/largest-series-product/example.R

@@ -0,0 +1,22 @@
+largestSeriesProduct <- function(digits, span){
+  
+  nums <- as.numeric(unlist(strsplit(digits, "")))
+  
+  if (any(is.na(nums)) || span < 0 || span > length(nums)) {
+    stop("Non-numeric characters or span less than digit length")
+  }
+  
+  if (span == 0) {
+    return (1)
+  }
+  
+  indices <- 1:(length(nums)-span+1)
+  
+  get_prod <- function(index, nums, span) {
+    prod(nums[index:(index+span-1)])
+  }
+  
+  products <- sapply(indices, FUN = get_prod, nums, span)
+  
+  max(products)
+}

data/tracks/r/exercises/largest-series-product/largest-series-product.R

@@ -0,0 +1,3 @@
+largestSeriesProduct <- function(digits, span){
+  
+}

data/tracks/r/exercises/largest-series-product/test_largest-series-product.R

@@ -0,0 +1,110 @@
+source('./largest-series-product.R')
+library(testthat)
+
+test_that("finds the largest product if span equals length", {
+  digits <- "29"
+  span <- 2
+  expect_equal(largestSeriesProduct(digits, span), 18)
+})
+
+test_that("can find the largest product of 2 with numbers in order", {
+  digits <- "0123456789"
+  span <- 2
+  expect_equal(largestSeriesProduct(digits, span), 72)
+})
+
+test_that("can find the largest product of 2", {
+  digits <- "576802143"
+  span <- 2
+  expect_equal(largestSeriesProduct(digits, span), 48)
+})
+
+test_that("can find the largest product of 3 with numbers in order", {
+  digits <- "0123456789"
+  span <- 3
+  expect_equal(largestSeriesProduct(digits, span), 504)
+})
+
+test_that("can find the largest product of 3", {
+  digits <- "1027839564"
+  span <- 3
+  expect_equal(largestSeriesProduct(digits, span), 270)
+})
+
+test_that("can find the largest product of 5 with numbers in order", {
+  digits <- "0123456789"
+  span <- 5
+  expect_equal(largestSeriesProduct(digits, span), 15120)
+})
+
+test_that("can get the largest product of a big number", {
+  digits <- "73167176531330624919225119674426574742355349194934"
+  span <- 6
+  expect_equal(largestSeriesProduct(digits, span), 23520)
+})
+
+test_that("reports zero if the only digits are zero", {
+  digits <- "0000"
+  span <- 2
+  expect_equal(largestSeriesProduct(digits, span), 0)
+})
+
+test_that("reports zero if all spans include zero", {
+  digits <- "99099"
+  span <- 3
+  expect_equal(largestSeriesProduct(digits, span), 0)
+})
+
+test_that("rejects span longer than string length", {
+  digits <- "123"
+  span <- 4
+  expect_error(largestSeriesProduct(digits, span))
+})
+
+# There may be some confusion about whether this should be 1 or error.
+# The reasoning for it being 1 is this:
+#   There is one 0-character string contained in the empty string.
+#   That's the empty string itself.
+#   The empty product is 1 (the identity for multiplication).
+#   Therefore LSP('', 0) is 1.
+#   It's NOT the case that LSP('', 0) takes max of an empty list.
+#   So there is no error.
+# Compare against LSP('123', 4):
+#   There are zero 4-character strings in '123'.
+#   So LSP('123', 4) really DOES take the max of an empty list.
+#   So LSP('123', 4) errors and LSP('', 0) does NOT.
+
+test_that("reports 1 for empty string and empty product (0 span)", {
+  digits <- ""
+  span <- 0
+  expect_equal(largestSeriesProduct(digits, span), 1)
+})
+
+# As above, there is one 0-character string in '123'.
+# So again no error. It's the empty product, 1.
+
+test_that("reports 1 for nonempty string and empty product (0 span)", {
+  digits <- "123"
+  span <- 0
+  expect_equal(largestSeriesProduct(digits, span), 1)
+})
+
+test_that("rejects empty string and nonzero span", {
+  digits <- ""
+  span <- 1
+  expect_error(largestSeriesProduct(digits, span))
+})
+
+test_that("rejects invalid character in digits", {
+  digits <- "1234a5"
+  span <- 2
+  expect_error(largestSeriesProduct(digits, span))
+})
+
+test_that("rejects negative span", {
+  digits <- "12345"
+  span <- -1
+  expect_error(largestSeriesProduct(digits, span))
+})
+
+print("All tests passed!")

data/tracks/r/exercises/leap/test_leap.R

@@ -1,5 +1,5 @@
 source('./leap.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("year not divisible by 4: common year", {
   year <- 2015

data/tracks/r/exercises/luhn/test_luhn.R

@@ -1,5 +1,5 @@
 source('./luhn.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("single digit strings can not be valid", {
   input <- "1"

data/tracks/r/exercises/pascals-triangle/example.R

@@ -0,0 +1,27 @@
+pascalsTriangle <- function(n) {
+  
+  if (n == 0) {
+    return (list())
+  }
+  else if (n == 1) {
+    return (list(1))
+  }
+  else if (n == 2) {
+    return (list(1, c(1,1)))
+  }
+  else if (n >= 3) {
+    triangle <- list(1, c(1,1))
+    for (x in 3:n) {
+      row <- rep(1, x)
+      for (i in 2:(x-1)) {
+        row[i] = sum(triangle[[x-1]][(i-1):i])
+      }
+      triangle[[x]] = row
+    }
+    return (triangle)
+  }
+  else {
+    stop("argument n needs to be an integer")
+  }
+  
+}

data/tracks/r/exercises/pascals-triangle/pascals-triangle.R

@@ -0,0 +1,3 @@
+pascalsTriangle <- function(n) {
+  
+}

data/tracks/r/exercises/pascals-triangle/test_pascals-triangle.R

@@ -0,0 +1,32 @@
+source('./pascals-triangle.R')
+library(testthat)
+
+test_that("zero rows", {
+  expect_equal(pascalsTriangle(0), list())
+})
+
+test_that("single row", {
+  expect_equal(pascalsTriangle(1), list(1))
+})
+
+test_that("two rows", {
+  expect_equal(pascalsTriangle(2), list(1, c(1, 1)))
+})
+
+test_that("three rows", {
+  expect_equal(pascalsTriangle(3), list(1, c(1, 1), c(1, 2, 1)))
+})
+
+test_that("four rows", {
+  expect_equal(pascalsTriangle(4), list(1, c(1, 1), c(1, 2, 1), c(1, 3, 3, 1)))
+})
+
+test_that("negative rows", {
+  expect_error(pascalsTriangle(-1))
+})
+
+test_that("null/no rows", {
+  expect_error(pascalsTriangle(NULL))
+})
+
+print("All tests passed!")

data/tracks/r/exercises/perfect-numbers/example.R

@@ -0,0 +1,22 @@
+isPerfect <- function(n){
+  
+  findFactors <- function(n) {
+    factors <- c()
+    for (i in 2:floor(n^0.5 + 1)) {
+      
+      if (n %% i == 0) {
+        if (i^2 != n) {
+          factors <- c(factors, i, n / i)
+        }
+        else {
+          factors <- c(factors, i)
+        }
+      }
+            
+    }
+    unique(factors)
+  }
+  
+  sum(findFactors(n)) + 1 == n
+  
+}

data/tracks/r/exercises/perfect-numbers/perfect-numbers.R

@@ -0,0 +1,3 @@
+isPerfect <- function(n){
+  
+}

data/tracks/r/exercises/perfect-numbers/test_perfect-numbers.R

@@ -0,0 +1,59 @@
+source('./perfect-number.R')
+library(testthat)
+
+test_that("first perfect number", {
+  n <- 6
+  expect_equal(isPerfect(n), TRUE)
+})
+
+test_that("no perfect number", {
+  n <- 8
+  expect_equal(isPerfect(n), FALSE)
+})
+
+test_that("second perfect number", {
+  n <- 28
+  expect_equal(isPerfect(n), TRUE)
+})
+
+test_that("abundant", {
+  n <- 20
+  expect_equal(isPerfect(n), FALSE)
+})
+
+test_that("answer to the ultimate question of life", {
+  n <- 42
+  expect_equal(isPerfect(n), FALSE)
+})
+
+test_that("third perfect number", {
+  n <- 496
+  expect_equal(isPerfect(n), TRUE)
+})
+
+test_that("odd abundant", {
+  n <- 945
+  expect_equal(isPerfect(n), FALSE)
+})
+
+test_that("fourth perfect number", {
+  n <- 8128
+  expect_equal(isPerfect(n), TRUE)
+})
+
+test_that("fifth perfect number", {
+  n <- 33550336
+  expect_equal(isPerfect(n), TRUE)
+})
+
+test_that("sixth perfect number", {
+  n <- 8589869056
+  expect_equal(isPerfect(n), TRUE)
+})
+
+test_that("seventh perfect number", {
+  n <- 137438691328
+  expect_equal(isPerfect(n), TRUE)
+})
+
+print("All tests passed!")

data/tracks/r/exercises/phone-number/test_phone-number.R

@@ -1,5 +1,5 @@
 source('./phone-number.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("cleans the number", {
   expect_equal(parsePhoneNumber("(123) 456-7890"), "1234567890")

data/tracks/r/exercises/prime-factors/example.R

@@ -0,0 +1,14 @@
+prime_factors <- function(number) {
+  factors <- c()
+  lowest.factor = 2
+  while (number > 1) {
+    if (number %% lowest.factor == 0) {
+      number <- number / lowest.factor
+      factors[length(factors) + 1] = lowest.factor
+    }
+    else {
+      lowest.factor <- lowest.factor + 1
+    }
+  }
+  return(factors)
+}

data/tracks/r/exercises/prime-factors/prime-factors.R

@@ -0,0 +1,3 @@
+prime_factors <- function() {
+  
+}

data/tracks/r/exercises/prime-factors/test_prime-factors.R

@@ -0,0 +1,50 @@
+source('./prime-factors.R')
+suppressPackageStartupMessages({ library(testthat) })
+
+test_that("no factors", {
+  number <- 1
+  expect_equal(prime_factors(number),
+               c()
+  )
+})
+
+test_that("prime number", {
+  number <- 2
+  expect_equal(prime_factors(number),
+               c(2)
+  )
+})
+
+test_that("square of a prime", {
+  number <- 9
+    expect_equal(prime_factors(number),
+                 c(3, 3)
+    )
+})
+
+test_that("cube of a prime", {
+  number <- 8
+    expect_equal(prime_factors(number),
+                 c(2, 2, 2)
+    )
+})
+
+test_that("product of primes and non-primes", {
+  number <- 12
+    expect_equal(prime_factors(number),
+                 c(2, 2, 3)
+    )
+})
+
+test_that("product of primes", {
+  number <- 901255
+    expect_equal(prime_factors(number),
+                 c(5, 17, 23, 461)
+    )
+})
+test_that("factors include a large prime", {
+  number <- 93819012551
+    expect_equal(prime_factors(number),
+                 c(11, 9539, 894119)
+    )
+})

data/tracks/r/exercises/raindrops/test_raindrops.R

@@ -1,5 +1,5 @@
 source('./raindrops.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("the sound for 1 is 1", {
   number <- 1

data/tracks/r/exercises/rna-transcription/example.R

@@ -0,0 +1,14 @@
+to_rna <- function(dna) {
+  
+  dna_to_rna <- list(G="C", C="G", T="A", A="U")
+  
+  func <- function(x) {
+    if (!(x %in% c("G","C","T","A"))) {
+      stop("invalid dna strand")
+    }
+    dna_to_rna[[x]]
+  }
+  
+  paste(lapply(strsplit(dna, "")[[1]], FUN=func), collapse = "")
+  
+}

data/tracks/r/exercises/rna-transcription/rna-transcription.R

@@ -0,0 +1,3 @@
+to_rna <- function(dna) {
+  
+}

data/tracks/r/exercises/rna-transcription/test_rna-transcription.R

@@ -0,0 +1,44 @@
+source('./rna-transcription.R')
+library(testthat)
+
+test_that("rna complement of cytosine is guanine", {
+  dna <- "C"
+  expect_equal(to_rna(dna), "G")
+})
+
+test_that("rna complement of guanine is cytosine", {
+  dna <- "G"
+  expect_equal(to_rna(dna), "C")
+})
+
+test_that("rna complement of thymine is adenine", {
+  dna <- "T"
+  expect_equal(to_rna(dna), "A")
+})
+
+test_that("rna complement of adenine is uracil", {
+  dna <- "A"
+  expect_equal(to_rna(dna), "U")
+})
+
+test_that("rna complement", {
+  dna <- "ACGTGGTCTTAA"
+  expect_equal(to_rna(dna), "UGCACCAGAAUU")
+})
+
+test_that("dna correctly handles invalid input", {
+  dna <- "U"
+  expect_error(to_rna(dna))
+})
+
+test_that("dna correctly handles completely invalid input", {
+  dna <- "XXX"
+  expect_error(to_rna(dna))
+})
+
+test_that("dna correctly handles partially invalid input", {
+  dna <- "ACGTXXXCTTAA"
+  expect_error(to_rna(dna))
+})
+
+print("All tests passed!")

data/tracks/r/exercises/rotational-cipher/example.R

@@ -0,0 +1,22 @@
+rotate <- function(text, key) {
+  
+  # Split string into character vector
+  textVector <- unlist(strsplit(text, ""))
+  
+  # Record which characters are upper case
+  upperCase <- toupper(textVector) == textVector
+  
+  # Rotate letter characters
+  rotationIndex <- (match(tolower(textVector), letters)+key-1) %% 26 + 1
+  rotatedVector <- letters[rotationIndex]
+  
+  # Restore non-letter characters in rotated character vector
+  rotatedVector[is.na(rotatedVector)] <- textVector[is.na(rotatedVector)]
+  
+  # Restore upper case characters
+  rotatedVector[upperCase] <- toupper(rotatedVector[upperCase])
+  
+  # Collapse character vector into string
+  paste(rotatedVector, collapse = "")
+  
+}

data/tracks/r/exercises/rotational-cipher/rotational-cipher.R

@@ -0,0 +1,3 @@
+rotate <- function(text, key) {
+  
+}

data/tracks/r/exercises/rotational-cipher/test_rotational-cipher.R

@@ -0,0 +1,64 @@
+source('./rotational-cipher.R')
+library(testthat)
+
+test_that("rotate a by 1", {
+  text <- "a"
+  key <- 1
+  expect_equal(rotate(text, key), "b")
+})
+
+test_that("rotate a by 26, same output as input", {
+  text <- "a"
+  key <- 26
+  expect_equal(rotate(text, key), "a")
+})
+
+test_that("rotate a by 0, same output as input", {
+  text <- "a"
+  key <- 0
+  expect_equal(rotate(text, key), "a")
+})
+
+test_that("rotate m by 13", {
+  text <- "m"
+  key <- 13
+  expect_equal(rotate(text, key), "z")
+})
+
+test_that("rotate n by 13 with wrap around alphabet", {
+  text <- "n"
+  key <- 13
+  expect_equal(rotate(text, key), "a")
+})
+
+test_that("rotate capital letters", {
+  text <- "OMG"
+  key <- 5
+  expect_equal(rotate(text, key), "TRL")
+})
+
+test_that("rotate spaces", {
+  text <- "O M G"
+  key <- 5
+  expect_equal(rotate(text, key), "T R L")
+})
+
+test_that("rotate numbers", {
+  text <- "Testing 1 2 3 testing"
+  key <- 4
+  expect_equal(rotate(text, key), "Xiwxmrk 1 2 3 xiwxmrk")
+})
+
+test_that("rotate punctuation", {
+  text <- "Let's eat, Grandma!"
+  key <- 21
+  expect_equal(rotate(text, key), "Gzo'n zvo, Bmviyhv!")
+})
+
+test_that("rotate all letters", {
+  text <- "The quick brown fox jumps over the lazy dog."
+  key <- 13
+  expect_equal(rotate(text, key), "Gur dhvpx oebja sbk whzcf bire gur ynml qbt.")
+})
+
+print("All tests passed!")

data/tracks/r/exercises/scrabble-score/example.R

@@ -0,0 +1,19 @@
+scrabbleScore <- function(input){
+  
+  # Letter                           Value
+  # A, E, I, O, U, L, N, R, S, T       1
+  # D, G                               2
+  # B, C, M, P                         3
+  # F, H, V, W, Y                      4
+  # K                                  5
+  # J, X                               8
+  # Q, Z                               10
+  
+  letterScore <- c(1,3,3,2,1,4,2,4,1,8,5,1,3,1,1,3,10,1,1,1,1,4,4,8,4,10)
+  names(letterScore) <- LETTERS
+  
+  chars <- unlist(strsplit(input, ""))
+  
+  sum(letterScore[toupper(chars)])
+  
+}

data/tracks/r/exercises/scrabble-score/scrabble-score.R

@@ -0,0 +1,3 @@
+scrabbleScore <- function(input){
+  
+}

data/tracks/r/exercises/scrabble-score/test_scrabble-score.R

@@ -0,0 +1,59 @@
+source('./scrabble-score.R')
+library(testthat)
+
+test_that("lowercase letter", {
+  input <- "a"
+  expect_equal(scrabbleScore(input), 1)
+})
+
+test_that("uppercase letter", {
+  input <- "A"
+  expect_equal(scrabbleScore(input), 1)
+})
+
+test_that("valuable letter", {
+  input <- "f"
+  expect_equal(scrabbleScore(input), 4)
+})
+
+test_that("short word", {
+  input <- "at"
+  expect_equal(scrabbleScore(input), 2)
+})
+
+test_that("short, valuable word", {
+  input <- "zoo"
+  expect_equal(scrabbleScore(input), 12)
+})
+
+test_that("medium word", {
+  input <- "street"
+  expect_equal(scrabbleScore(input), 6)
+})
+
+test_that("medium, valuable word", {
+  input <- "quirky"
+  expect_equal(scrabbleScore(input), 22)
+})
+
+test_that("long, mixed-case word", {
+  input <- "OxyphenButazone"
+  expect_equal(scrabbleScore(input), 41)
+})
+
+test_that("english-like word", {
+  input <- "pinata"
+  expect_equal(scrabbleScore(input), 8)
+})
+
+test_that("empty input", {
+  input <- ""
+  expect_equal(scrabbleScore(input), 0)
+})
+
+test_that("entire alphabet available", {
+  input <- "abcdefghijklmnopqrstuvwxyz"
+  expect_equal(scrabbleScore(input), 87)
+})
+
+print("All tests passed!")

data/tracks/r/exercises/secret-handshake/test_secret-handshake.R

@@ -1,5 +1,5 @@
 source('./secret-handshake.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("wink for 1", {
   expect_equal(handshake(1), c("wink"))

data/tracks/r/exercises/sieve/test_sieve.R

@@ -1,5 +1,5 @@
 source('./sieve.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("no primes under two", {
   expect_equal(sieve(1), c())

data/tracks/r/exercises/space-age/test_space-age.R

@@ -1,5 +1,5 @@
 source('./space-age.R')
-suppressPackageStartupMessages({ require(testthat) })
+library(testthat)
 
 test_that("Age on Earth", {
   seconds <- 1000000000

data/tracks/r/exercises/sum-of-multiples/test_sum-of-multiples.R

@@ -1,5 +1,5 @@
-source('./sum_of_multiples.R')
-suppressPackageStartupMessages({ require(testthat) })
+source('./sum-of-multiples.R')
+library(testthat)
 
 test_that("Case 1", {
   expect_equal(sum_of_multiples(c(3,5), 1), 0)

data/tracks/r/exercises/tournament/example.R

@@ -0,0 +1,35 @@
+tournament <- function(input) {
+
+  results <- data.frame(Team = "tempTeam", MP = 0, W = 0, D = 0, L = 0, P = 0)
+  
+  for (item in input) {
+    
+    match <- unlist(strsplit(item, ";"))
+    # Check that match result is valid
+    if (length(match) != 3 || !(match[3] %in% c("draw", "win", "loss"))) {
+      next
+    }
+    else {
+      # Process result
+      if (match[3]=="draw") {
+        results <- rbind(results, c(match[1], 1, 0, 1, 0, 1), c(match[2], 1, 0, 1, 0, 1))
+      } else if (match[3]=="win") {
+        results <- rbind(results, c(match[1], 1, 1, 0, 0, 3), c(match[2], 1, 0, 0, 1, 0))
+      } else {
+        results <- rbind(results, c(match[2], 1, 1, 0, 0, 3), c(match[1], 1, 0, 0, 1, 0))
+      }
+    }
+    
+  }
+  results$MP <- as.numeric(results$MP)
+  results$W <- as.numeric(results$W)
+  results$D <- as.numeric(results$D)
+  results$L <- as.numeric(results$L)
+  results$P <- as.numeric(results$P)
+  
+  output <- aggregate(.~Team, results[-1,], sum)
+  output <- output[order(-output$P,output$Team), ]
+  row.names(output) <- 1:nrow(output)
+  output
+  
+}

data/tracks/r/exercises/tournament/test_tournament.R

@@ -0,0 +1,140 @@
+source('./tournament.R')
+library(testthat)
+
+options(stringsAsFactors = FALSE)
+
+test_that("typical input", {
+  input <- c("Allegoric Alaskans;Blithering Badgers;win",
+             "Devastating Donkeys;Courageous Californians;draw",
+             "Devastating Donkeys;Allegoric Alaskans;win",
+             "Courageous Californians;Blithering Badgers;loss",
+             "Blithering Badgers;Devastating Donkeys;loss",
+             "Allegoric Alaskans;Courageous Californians;win")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Devastating Donkeys","Allegoric Alaskans",
+               "Blithering Badgers","Courageous Californians"),
+      MP = c(3, 3, 3, 3),
+      W = c(2, 2, 1, 0),
+      D = c(1, 0, 0, 1),
+      L = c(0, 1, 2, 2),
+      P = c(7, 6, 3, 1)
+    )
+  )
+})
+
+test_that("incomplete competition (not all pairs have played)", {
+  input <- c("Allegoric Alaskans;Blithering Badgers;loss",
+             "Devastating Donkeys;Allegoric Alaskans;loss",
+             "Courageous Californians;Blithering Badgers;draw",
+             "Allegoric Alaskans;Courageous Californians;win")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Allegoric Alaskans","Blithering Badgers",
+               "Courageous Californians","Devastating Donkeys"),
+      MP = c(3, 2, 2, 1),
+      W = c(2, 1, 0, 0),
+      D = c(0, 1, 1, 0),
+      L = c(1, 0, 1, 1),
+      P = c(6, 4, 1, 0)
+    )
+  )
+})
+
+test_that("ties broken alphabetically", {
+  input <- c("Courageous Californians;Devastating Donkeys;win",
+             "Allegoric Alaskans;Blithering Badgers;win",
+             "Devastating Donkeys;Allegoric Alaskans;loss",
+             "Courageous Californians;Blithering Badgers;win",
+             "Blithering Badgers;Devastating Donkeys;draw",
+             "Allegoric Alaskans;Courageous Californians;draw")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Allegoric Alaskans","Courageous Californians",
+              "Blithering Badgers","Devastating Donkeys"),
+      MP = c(3, 3, 3, 3),
+      W = c(2, 2, 0, 0),
+      D = c(1, 1, 1, 1),
+      L = c(0, 0, 2, 2),
+      P = c(7, 7, 1, 1)
+    )
+  )
+})
+
+test_that("an empty line", {
+  input <- c("Allegoric Alaskans;Blithering Badgers;loss",
+             "Devastating Donkeys;Allegoric Alaskans;loss",
+             "",
+             "Courageous Californians;Blithering Badgers;draw",
+             "Allegoric Alaskans;Courageous Californians;win")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Allegoric Alaskans","Blithering Badgers",
+              "Courageous Californians","Devastating Donkeys"),
+      MP = c(3, 2, 2, 1),
+      W = c(2, 1, 0, 0),
+      D = c(0, 1, 1, 0),
+      L = c(1, 0, 1, 1),
+      P = c(6, 4, 1, 0)
+    )
+  )
+})
+
+test_that("wrong separator used", {
+  input <- c("Allegoric Alaskans;Blithering Badgers;loss",
+             "Devastating Donkeys;Allegoric Alaskans;loss",
+             "Courageous Californians;Blithering Badgers;draw",
+             "Devastating Donkeys@Courageous Californians;draw",
+             "Allegoric Alaskans;Courageous Californians;win")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Allegoric Alaskans","Blithering Badgers",
+              "Courageous Californians","Devastating Donkeys"),
+      MP = c(3, 2, 2, 1),
+      W = c(2, 1, 0, 0),
+      D = c(0, 1, 1, 0),
+      L = c(1, 0, 1, 1),
+      P = c(6, 4, 1, 0)
+    )
+  )
+})
+
+test_that("too many separators", {
+  input <- c("Allegoric Alaskans;Blithering Badgers;loss",
+             "Devastating Donkeys;Courageous Californians;draw;5",
+             "Devastating Donkeys;Allegoric Alaskans;loss",
+             "Courageous Californians;Blithering Badgers;draw",
+             "Allegoric Alaskans;Courageous Californians;win")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Allegoric Alaskans","Blithering Badgers",
+              "Courageous Californians","Devastating Donkeys"),
+      MP = c(3, 2, 2, 1),
+      W = c(2, 1, 0, 0),
+      D = c(0, 1, 1, 0),
+      L = c(1, 0, 1, 1),
+      P = c(6, 4, 1, 0)
+    )
+  )
+})
+
+test_that("invalid match result", {
+  input <- c("Allegoric Alaskans;Blithering Badgers;loss",
+             "Devastating Donkeys;Allegoric Alaskans;loss",
+             "Courageous Californians;Blithering Badgers;draw",
+             "Allegoric Alaskans;Courageous Californians;win",
+             "Devastating Donkeys;Allegoric Alaskans;dra")
+  expect_equal(tournament(input), 
+    data.frame(
+      Team = c("Allegoric Alaskans","Blithering Badgers",
+              "Courageous Californians","Devastating Donkeys"),
+      MP = c(3, 2, 2, 1),
+      W = c(2, 1, 0, 0),
+      D = c(0, 1, 1, 0),
+      L = c(1, 0, 1, 1),
+      P = c(6, 4, 1, 0)
+    )
+  )
+})
+
+print("All tests passed!")

data/tracks/r/exercises/tournament/tournament.R

@@ -0,0 +1,3 @@
+tournament <- function(input) {
+  
+}

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

@@ -1,5 +1,5 @@
 source('./word-count.R')
-suppressPackageStartupMessages({ require(testthat) })
+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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.8.37
+  version: 2.0.8.38
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-31 00:00:00.000000000 Z
+date: 2017-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -6860,18 +6860,42 @@ files:
 - tracks/r/exercises/hello-world/example.R
 - tracks/r/exercises/hello-world/hello-world.R
 - tracks/r/exercises/hello-world/test_hello-world.R
+- tracks/r/exercises/isogram/example.R
+- tracks/r/exercises/isogram/isogram.R
+- tracks/r/exercises/isogram/test_isogram.R
+- tracks/r/exercises/largest-series-product/example.R
+- tracks/r/exercises/largest-series-product/largest-series-product.R
+- tracks/r/exercises/largest-series-product/test_largest-series-product.R
 - tracks/r/exercises/leap/example.R
 - tracks/r/exercises/leap/leap.R
 - tracks/r/exercises/leap/test_leap.R
 - tracks/r/exercises/luhn/example.R
 - tracks/r/exercises/luhn/luhn.R
 - tracks/r/exercises/luhn/test_luhn.R
+- tracks/r/exercises/pascals-triangle/example.R
+- tracks/r/exercises/pascals-triangle/pascals-triangle.R
+- tracks/r/exercises/pascals-triangle/test_pascals-triangle.R
+- tracks/r/exercises/perfect-numbers/example.R
+- tracks/r/exercises/perfect-numbers/perfect-numbers.R
+- tracks/r/exercises/perfect-numbers/test_perfect-numbers.R
 - tracks/r/exercises/phone-number/example.R
 - tracks/r/exercises/phone-number/phone-number.R
 - tracks/r/exercises/phone-number/test_phone-number.R
+- tracks/r/exercises/prime-factors/example.R
+- tracks/r/exercises/prime-factors/prime-factors.R
+- tracks/r/exercises/prime-factors/test_prime-factors.R
 - tracks/r/exercises/raindrops/example.R
 - tracks/r/exercises/raindrops/raindrops.R
 - tracks/r/exercises/raindrops/test_raindrops.R
+- tracks/r/exercises/rna-transcription/example.R
+- tracks/r/exercises/rna-transcription/rna-transcription.R
+- tracks/r/exercises/rna-transcription/test_rna-transcription.R
+- tracks/r/exercises/rotational-cipher/example.R
+- tracks/r/exercises/rotational-cipher/rotational-cipher.R
+- tracks/r/exercises/rotational-cipher/test_rotational-cipher.R
+- tracks/r/exercises/scrabble-score/example.R
+- tracks/r/exercises/scrabble-score/scrabble-score.R
+- tracks/r/exercises/scrabble-score/test_scrabble-score.R
 - tracks/r/exercises/secret-handshake/example.R
 - tracks/r/exercises/secret-handshake/secret-handshake.R
 - tracks/r/exercises/secret-handshake/test_secret-handshake.R
@@ -6884,6 +6908,9 @@ files:
 - tracks/r/exercises/sum-of-multiples/example.R
 - tracks/r/exercises/sum-of-multiples/sum-of-multiples.R
 - tracks/r/exercises/sum-of-multiples/test_sum-of-multiples.R
+- tracks/r/exercises/tournament/example.R
+- tracks/r/exercises/tournament/test_tournament.R
+- tracks/r/exercises/tournament/tournament.R
 - tracks/r/exercises/word-count/example.R
 - tracks/r/exercises/word-count/test_word-count.R
 - tracks/r/exercises/word-count/word-count.R