trackler 2.0.6.34 → 2.0.6.35

data/tracks/kotlin/exercises/hello-world/src/example/kotlin/HelloWorld.kt

@@ -1,31 +1,3 @@
-/**
- * Simple HelloWorld singleton class as defined by the `Kotlin object keyword`.
- * See: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations
- *
- * As an alternative one could create a class such as:
- * ```
- * class HelloWorld(name: String? = "Default Value") {
- *     fun hello(): String {
- *
- *     }
- * }
- * ```
- * Resulting in a call such as: `HelloWorld("Bob").hello()`
- * See: https://kotlinlang.org/docs/reference/classes.html#constructors
- *
- * In Kotlin we make objects defined as nullable via the trailing `?`, if you try
- * to assign a null value to any value that isn't nullable a compilation error is thrown.
- * Kotlin makes sure you are accessing nullable values safely and provides null safe calls
- * and the use of the elvis operator. See: https://kotlinlang.org/docs/reference/null-safety.html
- *
- * You may provide default values on methods, so if an argument is omitted the default is used.
- * See: https://kotlinlang.org/docs/reference/functions.html#default-arguments
- *
- * Kotlin provides String interpolation to make String formatting simple.
- * See: https://kotlinlang.org/docs/reference/idioms.html#string-interpolation
- */
-object HelloWorld {
-    fun hello(name: String? = null): String {
-        return "Hello, ${if (name.isNullOrBlank()) "World" else name}!"
-    }
+fun hello(name: String = "World"): String {
+    return "Hello, ${if (name.isBlank()) "World" else name}!"
 }

data/tracks/kotlin/exercises/hello-world/src/main/kotlin/HelloWorld.kt

@@ -1,31 +1,3 @@
-/**
- * Simple HelloWorld singleton class as defined by the `Kotlin object keyword`.
- * See: https://kotlinlang.org/docs/reference/object-declarations.html#object-declarations
- *
- * As an alternative one could create a class such as:
- * ```
- * class HelloWorld(name: String? = "Default Value") {
- *     fun hello(): String {
- *
- *     }
- * }
- * ```
- * Resulting in a call such as: `HelloWorld("Bob").hello()`
- * See: https://kotlinlang.org/docs/reference/classes.html#constructors
- *
- * In Kotlin we make objects defined as nullable via the trailing `?`, if you try
- * to assign a null value to any value that isn't nullable a compilation error is thrown.
- * Kotlin makes sure you are accessing nullable values safely and provides null safe calls
- * and the use of the elvis operator. See: https://kotlinlang.org/docs/reference/null-safety.html
- *
- * You may provide default values on methods, so if an argument is omitted the default is used.
- * See: https://kotlinlang.org/docs/reference/functions.html#default-arguments
- *
- * Kotlin provides String interpolation to make String formatting simple.
- * See: https://kotlinlang.org/docs/reference/idioms.html#string-interpolation
- */
-object HelloWorld {
-    fun hello(name: String? = "Default Argument"): String {
-
-    }
+fun hello(name: String = ""): String {
+   return ""
 }

data/tracks/kotlin/exercises/hello-world/src/test/kotlin/HelloWorldTest.kt

@@ -1,38 +1,30 @@
-import kotlin.test.assertEquals
-import org.junit.Test
 import org.junit.Ignore
+import org.junit.Test
+import org.junit.Assert.assertEquals
 
-class HelloWorldTest {
 
+class HelloWorldTest {
 
     @Test
     fun helloNoName() {
-        assertEquals("Hello, World!", HelloWorld.hello())
+        assertEquals("Hello, World!", hello())
     }
 
-    @Ignore
     @Test
-    fun helloBlankName() {
-        assertEquals("Hello, World!", HelloWorld.hello(""))
-        assertEquals("Hello, World!", HelloWorld.hello("    "))
-    }
-
     @Ignore
-    @Test
-    fun helloNullName() {
-        //This isn't advised in Kotlin but demonstrates the null safety in Kotlin
-        assertEquals("Hello, World!", HelloWorld.hello(null))
+    fun helloSampleName() {
+        assertEquals("Hello, Alice!", hello("Alice"))
     }
 
-    @Ignore
     @Test
-    fun helloSampleName() {
-        assertEquals("Hello, Alice!", HelloWorld.hello("Alice"))
+    @Ignore
+    fun helloBlankName() {
+        assertEquals("Hello, World!", hello("    "))
     }
 
-    @Ignore
     @Test
+    @Ignore
     fun helloAnotherSampleName() {
-        assertEquals("Hello, Bob!", HelloWorld.hello("Bob"))
+        assertEquals("Hello, Bob!", hello("Bob"))
     }
 }

data/tracks/objective-c/circle.yml

@@ -3,4 +3,4 @@ machine:
     version: "8.2"
 test:
   override:
-    -xctool test -project 'xcodeProject/ObjectiveC.xcodeproj' -scheme 'xobjectivecTest' -sdk macosx10.11 -reporter json-compilation-database:compile_commands.json -reporter plain:plain-output.txt -reporter pretty
+    - xcodebuild test -project 'xcodeProject/ObjectiveC.xcodeproj' -scheme 'xobjectivecTest' -sdk macosx10.12

data/tracks/pony/config.json

@@ -87,6 +87,15 @@
         "strings",
         "iterators"
       ]
+    },
+    {
+      "slug": "pascals-triangle",
+      "difficulty": 1,
+      "topics": [
+        "math",
+        "iterators",
+        "arrays"
+      ]
     }
   ]
 }

data/tracks/pony/exercises/pascals-triangle/example.pony

@@ -0,0 +1,18 @@
+use "collections"
+use "itertools"
+
+primitive PascalsTriangle
+  fun rows(count: USize): Array[Array[USize]] =>
+    Iter[USize](Range(0, count))
+      .map[Array[USize]]({(n: USize): Array[USize] => PascalsTriangle.row(n)})
+      .collect(Array[Array[USize]](count))
+
+  fun row(n: USize): Array[USize] =>
+    let r = Array[USize](n).>push(1)
+    for i in Range(1, n + 1) do
+      try
+        let last = r(i - 1)
+        r.push((last * ((n + 1) - i)) / i)
+      end
+    end
+    r

data/tracks/pony/exercises/pascals-triangle/test.pony

@@ -0,0 +1,31 @@
+use "collections"
+use "ponytest"
+
+actor Main is TestList
+  new create(env: Env) =>
+    PonyTest(env, this)
+
+  fun tag tests(test: PonyTest) =>
+    test(_TestPascalsTriangle)
+
+class iso _TestPascalsTriangle is UnitTest
+  fun name(): String => "pascals-triangle"
+
+  fun apply(h: TestHelper) ? =>
+    assert_rows_eq(h, 0, Array[Array[USize]])
+    assert_rows_eq(h, 1, [[1]])
+    assert_rows_eq(h, 2, [[1], [1, 1]])
+    assert_rows_eq(h, 3, [[1], [1, 1], [1, 2, 1]])
+    assert_rows_eq(h, 4, [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]])
+
+  fun assert_rows_eq(
+    h: TestHelper,
+    count: USize,
+    expected: Array[Array[USize]],
+    loc: SourceLoc = __loc)
+  ? =>
+    let t = PascalsTriangle.rows(count)
+    h.assert_eq[USize](t.size(), expected.size())
+    for i in Range(0, expected.size()) do
+      h.assert_array_eq[USize](expected(i), t(i))
+    end

data/tracks/r/config.json

@@ -69,6 +69,26 @@
       "difficulty": 1,
       "slug": "sum-of-multiples",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "grains",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "secret-handshake",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "phone-number",
+      "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "sieve",
+      "topics": []
     }
   ]
 }

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

@@ -0,0 +1,16 @@
+square <- function(n) {
+  
+  if (n > 0 & n < 65) {
+    2^(n-1)
+  }
+  else {
+    stop("Input value should be between 1 and 64")
+  }
+  
+}
+
+total <- function() {
+  
+  sum(2^(0:63))
+  
+}

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

@@ -0,0 +1,7 @@
+square <- function(n) {
+  
+}
+
+total <- function() {
+  
+}

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

@@ -0,0 +1,49 @@
+source('./square.R')
+suppressPackageStartupMessages({ require(testthat) })
+
+test_that("Case 1", {
+  expect_equal(square(1), 1)
+})
+
+test_that("Case 2", {
+  expect_equal(square(2), 2)
+})
+
+test_that("Case 3", {
+  expect_equal(square(3), 4)
+})
+
+test_that("Case 4", {
+  expect_equal(square(4), 8)
+})
+
+test_that("Case 16", {
+  expect_equal(square(16), 32768)
+})
+
+test_that("Case 32", {
+  expect_equal(square(32), 2147483648)
+})
+
+test_that("Case 1", {
+  expect_equal(square(64), 9223372036854775808)
+})
+
+test_that("square 0 raises an exception", {
+  expect_error(square(0))
+})
+
+test_that("negative square raises an exception", {
+  expect_error(square(-1))
+})
+
+test_that("square greater than 64 raises an exception", {
+  expect_error(square(65))
+})
+
+test_that("returns the total number of square on the board", {
+  expect_equal(total(), 18446744073709551615)
+})
+
+
+print("All tests passed!")

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

@@ -0,0 +1,30 @@
+parsePhoneNumber <- function(numberString) {
+  
+  # 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
+ 
+  # Check for letters
+  if (grepl("[A-z]", numberString)) {
+    return (NULL)
+  }
+  
+  # Remove non-digit characters from number string
+  cleaned <- gsub("[^0-9]", "", numberString)
+  
+  if (nchar(cleaned) < 10) {
+    NULL
+  } 
+  else if (nchar(cleaned) == 10) {
+    cleaned
+  } 
+  else if (nchar(cleaned) == 11 & substr(cleaned, 1, 1) == "1") {
+    substr(cleaned, 2, 11)
+  }
+  else {
+    NULL
+  }
+ 
+}

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

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

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

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

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

@@ -0,0 +1,26 @@
+handshake <- function(n) {
+  
+  # 1 = wink
+  # 10 = double blink
+  # 100 = close your eyes
+  # 1000 = jump
+  # 10000 = reverse
+  actions = c("wink", "double blink", "close your eyes", "jump")
+  
+  bin = intToBits(n)
+  
+  events = c()
+  
+  for (i in 1:4){
+    if (bin[i] > 0) {
+      events = c(events, actions[i])
+    }
+  }
+  
+  if (bin[5] > 0) {
+    events = rev(events)
+  }
+  
+  events
+  
+}

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

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

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

@@ -0,0 +1,52 @@
+source('./secret-handshake.R')
+suppressPackageStartupMessages({ require(testthat) })
+
+test_that("wink for 1", {
+  expect_equal(handshake(1), c("wink"))
+})
+
+test_that("double blink for 10", {
+  expect_equal(handshake(2), c("double blink"))
+})
+
+test_that("close your eyes for 100", {
+  expect_equal(handshake(4), c("close your eyes"))
+})
+
+test_that("jump for 1000", {
+  expect_equal(handshake(8), c("jump"))
+})
+
+test_that("combine two actions", {
+  expect_equal(handshake(3), c("wink", "double blink"))
+})
+
+test_that("reverse two actions", {
+  expect_equal(handshake(19), c("double blink", "wink"))
+})
+
+test_that("reversing one action gives the same action", {
+  expect_equal(handshake(24), c("jump"))
+})
+
+test_that("reversing no actions still gives no actions", {
+  expect_equal(handshake(16), c())
+})
+
+test_that("all possible actions", {
+  expect_equal(handshake(15), c("wink", "double blink", "close your eyes", "jump"))
+})
+
+test_that("reverse all possible actions", {
+  expect_equal(handshake(31), c("jump", "close your eyes", "double blink", "wink"))
+})
+
+test_that("do nothing for zero", {
+  expect_equal(handshake(0), c())
+})
+
+test_that("do nothing if lower 5 bits not set", {
+  expect_equal(handshake(32), c())
+})
+
+print("All tests passed!")