Kotlin - Backfill

kotlin/bracket-push/README.md

@@ -0,0 +1,13 @@
+# Bracket Push
+
+Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
+verify that all the pairs are matched and nested correctly.
+
+
+
+## Source
+
+Ginna Baker
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

kotlin/bracket-push/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

kotlin/bracket-push/src/test/kotlin/BracketPushTest.kt

@@ -0,0 +1,35 @@
+
+import org.junit.Test
+import org.junit.Ignore
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+import kotlin.test.assertEquals
+
+@RunWith(Parameterized::class)
+class BracketPushTest(val input: String, val expectedOutput: Boolean) {
+
+    companion object {
+        @JvmStatic
+        @Parameterized.Parameters(name = "{index}: bracket({0})={1}")
+        fun data() = listOf(
+                arrayOf("[]", true),
+                arrayOf("", true),
+                arrayOf("[[", false),
+                arrayOf("}{", false),
+                arrayOf("{ }", true),
+                arrayOf("{[]}", true),
+                arrayOf("{}[]", true),
+                arrayOf("([{}({}[])])", true),
+                arrayOf("([{])", false),
+                arrayOf("[({]})", false),
+                arrayOf("(((185 + 223.85) * 15) - 543)/2", true),
+                arrayOf("\\\\left(\\\\begin{array}{cc} \\\\frac{1}{3} & x\\\\\\\\ \\\\mathrm{e}^{x} &... x^2 \\\\end{array}\\\\right)", true)
+        )
+    }
+
+
+    @Test
+    fun test() {
+        assertEquals(expectedOutput, BracketPush.isValid(input))
+    }
+}

kotlin/pascals-triangle/README.md

@@ -0,0 +1,24 @@
+# Pascals Triangle
+
+Compute Pascal's triangle up to a given number of rows.
+
+In Pascal's Triangle each number is computed by adding the numbers to
+the right and left of the current position in the previous row.
+
+```plain
+    1
+   1 1
+  1 2 1
+ 1 3 3 1
+1 4 6 4 1
+# ... etc
+```
+
+
+
+## Source
+
+Pascal's Triangle at Wolfram Math World [http://mathworld.wolfram.com/PascalsTriangle.html](http://mathworld.wolfram.com/PascalsTriangle.html)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

kotlin/pascals-triangle/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

kotlin/pascals-triangle/src/test/kotlin/PascalsTriangleTest.kt

@@ -0,0 +1,48 @@
+import org.junit.Test
+import org.junit.Ignore
+import kotlin.test.assertEquals
+
+class PascalsTriangleTest {
+
+
+    @Test
+    fun triangleWithFourRows() {
+        val expectedOutput = listOf(
+                listOf(1),
+                listOf(1, 1),
+                listOf(1, 2, 1),
+                listOf(1, 3, 3, 1)
+        )
+
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(4))
+    }
+
+    
+    @Test
+    fun triangleWithSixRows() {
+        val expectedOutput = listOf(
+                listOf(1),
+                listOf(1, 1),
+                listOf(1, 2, 1),
+                listOf(1, 3, 3, 1),
+                listOf(1, 4, 6, 4, 1),
+                listOf(1, 5, 10, 10, 5, 1)
+        )
+
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(6))
+    }
+
+    
+    @Test
+    fun expectEmptyTriangle() {
+        val expectedOutput = emptyList<List<Int>>()
+
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(0))
+    }
+
+    
+    @Test(expected = IllegalArgumentException::class)
+    fun validatesNotNegativeRows() {
+        PascalsTriangle.computeTriangle(-1)
+    }
+}

kotlin/rotational-cipher/README.md

@@ -0,0 +1,39 @@
+# Rotational Cipher
+
+Create an implementation of the rotational cipher, also sometimes called the Caesar cipher.
+
+The Caesar cipher is a simple shift cipher that relies on
+transposing all the letters in the alphabet using an integer key
+between `0` and `26`. Using a key of `0` or `26` will always yield
+the same output due to modular arithmetic. The letter is shifted
+for as many values as the value of the key.
+
+The general notation for rotational ciphers is `ROT + <key>`.
+The most commonly used rotational cipher is `ROT13`.
+
+A `ROT13` on the Latin alphabet would be as follows:
+
+```plain
+Plain:  abcdefghijklmnopqrstuvwxyz
+Cipher: nopqrstuvwxyzabcdefghijklm
+```
+
+It is stronger than the Atbash cipher because it has 27 possible keys, and 25 usable keys.
+
+Ciphertext is written out in the same formatting as the input including spaces and punctuation.
+
+## Examples
+- ROT5  `omg` gives `trl`
+- ROT0  `c` gives `c`
+- ROT26 `Cool` gives `Cool`
+- ROT13 `The quick brown fox jumps over the lazy dog.` gives `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.`
+- ROT13 `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.` gives `The quick brown fox jumps over the lazy dog.`
+
+
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Caesar_cipher](https://en.wikipedia.org/wiki/Caesar_cipher)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

kotlin/rotational-cipher/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

kotlin/rotational-cipher/src/test/kotlin/RotationalCipherTest.kt

@@ -0,0 +1,81 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.0
+ */
+class RotationalCipherTest {
+
+    @Test
+    fun testRotateLowercaseABy1NoWrapAround() {
+        val cipher = RotationalCipher(1)
+        assertEquals("b", cipher.encode("a"))
+    }
+
+    
+    @Test
+    fun testRotateLowercaseABy26SingleWrapAround() {
+        val cipher = RotationalCipher(26)
+        assertEquals("a", cipher.encode("a"))
+    }
+
+    
+    @Test
+    fun testRotateLowercaseABy0() {
+        val cipher = RotationalCipher(0)
+        assertEquals("a", cipher.encode("a"))
+    }
+
+    
+    @Test
+    fun testRotateLowercaseMBy13NoWrapAround() {
+        val cipher = RotationalCipher(13)
+        assertEquals("z", cipher.encode("m"))
+    }
+
+    
+    @Test
+    fun testRotateLowercaseNBy1SingleWrapAround() {
+        val cipher = RotationalCipher(13)
+        assertEquals("a", cipher.encode("n"))
+    }
+
+    
+    @Test
+    fun testRotateCapitalLettersNoWrapAround() {
+        val cipher = RotationalCipher(5)
+        assertEquals("TRL", cipher.encode("OMG"))
+    }
+
+    
+    @Test
+    fun testSpacesAreUnalteredByRotation() {
+        val cipher = RotationalCipher(5)
+        assertEquals("T R L", cipher.encode("O M G"))
+    }
+
+    
+    @Test
+    fun testNumbersAreUnalteredByRotation() {
+        val cipher = RotationalCipher(4)
+        assertEquals("Xiwxmrk 1 2 3 xiwxmrk", cipher.encode("Testing 1 2 3 testing"))
+    }
+
+    
+    @Test
+    fun testPunctuationIsUnalteredByRotation() {
+        val cipher = RotationalCipher(21)
+        assertEquals("Gzo'n zvo, Bmviyhv!", cipher.encode("Let's eat, Grandma!"))
+    }
+
+    
+    @Test
+    fun testAllLettersRotateCorrectly() {
+        val cipher = RotationalCipher(13)
+        assertEquals(
+                "Gur dhvpx oebja sbk whzcf bire gur ynml qbt.",
+                cipher.encode("The quick brown fox jumps over the lazy dog."))
+    }
+
+}

kotlin/series/README.md

@@ -0,0 +1,30 @@
+# Series
+
+Given a string of digits, output all the contiguous substrings of length `n` in
+that string.
+
+For example, the string "49142" has the following 3-digit series:
+
+- 491
+- 914
+- 142
+
+And the following 4-digit series:
+
+- 4914
+- 9142
+
+And if you ask for a 6-digit series from a 5-digit string, you deserve
+whatever you get.
+
+Note that these series are only required to occupy *adjacent positions*
+in the input; the digits need not be *numerically consecutive*.
+
+
+
+## Source
+
+A subset of the Problem 8 at Project Euler [http://projecteuler.net/problem=8](http://projecteuler.net/problem=8)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

kotlin/series/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

kotlin/series/src/test/kotlin/SeriesTest.kt

@@ -0,0 +1,36 @@
+import org.junit.Test
+import org.junit.Ignore
+import kotlin.test.assertEquals
+
+class SeriesTest {
+
+
+    @Test
+    fun slicesOfOne() {
+        assertEquals(listOf<List<Int>>(), Series.slices(1, ""))
+        assertEquals(
+                listOf(listOf(0), listOf(1), listOf(2), listOf(3), listOf(4)),
+                Series.slices(1, "01234")
+        )
+    }
+
+    @Test
+    fun slicesOfTwo() {
+        assertEquals(listOf<List<Int>>(), Series.slices(2, ""))
+        assertEquals(listOf(listOf(0, 1)), Series.slices(2, "01"))
+        assertEquals(
+                listOf(listOf(0, 1), listOf(1, 2), listOf(2, 3), listOf(3, 4)),
+                Series.slices(2, "01234")
+        )
+    }
+
+    @Test
+    fun slicesOfThree() {
+        assertEquals(listOf<List<Int>>(), Series.slices(3, ""))
+        assertEquals(listOf(listOf(0, 1, 2)), Series.slices(3, "012"))
+        assertEquals(
+                listOf(listOf(0, 1, 2), listOf(1, 2, 3), listOf(2, 3, 4)),
+                Series.slices(3, "01234")
+        )
+    }
+}