trackler 2.1.0.48 → 2.1.0.49

data/tracks/julia/config.json

@@ -224,6 +224,17 @@
         "randomness"
       ]
     },
+    {
+      "slug": "complex-numbers",
+      "difficulty": 2,
+      "topics": [
+        "structs",
+        "mathematics",
+        "methods",
+        "multiple dispatch",
+        "function extension"
+      ]
+    },
     {
       "slug": "rotational-cipher",
       "difficulty": 2,

data/tracks/julia/exercises/complex-numbers/HINTS.md

@@ -0,0 +1,11 @@
+The Julia Base implementation of complex numbers can be found here: https://github.com/JuliaLang/julia/blob/master/base/complex.jl.
+
+---
+
+You can work on the bonus exercises by changing `@test_skip` to `@test`.
+
+## Bonus A
+Implement the exponential function on complex numbers `exp(::ComplexNumber)`.
+
+## Bonus B
+Implement `jm` analogous to `im` so that `1 + 1jm == ComplexNumber(1, 1)`.

data/tracks/julia/exercises/complex-numbers/example.jl

@@ -0,0 +1,41 @@
+# Based on https://github.com/JuliaLang/julia/blob/master/base/complex.jl (MIT license)
+
+import Base: real, imag, conj, abs, +, -, *, /, exp, convert, promote_rule, isfinite
+
+struct ComplexNumber{T<:Real} <: Number
+    re::T
+    im::T
+end
+
+const jm = ComplexNumber(0, 1)
+
+ComplexNumber(re::Real, im::Real) = ComplexNumber(promote(re, im)...)
+ComplexNumber(re::Real) = ComplexNumber(re, zero(re))
+
+convert(::Type{ComplexNumber{T}}, x::Real) where {T<:Real} = ComplexNumber{T}(x, 0)
+convert(::Type{ComplexNumber{T}}, z::ComplexNumber) where {T<:Real} = ComplexNumber{T}(real(z), imag(z))
+
+promote_rule(::Type{ComplexNumber{T}}, ::Type{S}) where {T<:Real, S<:Real} = ComplexNumber{promote_type(T, S)}
+promote_rule(::Type{ComplexNumber{T}}, ::Type{ComplexNumber{S}}) where {T<:Real, S<:Real} = ComplexNumber{promote_type(T, S)}
+
+real(z::ComplexNumber) = z.re
+imag(z::ComplexNumber) = z.im
+
+reim(z::ComplexNumber) = z.re, z.im
+
+conj(z::ComplexNumber) = ComplexNumber(real(z), -imag(z))
+abs(z::ComplexNumber)  = hypot(real(z), imag(z))
+
+isfinite(z::ComplexNumber) = isfinite(real(z)) && isfinite(imag(z))
+
++(u::ComplexNumber, v::ComplexNumber) = ComplexNumber(real(u) + real(v), imag(u) + imag(v))
+-(u::ComplexNumber, v::ComplexNumber) = ComplexNumber(real(u) - real(v), imag(u) - imag(v))
+*(u::ComplexNumber, v::ComplexNumber) = ComplexNumber(real(u) * real(v) - imag(u) * imag(v), real(u) * imag(v) + imag(u) * real(v))
+/(u::ComplexNumber, v::ComplexNumber) = ComplexNumber((real(u) * real(v) + imag(u) * imag(v)) / (real(v)^2 + imag(v)^2), (imag(u) * real(v) - real(u) * imag(v)) / (real(v)^2 + imag(v)^2))
+-(z::ComplexNumber) = ComplexNumber(-real(z), -imag(z))
+
+function exp(z::ComplexNumber)
+    z_re, z_im = reim(z)
+    e_re = exp(z_re)
+    ComplexNumber(e_re * cos(z_im), e_re * sin(z_im))
+end

data/tracks/julia/exercises/complex-numbers/runtests.jl

@@ -0,0 +1,74 @@
+using Base.Test
+
+include("complex-numbers.jl")
+
+@test ComplexNumber <: Number
+
+@test ComplexNumber(0, 1)^2 == ComplexNumber(-1, 0)
+
+@testset "Arithmetic" begin
+    @testset "Addition" begin
+        @test ComplexNumber(1, 0) + ComplexNumber(2, 0) == ComplexNumber(3, 0)
+        @test ComplexNumber(0, 1) + ComplexNumber(0, 2) == ComplexNumber(0, 3)
+        @test ComplexNumber(1, 2) + ComplexNumber(3, 4) == ComplexNumber(4, 6)
+    end
+
+    @testset "Subtraction" begin
+        @test ComplexNumber(1, 0) - ComplexNumber(2, 0) == ComplexNumber(-1, 0)
+        @test ComplexNumber(0, 1) - ComplexNumber(0, 2) == ComplexNumber(0, -1)
+        @test ComplexNumber(1, 2) - ComplexNumber(3, 4) == ComplexNumber(-2, -2)
+    end
+
+    @testset "Multiplication" begin
+        @test ComplexNumber(1, 0) * ComplexNumber(2, 0) == ComplexNumber(2, 0)
+        @test ComplexNumber(0, 1) * ComplexNumber(0, 2) == ComplexNumber(-2, 0)
+        @test ComplexNumber(1, 2) * ComplexNumber(3, 4) == ComplexNumber(-5, 10)
+    end
+
+    @testset "Division" begin
+        @test ComplexNumber(1, 0) / ComplexNumber(2, 0) == ComplexNumber(0.5, 0)
+        @test ComplexNumber(0, 1) / ComplexNumber(0, 2) == ComplexNumber(0.5, 0)
+        @test ComplexNumber(1, 2) / ComplexNumber(3, 4) == ComplexNumber(0.44, 0.08)
+    end
+end
+
+@testset "Absolute value" begin
+    @test abs(ComplexNumber(5, 0))  == 5
+    @test abs(ComplexNumber(-5, 0)) == 5
+    @test abs(ComplexNumber(0, 5))  == 5
+    @test abs(ComplexNumber(0, -5)) == 5
+    @test abs(ComplexNumber(3, 4))  == 5
+end
+
+@testset "Complex conjugate" begin
+    @test conj(ComplexNumber(5, 0))  == ComplexNumber(5, 0)
+    @test conj(ComplexNumber(0, 5))  == ComplexNumber(0, -5)
+    @test conj(ComplexNumber(1, 1))  == ComplexNumber(1, -1)
+end
+
+@testset "Real part" begin
+    @test real(ComplexNumber(1, 0)) == 1
+    @test real(ComplexNumber(0, 1)) == 0
+    @test real(ComplexNumber(1, 2)) == 1
+end
+
+@testset "Imaginary part" begin
+    @test imag(ComplexNumber(1, 0)) == 0
+    @test imag(ComplexNumber(0, 1)) == 1
+    @test imag(ComplexNumber(1, 2)) == 2
+end
+
+# Bonus A
+@testset "Complex exponential" begin
+    @test_skip exp(ComplexNumber(0, π)) ≈ ComplexNumber(-1, 0)
+    @test_skip exp(ComplexNumber(0, 0)) == ComplexNumber(1, 0)
+    @test_skip exp(ComplexNumber(1, 0)) ≈ ComplexNumber(e, 0)
+end
+
+# Bonus B
+@testset "Syntax sugar jm" begin
+    @test_skip ComplexNumber(0, 1)  == jm
+    @test_skip ComplexNumber(1, 0)  == 1 + 0jm
+    @test_skip ComplexNumber(1, 1)  == 1 + 1jm
+    @test_skip ComplexNumber(-1, 0) == jm^2
+end

data/tracks/kotlin/README.md

@@ -34,7 +34,7 @@ To submit a fix for an existing exercise or port an exercise to Kotlin with the
    (see [exercism.io: Installing Kotlin](http://exercism.io/languages/kotlin/installing))
 -  **Setup a branch on a fork of [exercism/kotlin](https://github.com/exercism/kotlin) on your computer.**
 
-   See [GitHub Help: Forking](https://help.github.com/articles/fork-a-repo/).  Use those instructions (in conjunction with [Exercism Contributing Guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#git-basics)) to:
+Use those instructions (in conjunction with the [Git Basics doc](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/git-basics.md)) to:
    * "fork" a repository on GitHub;
    - install `git`;
    - "clone" a copy of your fork;
@@ -52,15 +52,15 @@ To submit a fix for an existing exercise or port an exercise to Kotlin with the
    $ git push
    ```
 
-   [Exercism Contributing Guide :: Commit Messages](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md#commit-messages) provides practical advice on crafting meaningful commit messages.
+   The Git Basics doc has a section on [commit messages](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/git-basics.md#commit-messages) that provides practical advice on crafting meaningful commit messages.
 -  **Verify that your work passes all tests.**  When you create a pull request (PR), GitHub triggers a build on Travis CI.  Your PR will not be merged unless those tests pass.
 
 ## Getting Familiar With the Codebase
 
 There are two objectives to the design of this build:
 
-1. when a problem is built from within the kotlin repo (i.e. when you, the contributor, are developing the exercise), the tests run against the "example" code;
-2. when a problem is built outside the kotlin repo (when a participant is solving the exercise), the tests run against the "main" code.
+1. when a problem is built from within the `exercism/kotlin` repo (i.e. when you, the contributor, are developing the exercise), the tests run against the "example" code;
+2. when a problem is built outside the `exercism/kotlin` repo (when a participant is solving the exercise), the tests run against the "main" code.
 
 This repo is a multi-project gradle build.
 
@@ -68,15 +68,15 @@ This repo is a multi-project gradle build.
 
 This is the top-level module, contained in the `exercises` directory.  It is a container for the problem sub-modules.
 
-  * it's `build.gradle` points the "main" sourceset to the example code.
-  * it's `settings.gradle` names each of the subprojects, one for each problem in the set.
+  * its `build.gradle` points the "main" sourceset to the example code.
+  * its `settings.gradle` names each of the subprojects, one for each problem in the set.
 
 ### The Problem Submodules
 
 The `exercises` subdirectory contains all of the problem submodules.
 Each problem/submodule is a subdirectory of the same name as its slug.
 
-  * it's `build.gradle` names dependencies required to work that problem.
+  * its `build.gradle` names dependencies required to work that problem.
 
 Each problem/submodule has three source sets:
 
@@ -109,7 +109,7 @@ and if you review the logs of your x-api, you'll find:
 2015-09-06 15:21:01 - JSON::GeneratorError - source sequence is illegal/malformed utf-8:
 ```
 
-This is because some files generated by the build can't be served from the x-api.  This is by design: the CLI does not serve binaries.  To fix this, simply make sure you do a clean in your `kotlin` repo before you fetch:
+This is because some files generated by the build can't be served from the x-api.  This is by design: the CLI does not serve binaries.  To fix this, simply make sure you do a clean in your `exercism/kotlin` repo before you fetch:
 
 ```
 cd ~/workspace/exercism/kotlin/exercises

data/tracks/kotlin/bin/journey-test.sh

@@ -3,7 +3,7 @@
 # This script is shared between the Java and Kotlin tracks.  If you make an update to this script on
 # one track, please create a companion PR to merge it in to the other.  Thank you!
 TRACK=kotlin
-TRACK_REPO="x${TRACK}"
+TRACK_REPO="$TRACK"
 TRACK_SRC_EXT="kt"
 
 on_exit() {

data/tracks/kotlin/exercises/allergies/src/example/kotlin/Allergen.kt

@@ -0,0 +1 @@
+../../main/kotlin/Allergen.kt

data/tracks/kotlin/exercises/hamming/src/test/kotlin/HammingTest.kt

@@ -1,61 +1,111 @@
 import org.junit.Test
 import org.junit.Ignore
+import org.junit.Rule
+import org.junit.rules.ExpectedException
 import kotlin.test.assertEquals
 
+/*
+ * version: 1.1.0
+ */
 class HammingTest {
-    
 
+    @Rule
+    @JvmField
+    var expectedException: ExpectedException = ExpectedException.none()
+
+    @Test
+    fun noDistanceBetweenEmptyStrands() {
+        assertEquals(0, Hamming.compute("", ""))
+    }
+
+    @Ignore
     @Test
-    fun noDifferenceBetweenIdenticalStrands() {
+    fun noDistanceBetweenShortIdenticalStrands() {
         assertEquals(0, Hamming.compute("A", "A"))
     }
 
     @Ignore
     @Test
-    fun completeHammingDistanceOfForSingleNucleotideStrand() {
+    fun noDistanceBetweenLongIdenticalStrands() {
+        assertEquals(0, Hamming.compute("GGACTGA", "GGACTGA"))
+    }
+
+    @Ignore
+    @Test
+    fun completeDistanceInSingleNucleotideStrand() {
         assertEquals(1, Hamming.compute("A", "G"))
     }
 
     @Ignore
     @Test
-    fun completeHammingDistanceForSmallStrand() {
+    fun completeDistanceInSmallStrand() {
         assertEquals(2, Hamming.compute("AG", "CT"))
     }
 
     @Ignore
     @Test
-    fun smallHammingDistance() {
+    fun smallDistanceInSmallStrand() {
         assertEquals(1, Hamming.compute("AT", "CT"))
     }
 
     @Ignore
     @Test
-    fun smallHammingDistanceInLongerStrand() {
+    fun smallDistanceInMediumStrand() {
         assertEquals(1, Hamming.compute("GGACG", "GGTCG"))
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException::class)
-    fun validatesFirstStrandNotLonger() {
-        Hamming.compute("AAAG", "AAA")
+    @Test
+    fun smallDistanceInLongStrand() {
+        assertEquals(2, Hamming.compute("ACCAGGG", "ACTATGG"))
+    }
+
+    @Ignore
+    @Test
+    fun nonUniqueCharacterInFirstStrand() {
+        assertEquals(1, Hamming.compute("AGA", "AGG"))
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException::class)
-    fun validatesOtherStrandNotLonger() {
-        Hamming.compute("AAA", "AAAG")
+    @Test
+    fun nonUniqueCharacterInSecondStrand() {
+        assertEquals(1, Hamming.compute("AGG", "AGA"))
     }
 
     @Ignore
     @Test
-    fun largeHammingDistance() {
+    fun sameNucleotidesInDifferentPositions() {
+        assertEquals(2, Hamming.compute("TAG", "GAT"))
+    }
+
+    @Ignore
+    @Test
+    fun largeDistanceInPermutedStrand() {
         assertEquals(4, Hamming.compute("GATACA", "GCATAA"))
     }
 
     @Ignore
     @Test
-    fun hammingDistanceInVeryLongStrand() {
+    fun largeDistanceInOffByOneStrand() {
         assertEquals(9, Hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"))
     }
 
+    @Ignore
+    @Test
+    fun validatesFirstStrandNotLonger() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("leftStrand and rightStrand must be of equal length.")
+
+        Hamming.compute("AATG", "AAA")
+    }
+
+    @Ignore
+    @Test
+    fun validatesSecondStrandNotLonger() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("leftStrand and rightStrand must be of equal length.")
+
+        Hamming.compute("ATA", "AGTG")
+    }
+
 }

data/tracks/kotlin/exercises/hello-world/TUTORIAL.md

@@ -679,8 +679,7 @@ than 100 maintainers and many more contributors.
 
 A starting point to jumping in can be found here:
 
-https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md
-
+https://github.com/exercism/problem-specifications/blob/master/CONTRIBUTING.md
 
 ----
 

data/tracks/kotlin/exercises/pangram/src/test/kotlin/PangramTest.kt

@@ -3,9 +3,11 @@ import org.junit.Ignore
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
+/*
+ * version: 1.1.0
+ */
 class PangramTest {
 
-
     @Test
     fun emptySentence() {
         assertFalse(Pangrams.isPangram(""))
@@ -52,17 +54,11 @@ class PangramTest {
     fun mixedCaseAndPunctuation() {
         assertTrue(Pangrams.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""))
     }
-    
-    @Ignore
-    @Test
-    fun mixedCaseDuplicatedCharacters() {
-        assertFalse(Pangrams.isPangram("the quick brown fox jumps over the lazy FOX"))
-    }
 
     @Ignore
     @Test
-    fun nonAsciiCharacters() {
-        assertTrue(Pangrams.isPangram("Victor jagt zwölf Boxkämpfer quer über den großen Sylter Deich."))
+    fun mixedCaseDuplicatedCharacters() {
+        assertFalse(Pangrams.isPangram("the quick brown fox jumps over with lazy FX"))
     }
 
 }

data/tracks/kotlin/exercises/phone-number/src/example/kotlin/PhoneNumber.kt

@@ -1,6 +1,6 @@
 data class PhoneNumber(private val rawNumber: String) {
     companion object {
-        private val validationRegex = Regex("^1?(\\d{10})$")
+        private val validationRegex = Regex("^1?([2-9]\\d{2}[2-9]\\d{6})$")
     }
     private val cleanedNumber = rawNumber.replace(Regex("[^\\d]"), "")
 

data/tracks/kotlin/exercises/phone-number/src/test/kotlin/PhoneNumberTest.kt

@@ -8,8 +8,8 @@ class PhoneNumberTest {
 
     @Test
     fun cleansNumber() {
-        val expectedNumber = "1234567890"
-        val actualNumber = PhoneNumber("(123) 456-7890").number
+        val expectedNumber = "2234567890"
+        val actualNumber = PhoneNumber("(223) 456-7890").number
 
         assertEquals(expectedNumber, actualNumber)
     }
@@ -17,8 +17,8 @@ class PhoneNumberTest {
     @Ignore
     @Test
     fun cleansNumberWithDots() {
-        val expectedNumber = "1234567890"
-        val actualNumber = PhoneNumber("123.456.7890").number
+        val expectedNumber = "2234567890"
+        val actualNumber = PhoneNumber("223.456.7890").number
 
         assertEquals(expectedNumber, actualNumber)
     }
@@ -26,12 +26,20 @@ class PhoneNumberTest {
     @Ignore
     @Test
     fun validWhen11DigitsAndFirstIs1() {
-        val expectedNumber = "1234567890"
-        val actualNumber = PhoneNumber("11234567890").number
+        val expectedNumber = "2234567890"
+        val actualNumber = PhoneNumber("12234567890").number
 
         assertEquals(expectedNumber, actualNumber)
     }
 
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun invalidWhen10DigitsAndFirstIs1() {
+        val actualNumber = PhoneNumber("1234567890")
+
+        fail("IllegalArgumentException should have been thrown")
+    }
+
     @Ignore
     @Test(expected = IllegalArgumentException::class)
     fun invalidWhenOnly11Digits() {
@@ -43,7 +51,7 @@ class PhoneNumberTest {
     @Ignore
     @Test(expected = IllegalArgumentException::class)
     fun invalidWhen9Digits() {
-        val actualNumber = PhoneNumber("123456789")
+        val actualNumber = PhoneNumber("223456789")
 
         fail("IllegalArgumentException should have been thrown")
     }
@@ -51,8 +59,8 @@ class PhoneNumberTest {
     @Ignore
     @Test
     fun areaCode() {
-        val expectedAreaCode = "123"
-        val actualAreaCode = PhoneNumber("1234567890").areaCode
+        val expectedAreaCode = "223"
+        val actualAreaCode = PhoneNumber("2234567890").areaCode
 
         assertEquals(expectedAreaCode, actualAreaCode)
     }
@@ -60,8 +68,8 @@ class PhoneNumberTest {
     @Ignore
     @Test
     fun toStringPrint() {
-        val expectedtoStringNumber = "(123) 456-7890"
-        val actualtoStringNumber = PhoneNumber("1234567890").toString()
+        val expectedtoStringNumber = "(223) 456-7890"
+        val actualtoStringNumber = PhoneNumber("2234567890").toString()
 
         assertEquals(expectedtoStringNumber, actualtoStringNumber)
     }
@@ -69,8 +77,8 @@ class PhoneNumberTest {
     @Ignore
     @Test
     fun toStringPrintWithFullUSPhoneNumber() {
-        val expectedtoStringNumber = "(123) 456-7890"
-        val actualtoStringNumber = PhoneNumber("11234567890").toString()
+        val expectedtoStringNumber = "(223) 456-7890"
+        val actualtoStringNumber = PhoneNumber("12234567890").toString()
 
         assertEquals(expectedtoStringNumber, actualtoStringNumber)
     }