trackler 2.1.0.21 → 2.1.0.22

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

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

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

@@ -2,31 +2,31 @@ source("./pascals-triangle.R")
 library(testthat)
 
 test_that("zero rows", {
-  expect_equal(pascalsTriangle(0), list())
+  expect_equal(pascals_triangle(0), list())
 })
 
 test_that("single row", {
-  expect_equal(pascalsTriangle(1), list(1))
+  expect_equal(pascals_triangle(1), list(1))
 })
 
 test_that("two rows", {
-  expect_equal(pascalsTriangle(2), list(1, c(1, 1)))
+  expect_equal(pascals_triangle(2), list(1, c(1, 1)))
 })
 
 test_that("three rows", {
-  expect_equal(pascalsTriangle(3), list(1, c(1, 1), c(1, 2, 1)))
+  expect_equal(pascals_triangle(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)))
+  expect_equal(pascals_triangle(4), list(1, c(1, 1), c(1, 2, 1), c(1, 3, 3, 1)))
 })
 
 test_that("negative rows", {
-  expect_error(pascalsTriangle(-1))
+  expect_error(pascals_triangle(-1))
 })
 
 test_that("null/no rows", {
-  expect_error(pascalsTriangle(NULL))
+  expect_error(pascals_triangle(NULL))
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: pascals-triangle")

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

@@ -1,6 +1,6 @@
-isPerfect <- function(n){
+is_perfect <- function(n){
   
-  findFactors <- function(n) {
+  find_factors <- function(n) {
     factors <- c()
     for (i in 2:floor(n^0.5 + 1)) {
       
@@ -17,6 +17,6 @@ isPerfect <- function(n){
     unique(factors)
   }
   
-  sum(findFactors(n)) + 1 == n
+  sum(find_factors(n)) + 1 == n
   
 }

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

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

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

@@ -3,57 +3,57 @@ library(testthat)
 
 test_that("first perfect number", {
   n <- 6
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
 test_that("no perfect number", {
   n <- 8
-  expect_equal(isPerfect(n), FALSE)
+  expect_equal(is_perfect(n), FALSE)
 })
 
 test_that("second perfect number", {
   n <- 28
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
 test_that("abundant", {
   n <- 20
-  expect_equal(isPerfect(n), FALSE)
+  expect_equal(is_perfect(n), FALSE)
 })
 
 test_that("answer to the ultimate question of life", {
   n <- 42
-  expect_equal(isPerfect(n), FALSE)
+  expect_equal(is_perfect(n), FALSE)
 })
 
 test_that("third perfect number", {
   n <- 496
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
 test_that("odd abundant", {
   n <- 945
-  expect_equal(isPerfect(n), FALSE)
+  expect_equal(is_perfect(n), FALSE)
 })
 
 test_that("fourth perfect number", {
   n <- 8128
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
 test_that("fifth perfect number", {
   n <- 33550336
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
 test_that("sixth perfect number", {
   n <- 8589869056
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
 test_that("seventh perfect number", {
   n <- 137438691328
-  expect_equal(isPerfect(n), TRUE)
+  expect_equal(is_perfect(n), TRUE)
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: perfect-numbers")

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

@@ -1,18 +1,18 @@
-parsePhoneNumber <- function(numberString) {
+parse_phone_number <- function(number_string) {
   
-  # If the phone number is less than 10 digits assume that it is bad number
-  # If the phone number is 10 digits assume that it is good
-  # If the phone number is 11 digits and the first number is 1, trim the 1 and use the last 10 digits
-  # If the phone number is 11 digits and the first number is not 1, then it is a bad number
-  # If the phone number is more than 11 digits assume that it is a bad number
+  # If the number is less than 10 digits assume that it is bad number
+  # If the number is 10 digits assume that it is good
+  # If the number is 11 digits and the first number is 1, use the last 10 digits
+  # If the number is 11 digits and the first number is not 1, it is a bad number
+  # If the number is more than 11 digits assume that it is a bad number
  
   # Check for letters
-  if (grepl("[A-z]", numberString)) {
+  if (grepl("[A-z]", number_string)) {
     return (NULL)
   }
   
   # Remove non-digit characters from number string
-  cleaned <- gsub("[^0-9]", "", numberString)
+  cleaned <- gsub("[^0-9]", "", number_string)
   
   if (nchar(cleaned) < 10) {
     NULL

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

@@ -1,3 +1,3 @@
-parsePhoneNumber <- function(numberString) {
+parse_phone_number <- function(number_string) {
   
 }

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

@@ -2,43 +2,43 @@ source("./phone-number.R")
 library(testthat)
 
 test_that("cleans the number", {
-  expect_equal(parsePhoneNumber("(123) 456-7890"), "1234567890")
+  expect_equal(parse_phone_number("(123) 456-7890"), "1234567890")
 })
 
 test_that("cleans numbers with dots", {
-  expect_equal(parsePhoneNumber("123.456.7890"), "1234567890")
+  expect_equal(parse_phone_number("123.456.7890"), "1234567890")
 })
 
 test_that("cleans numbers with multiple spaces", {
-  expect_equal(parsePhoneNumber("123 456   7890   "), "1234567890")
+  expect_equal(parse_phone_number("123 456   7890   "), "1234567890")
 })
 
 test_that("invalid when 9 digits", {
-  expect_equal(parsePhoneNumber("123456789"), NULL)
+  expect_equal(parse_phone_number("123456789"), NULL)
 })
 
 test_that("invalid when 11 digits", {
-  expect_equal(parsePhoneNumber("21234567890"), NULL)
+  expect_equal(parse_phone_number("21234567890"), NULL)
 })
 
 test_that("valid when 11 digits and starting with 1", {
-  expect_equal(parsePhoneNumber("11234567890"), "1234567890")
+  expect_equal(parse_phone_number("11234567890"), "1234567890")
 })
 
 test_that("invalid when 12 digits", {
-  expect_equal(parsePhoneNumber("321234567890"), NULL)
+  expect_equal(parse_phone_number("321234567890"), NULL)
 })
 
 test_that("invalid with letters", {
-  expect_equal(parsePhoneNumber("123-abc-7890"), NULL)
+  expect_equal(parse_phone_number("123-abc-7890"), NULL)
 })
 
 test_that("invalid with punctuations", {
-  expect_equal(parsePhoneNumber("123-@:!-7890"), NULL)
+  expect_equal(parse_phone_number("123-@:!-7890"), NULL)
 })
 
 test_that("invalid with right number of digits but letters mixed in", {
-  expect_equal(parsePhoneNumber("1a2b3c4d5e6f7g8h9i0j"), NULL)
+  expect_equal(parse_phone_number("1a2b3c4d5e6f7g8h9i0j"), NULL)
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: phone-number")

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

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

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

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

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

@@ -44,4 +44,4 @@ test_that("factors include a large prime", {
                c(11, 9539, 894119))
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: prime-factors")

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

@@ -1,28 +1,29 @@
 raindrops <- function(number) {
   
-  Pling <- ''
-  Plang <- ''
-  Plong <- ''
+  pling <- ''
+  plang <- ''
+  plong <- ''
   
   # If the number has 3 as a factor, output 'Pling'.
   if (number %% 3 == 0) {
-    Pling <- 'Pling'
+    pling <- 'Pling'
   }
   # If the number has 5 as a factor, output 'Plang'.
   if (number %% 5 == 0) {
-    Plang <- 'Plang'
+    plang <- 'Plang'
   }
   # If the number has 7 as a factor, output 'Plong'.
   if (number %% 7 == 0) {
-    Plong <- 'Plong'
+    plong <- 'Plong'
   }
   
-  PlingPlangPlong <- paste(Pling, Plang, Plong, sep = "")
+  plingplangplong <- paste(pling, plang, plong, sep = "")
   
-  # If the number does not have 3, 5, or 7 as a factor, just pass the number's digits straight through.
-  if (PlingPlangPlong == "") {
-    PlingPlangPlong = as.character(number)
+  # If the number does not have 3, 5, or 7 as a factor, 
+  # just pass the number's digits straight through
+  if (plingplangplong == "") {
+    plingplangplong <- as.character(number)
   }
   
-  PlingPlangPlong
+  plingplangplong
 }

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

@@ -26,7 +26,8 @@ test_that("the sound for 6 is Pling as it has a factor 3", {
   expect_equal(raindrops(number), "Pling")
 })
 
-test_that("2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base", {
+test_that("2 to the power 3 does not make a raindrop sound as 3 is the exponent 
+          not the base", {
   number <- 8
   expect_equal(raindrops(number), "8")
 })
@@ -91,4 +92,4 @@ test_that("the sound for 3125 is Plang as it has a factor 5", {
   expect_equal(raindrops(number), "Plang")
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: raindrops")

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

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

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

@@ -41,4 +41,4 @@ test_that("dna correctly handles partially invalid input", {
   expect_error(to_rna(dna))
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: rna-transcription")

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

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

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

@@ -58,7 +58,8 @@ test_that("rotate punctuation", {
 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.")
+  expect_equal(rotate(text, key), 
+               "Gur dhvpx oebja sbk whzcf bire gur ynml qbt.")
 })
 
-print("All tests passed!")
+print("All tests passed for exercise: rotational-cipher")

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

@@ -1,4 +1,4 @@
-scrabbleScore <- function(input){
+scrabble_score <- function(input){
   
   # Letter                           Value
   # A, E, I, O, U, L, N, R, S, T       1
@@ -9,11 +9,12 @@ scrabbleScore <- function(input){
   # 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
+  letter_score <- 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(letter_score) <- LETTERS
   
   chars <- unlist(strsplit(input, ""))
   
-  sum(letterScore[toupper(chars)])
+  sum(letter_score[toupper(chars)])
   
 }

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

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

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

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