trackler 2.1.0.53 → 2.1.0.54

data/tracks/kotlin/exercises/minesweeper/src/example/kotlin/MinesweeperBoard.kt

@@ -0,0 +1,54 @@
+private const val MINE_CHAR = '*'
+private const val SPACE_CHAR = ' '
+
+data class MinesweeperBoard(val mineLocations: List<String>) {
+
+    private val numberOfRows by lazy {
+        mineLocations.size
+    }
+
+    private val numberOfColumns by lazy {
+        if (mineLocations.isEmpty()) 0 else mineLocations[0].length
+    }
+
+    fun withNumbers() = (0 until numberOfRows).map { getRowWithNumbers(it) }
+
+    private fun getRowWithNumbers(rowNumber: Int) =
+            (0 until numberOfColumns)
+                    .map { columnNumber -> getCellNumber(rowNumber, columnNumber) }
+                    .joinToString("")
+
+    private fun getCellNumber(rowNumber: Int, columnNumber: Int): Char {
+        // If (rowNumber, columnNumber) is a mine, we're done.
+        if (mineLocations[rowNumber][columnNumber] == MINE_CHAR) {
+            return MINE_CHAR
+        }
+
+        val mineCount = computeMineCountAround(rowNumber, columnNumber)
+
+        // If computed count is positive, add it to the annotated row. Otherwise, add a blank space.
+        return if (mineCount > 0) Character.forDigit(mineCount, 10) else SPACE_CHAR
+    }
+
+    private fun computeMineCountAround(rowNumber: Int, columnNumber: Int): Int {
+        var result = 0
+
+        // Compute row and column ranges to inspect (respecting board edges).
+        val minRowToInspect = Math.max(rowNumber - 1, 0)
+        val maxRowToInspect = Math.min(rowNumber + 1, numberOfRows - 1)
+        val minColToInspect = Math.max(columnNumber - 1, 0)
+        val maxColToInspect = Math.min(columnNumber + 1, numberOfColumns - 1)
+
+        // Count mines in the cells surrounding (row, col).
+        for (rowToInspect in minRowToInspect..maxRowToInspect) {
+            for (colToInspect in minColToInspect..maxColToInspect) {
+                if (mineLocations[rowToInspect][colToInspect] == MINE_CHAR) {
+                    result += 1
+                }
+            }
+        }
+
+        return result
+    }
+
+}

data/tracks/kotlin/exercises/minesweeper/src/test/kotlin/MinesweeperBoardTest.kt

@@ -0,0 +1,241 @@
+import org.junit.Ignore
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.0
+ */
+class MinesweeperBoardTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule
+    @JvmField
+    var expectedException: ExpectedException = ExpectedException.none()
+
+    @Test
+    fun testInputBoardWithNoRowsAndNoColumns() {
+        val inputBoard = emptyList<String>()
+        val expectedNumberedBoard = emptyList<String>()
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithOneRowAndNoColumns() {
+        val inputBoard = listOf("")
+        val expectedNumberedBoard = listOf("")
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithNoMines() {
+        val inputBoard = listOf(
+                "   ",
+                "   ",
+                "   "
+        )
+
+        val expectedNumberedBoard = listOf(
+                "   ",
+                "   ",
+                "   "
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithOnlyMines() {
+        val inputBoard = listOf(
+                "***",
+                "***",
+                "***"
+        )
+
+        val expectedNumberedBoard = listOf(
+                "***",
+                "***",
+                "***"
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithSingleMineAtCenter() {
+        val inputBoard = listOf(
+                "   ",
+                " * ",
+                "   "
+        )
+
+        val expectedNumberedBoard = listOf(
+                "111",
+                "1*1",
+                "111"
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithMinesAroundPerimeter() {
+        val inputBoard = listOf(
+                "***",
+                "* *",
+                "***"
+        )
+
+        val expectedNumberedBoard = listOf(
+                "***",
+                "*8*",
+                "***"
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithSingleRowAndTwoMines() {
+        val inputBoard = listOf(" * * ")
+
+        val expectedNumberedBoard = listOf("1*2*1")
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithSingleRowAndTwoMinesAtEdges() {
+        val inputBoard = listOf("*   *")
+
+        val expectedNumberedBoard = listOf("*1 1*")
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithSingleColumnAndTwoMines() {
+        val inputBoard = listOf(
+                " ",
+                "*",
+                " ",
+                "*",
+                " "
+        )
+
+        val expectedNumberedBoard = listOf(
+                "1",
+                "*",
+                "2",
+                "*",
+                "1"
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
+        val inputBoard = listOf(
+                "*",
+                " ",
+                " ",
+                " ",
+                "*"
+        )
+
+        val expectedNumberedBoard = listOf(
+                "*",
+                "1",
+                " ",
+                "1",
+                "*"
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testInputBoardWithMinesInCross() {
+        val inputBoard = listOf(
+                "  *  ",
+                "  *  ",
+                "*****",
+                "  *  ",
+                "  *  "
+        )
+
+        val expectedNumberedBoard = listOf(
+                " 2*2 ",
+                "25*52",
+                "*****",
+                "25*52",
+                " 2*2 "
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+    @Ignore
+    @Test
+    fun testLargeInputBoard() {
+        val inputBoard = listOf(
+                " *  * ",
+                "  *   ",
+                "    * ",
+                "   * *",
+                " *  * ",
+                "      "
+        )
+
+        val expectedNumberedBoard = listOf(
+                "1*22*1",
+                "12*322",
+                " 123*2",
+                "112*4*",
+                "1*22*2",
+                "111111"
+        )
+
+        val actualNumberedBoard = MinesweeperBoard(inputBoard).withNumbers()
+
+        assertEquals(expectedNumberedBoard, actualNumberedBoard)
+    }
+
+}

data/tracks/kotlin/exercises/prime-factors/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"]
+  }
+}

data/tracks/kotlin/exercises/prime-factors/src/example/kotlin/PrimeFactorCalculator.kt

@@ -0,0 +1,24 @@
+object PrimeFactorCalculator {
+
+    fun primeFactors(int: Int): List<Int> {
+        return primeFactors(int.toLong()).map(Long::toInt)
+    }
+
+    fun primeFactors(long: Long): List<Long> {
+        val result = mutableListOf<Long>()
+        var remainder = long
+        var divisor: Long = 2
+
+        while (remainder > 1) {
+            while (remainder.rem(divisor) == 0L) {
+                result.add(divisor)
+                remainder /= divisor
+            }
+
+            divisor++
+        }
+
+        return result
+    }
+
+}

data/tracks/kotlin/exercises/prime-factors/src/test/kotlin/PrimeFactorCalculatorTest.kt

@@ -0,0 +1,51 @@
+import org.junit.Ignore
+import org.junit.Test
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.0
+ */
+class PrimeFactorCalculatorTest {
+
+    @Test
+    fun testThat1HasNoPrimeFactors() {
+        assertEquals(emptyList(), PrimeFactorCalculator.primeFactors(1))
+    }
+
+    @Ignore
+    @Test
+    fun testThatAPrimeNumberHasExactlyOnePrimeFactor() {
+        assertEquals(listOf(2), PrimeFactorCalculator.primeFactors(2))
+    }
+
+    @Ignore
+    @Test
+    fun testThatASquareOfAPrimeHasExactlyOnePrimeFactorRepeatedTwice() {
+        assertEquals(listOf(3, 3), PrimeFactorCalculator.primeFactors(9))
+    }
+
+    @Ignore
+    @Test
+    fun testThatACubeOfAPrimeHasExactlyOnePrimeFactorRepeatedThreeTimes() {
+        assertEquals(listOf(2, 2, 2), PrimeFactorCalculator.primeFactors(8))
+    }
+
+    @Ignore
+    @Test
+    fun testThatAProductOfPrimesAndNonPrimesIsFactoredProperly() {
+        assertEquals(listOf(2, 2, 3), PrimeFactorCalculator.primeFactors(12))
+    }
+
+    @Ignore
+    @Test
+    fun testThatAProductOfSmallPrimesIsFactoredProperly() {
+        assertEquals(listOf(5, 17, 23, 461), PrimeFactorCalculator.primeFactors(901255))
+    }
+
+    @Ignore
+    @Test
+    fun testThatAProductOfSmallAndLargePrimesIsFactoredProperly() {
+        assertEquals(listOf<Long>(11, 9539, 894119), PrimeFactorCalculator.primeFactors(93819012551L))
+    }
+
+}

data/tracks/kotlin/exercises/robot-simulator/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"]
+  }
+}

data/tracks/kotlin/exercises/robot-simulator/src/example/kotlin/GridPosition.kt

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

data/tracks/kotlin/exercises/robot-simulator/src/example/kotlin/Orientation.kt

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

data/tracks/kotlin/exercises/robot-simulator/src/example/kotlin/Robot.kt

@@ -0,0 +1,34 @@
+fun Orientation.turnLeft()  = Orientation.values()[Math.floorMod(ordinal - 1, Orientation.values().size)]
+fun Orientation.turnRight() = Orientation.values()[Math.floorMod(ordinal + 1, Orientation.values().size)]
+
+class Robot(var gridPosition: GridPosition = GridPosition(0, 0), var orientation: Orientation = Orientation.NORTH) {
+
+    fun advance() {
+        gridPosition = when (orientation) {
+            Orientation.NORTH -> gridPosition.copy(y = gridPosition.y + 1)
+            Orientation.EAST  -> gridPosition.copy(x = gridPosition.x + 1)
+            Orientation.SOUTH -> gridPosition.copy(y = gridPosition.y - 1)
+            Orientation.WEST  -> gridPosition.copy(x = gridPosition.x - 1)
+        }
+    }
+
+    fun turnLeft() {
+        orientation = orientation.turnLeft()
+    }
+
+    fun turnRight() {
+        orientation = orientation.turnRight()
+    }
+
+    fun simulate(instructions: String) {
+        for (instruction in instructions) {
+            when (instruction) {
+                'A' -> advance()
+                'R' -> turnRight()
+                'L' -> turnLeft()
+                else -> throw IllegalArgumentException(String.format("Invalid instruction: '%s'", instruction))
+            }
+        }
+    }
+
+}