trackler 2.2.1.6 → 2.2.1.7

data/tracks/r/exercises/collatz-conjecture/README.md

@@ -0,0 +1,43 @@
+# Collatz Conjecture
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+
+## Installation
+See [this guide](https://github.com/exercism/xr/blob/master/docs/INSTALLATION.md) for instructions on how to setup your local R environment.
+
+## How to implement your solution
+In each problem folder, there is a file named `<exercise_name>.R` containing a function that returns a `NULL` value. Place your implementation inside the body of the function.
+
+## How to run tests
+Inside of RStudio, simply execute the `test_<exercise_name>.R` script. This can be conveniently done with [testthat's `auto_test` function](https://www.rdocumentation.org/packages/testthat/topics/auto_test). Because exercism code and tests are in the same folder, use this same path for both  `code_path` and `test_path` parameters. On the command-line, you can also run `Rscript test_<exercise_name>.R`.
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/r/exercises/collatz-conjecture/collatz-conjecture.R

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

data/tracks/r/exercises/collatz-conjecture/example.R

@@ -0,0 +1,13 @@
+collatz_step_counter <- function(num) {
+  
+  if (num <= 0) {
+    stop("Only positive numbers are allowed")
+  } else if (num == 1) {
+    return(0)  
+  } else if (num %% 2 == 0) {
+    return(1 + collatz_step_counter(num/2))
+  } else {
+    return(1 + collatz_step_counter(3*num + 1))
+  }
+  
+}

data/tracks/r/exercises/collatz-conjecture/test_collatz-conjecture.R

@@ -0,0 +1,28 @@
+source("./collatz-conjecture.R")
+library(testthat)
+
+test_that("Input of 1 results in 0 steps", {
+  expect_equal(collatz_step_counter(1), 0)
+})
+
+test_that("Even input with repeated even steps", {
+  expect_equal(collatz_step_counter(16), 4)
+})
+
+test_that("Input which results in small number of even and odd steps", {
+  expect_equal(collatz_step_counter(12), 9)
+})
+
+test_that("Input which results in large number of even and odd steps", {
+  expect_equal(collatz_step_counter(1000000), 152)
+})
+
+test_that("Input of 0 results in an error", {
+  expect_error(collatz_step_counter(0))
+})
+
+test_that("Negative input results in an error", {
+  expect_error(collatz_step_counter(-15))
+})
+
+message("All tests passed for exercise: collatz-conjecture")

data/tracks/r/exercises/nucleotide-count/README.md

@@ -0,0 +1,43 @@
+# Nucleotide Count
+
+Given a DNA string, compute how many times each nucleotide occurs in the string.
+
+DNA is represented by an alphabet of the following symbols: 'A', 'C',
+'G', and 'T'.
+
+Each symbol represents a nucleotide, which is a fancy name for the
+particular molecules that happen to make up a large part of DNA.
+
+Shortest intro to biochemistry EVAR:
+
+- twigs are to birds nests as
+- nucleotides are to DNA and RNA as
+- amino acids are to proteins as
+- sugar is to starch as
+- oh crap lipids
+
+I'm not going to talk about lipids because they're crazy complex.
+
+So back to nucleotides.
+
+DNA contains four types of them: adenine (`A`), cytosine (`C`), guanine
+(`G`), and thymine (`T`).
+
+RNA contains a slightly different set of nucleotides, but we don't care
+about that for now.
+
+## Installation
+See [this guide](https://github.com/exercism/xr/blob/master/docs/INSTALLATION.md) for instructions on how to setup your local R environment.
+
+## How to implement your solution
+In each problem folder, there is a file named `<exercise_name>.R` containing a function that returns a `NULL` value. Place your implementation inside the body of the function.
+
+## How to run tests
+Inside of RStudio, simply execute the `test_<exercise_name>.R` script. This can be conveniently done with [testthat's `auto_test` function](https://www.rdocumentation.org/packages/testthat/topics/auto_test). Because exercism code and tests are in the same folder, use this same path for both  `code_path` and `test_path` parameters. On the command-line, you can also run `Rscript test_<exercise_name>.R`.
+
+## Source
+
+The Calculating DNA Nucleotides_problem at Rosalind [http://rosalind.info/problems/dna/](http://rosalind.info/problems/dna/)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/r/exercises/nucleotide-count/example.R

@@ -0,0 +1,17 @@
+library(magrittr)
+
+nucleotide_count <- function(input) {
+  
+  strand_chr <- strsplit(input, "")[[1]]
+  
+  nucleotides <- c("A", "C", "G", "T")
+  
+  if (length(strand_chr) > 0 && !all(strand_chr %in% nucleotides)) {
+    stop("Invalid nucleotide in strand")
+  }
+  
+  nucleotides %>% 
+    sapply(function(x) {sum(x == strand_chr)}) %>% 
+    as.list()
+  
+}

data/tracks/r/exercises/nucleotide-count/nucleotide-count.R

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

data/tracks/r/exercises/nucleotide-count/test_nucleotide-count.R

@@ -0,0 +1,51 @@
+source("./nucleotide-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
+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")
+  }
+}
+
+test_that("all zeros for empty strand", {
+  expect_equal_pairs(nucleotide_count(""),
+                     list(
+                       A = 0,
+                       C = 0,
+                       G = 0,
+                       T = 0
+                     ))
+})
+
+test_that("3 zeros & 1 count for strand with a single repeated nucleotide", {
+  expect_equal_pairs(nucleotide_count("GGGGGGG"),
+                     list(
+                       A = 0,
+                       C = 0,
+                       G = 7,
+                       T = 0
+                     ))
+})
+
+test_that("correct counts for strand with multiple nucleotides", {
+  expect_equal_pairs(nucleotide_count(
+    "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC"),
+    list(
+      A = 20,
+      C = 12,
+      G = 17,
+      T = 21
+    ))
+})
+
+test_that("error for strand with invalid nucleotides", {
+  expect_error(nucleotide_count("AGXXACT"))
+})
+
+message("All tests passed for exercise: nucleotide-count")

data/tracks/r/exercises/pangram/README.md

@@ -0,0 +1,25 @@
+# Pangram
+
+Determine if a sentence is a pangram. A pangram (Greek: παν γράμμα, pan gramma,
+"every letter") is a sentence using every letter of the alphabet at least once.
+The best known English pangram is: 
+> The quick brown fox jumps over the lazy dog.
+
+The alphabet used consists of ASCII letters `a` to `z`, inclusive, and is case
+insensitive. Input will not contain non-ASCII symbols.
+
+## Installation
+See [this guide](https://github.com/exercism/xr/blob/master/docs/INSTALLATION.md) for instructions on how to setup your local R environment.
+
+## How to implement your solution
+In each problem folder, there is a file named `<exercise_name>.R` containing a function that returns a `NULL` value. Place your implementation inside the body of the function.
+
+## How to run tests
+Inside of RStudio, simply execute the `test_<exercise_name>.R` script. This can be conveniently done with [testthat's `auto_test` function](https://www.rdocumentation.org/packages/testthat/topics/auto_test). Because exercism code and tests are in the same folder, use this same path for both  `code_path` and `test_path` parameters. On the command-line, you can also run `Rscript test_<exercise_name>.R`.
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Pangram](https://en.wikipedia.org/wiki/Pangram)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,14 @@
+library(magrittr)
+
+is_pangram <- function(input) {
+
+  input_letters <- gsub("[^A-Za-z]", "", input) %>% 
+                    tolower() %>% 
+                    strsplit("") %>% 
+                    unlist() %>% 
+                    unique() %>% 
+                    sort()
+
+  identical(input_letters, letters)
+
+}

data/tracks/r/exercises/pangram/pangram.R

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

data/tracks/r/exercises/pangram/test_pangram.R

@@ -0,0 +1,42 @@
+source("./pangram.R")
+library(testthat)
+
+test_that("sentence empty", {
+    expect_false(is_pangram(""))
+})
+
+test_that("pangram with only lower case", {
+    expect_true(is_pangram("the quick brown fox jumps over the lazy dog"))
+})
+
+test_that("missing character 'x'", {
+    expect_false(
+      is_pangram("a quick movement of the enemy will jeopardize five gunboats"))
+})
+
+test_that("another missing character 'x'", {
+    expect_false(is_pangram("the quick brown fish jumps over the lazy dog"))
+})
+
+test_that("pangram with underscores", {
+    expect_true(is_pangram("the_quick_brown_fox_jumps_over_the_lazy_dog"))
+})
+
+test_that("pangram with numbers", {
+    expect_true(is_pangram("the 1 quick brown fox jumps over the 2 lazy dogs"))
+})
+
+test_that("missing letters replaced by numbers", {
+    expect_false(is_pangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog"))
+})
+
+test_that("pangram with mixed case and punctuation", {
+    expect_true(is_pangram("\"Five quacking Zephyrs jolt my wax bed.\""))
+})
+
+test_that("upper and lower case versions of the same character should not be 
+          counted separately", {
+    expect_false(is_pangram("the quick brown fox jumped over the lazy FOX"))
+})
+
+message("All tests passed for exercise: pangram")

data/tracks/r/exercises/triangle/.meta/hints.md

@@ -0,0 +1,4 @@
+
+## Hint
+
+For this exercise you will need to implement a simple S3 class. If you are not familiar with S3, a great starting point is the [chapter on S3](http://adv-r.hadley.nz/s3.html) in Hadley Wickham's book Advanced R.

data/tracks/r/exercises/triangle/README.md

@@ -0,0 +1,41 @@
+# Triangle
+
+Determine if a triangle is equilateral, isosceles, or scalene.
+
+An _equilateral_ triangle has all three sides the same length.<br/>
+An _isosceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)<br/>
+A _scalene_ triangle has all sides of different lengths.
+
+## Note
+
+For a shape to be a triangle at all, all sides have to be of length > 0, and 
+the sum of the lengths of any two sides must be greater than or equal to the 
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
+
+## Dig Deeper
+
+The case where the sum of the lengths of two sides _equals_ that of the 
+third is known as a _degenerate_ triangle - it has zero area and looks like 
+a single line. Feel free to add your own code/tests to check for degenerate triangles.
+
+## Hint
+
+For this exercise you will need to implement a simple S3 class. If you are not familiar with S3, a great starting point is the [chapter on S3](http://adv-r.hadley.nz/s3.html) in Hadley Wickham's book Advanced R.
+
+## Installation
+See [this guide](https://github.com/exercism/xr/blob/master/docs/INSTALLATION.md) for instructions on how to setup your local R environment.
+
+## How to implement your solution
+In each problem folder, there is a file named `<exercise_name>.R` containing a function that returns a `NULL` value. Place your implementation inside the body of the function.
+
+## How to run tests
+Inside of RStudio, simply execute the `test_<exercise_name>.R` script. This can be conveniently done with [testthat's `auto_test` function](https://www.rdocumentation.org/packages/testthat/topics/auto_test). Because exercism code and tests are in the same folder, use this same path for both  `code_path` and `test_path` parameters. On the command-line, you can also run `Rscript test_<exercise_name>.R`.
+
+## Source
+
+The Ruby Koans triangle project, parts 1 & 2 [http://rubykoans.com](http://rubykoans.com)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,23 @@
+triangle <- function(x, y, z) {
+  
+  checks <- c(x + y < z,
+              x + z < y,
+              y + z < x,
+              x == 0,
+              y == 0,
+              z == 0)
+  
+  if (any(checks)) {
+    stop("Invalid sides for triangle")
+  }
+  
+  unique_sides <- length(unique(c(x, y, z)))
+  
+  triangle_class <- switch(unique_sides,
+                           c("equilateral", "isosceles"),
+                           "isosceles",
+                           "scalene")
+  
+  structure(list(x = x, y = y, z = z), class = triangle_class)
+
+}

data/tracks/r/exercises/triangle/test_triangle.R

@@ -0,0 +1,72 @@
+source("./triangle.R")
+library(testthat)
+
+test_that("true if all sides are equal", {
+  expect_is(triangle(2, 2, 2), "equilateral")
+})
+
+test_that("false if any side is unequal", {
+  expect_false(any("equilateral" %in% class(triangle(2, 3, 2))))
+})
+
+test_that("false if no sides are equal", {
+  expect_false(any("equilateral" %in% class(triangle(5, 4, 6))))
+})
+
+test_that("not equilateral if sides are zero", {
+  expect_error(triangle(0, 0, 0))
+})
+
+test_that("sides may be floats", {
+  expect_is(triangle(0.5, 0.5, 0.5), "equilateral")
+})
+
+test_that("isosceles if last two sides are equal", {
+  expect_is(triangle(3, 4, 4), "isosceles")
+})
+
+test_that("isosceles if first two sides are equal", {
+  expect_is(triangle(4, 4, 3), "isosceles")
+})
+
+test_that("isosceles if first and last sides are equal", {
+  expect_is(triangle(4, 3, 4), "isosceles")
+})
+
+test_that("equilateral triangles are also isosceles", {
+  expect_is(triangle(4, 4, 4), "isosceles")
+})
+
+test_that("not isosceles if no sides are equal", {
+  expect_false(any("isosceles" %in% class(triangle(2, 3, 4))))
+})
+
+test_that("not isosceles if triangle inequality is violated", {
+  expect_error(triangle(1, 1, 3))
+})
+
+test_that("sides may be floats", {
+  expect_is(triangle(0.5, 0.4, 0.5), "isosceles")
+})
+
+test_that("scalene if no sides are equal", {
+  expect_is(triangle(5, 4, 6), "scalene")
+})
+
+test_that("not scalene if all sides are equal", {
+  expect_false(any("scalene" %in% class(triangle(4, 4, 4))))
+})
+
+test_that("not scalene if two sides are equal", {
+  expect_false(any("scalene" %in% class(triangle(4, 4, 3))))
+})
+
+test_that("not scalene if triangle inequality is violated", {
+  expect_error(triangle(7, 3, 2))
+})
+
+test_that("sides may be floats", {
+  expect_is(triangle(0.5, 0.4, 0.6), "scalene")
+})
+
+message("All tests passed for exercise: triangle")