ðŸŽ‰ Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io ðŸŽ‰

# krukouskiandrei's solution

## to Collatz Conjecture in the Kotlin Track

Published at Oct 12 2020 · 0 comments
Instructions
Test suite
Solution

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:

1. 12
2. 6
3. 3
4. 10
5. 5
6. 16
7. 8
8. 4
9. 2
10. 1

Resulting in 9 steps. So for input n = 12, the return value would be 9.

## Setup

Go through the setup instructions for Kotlin to install the necessary dependencies:

https://exercism.io/tracks/kotlin/installation

## Making the test suite pass

Execute the tests with:

``````\$ gradlew test
``````

Use `gradlew.bat` if you're on Windows

In the test suites all tests but the first have been skipped.

Once you get a test passing, you can enable the next one by removing the `@Ignore` annotation.

## Source

An unsolved problem in mathematics named after mathematician Lothar Collatz 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.

### CollatzCalculatorTest.kt

``````import org.junit.Ignore
import org.junit.Rule
import org.junit.Test
import org.junit.rules.ExpectedException
import kotlin.test.assertEquals

class CollatzCalculatorTest {

@Rule
@JvmField
var expectedException: ExpectedException = ExpectedException.none()

@Test
fun `zero steps for 1`() = assertStepsEqual(1, 0)

@Ignore
@Test
fun `divide if even`() = assertStepsEqual(16, 4)

@Ignore
@Test
fun `even and odd steps`() = assertStepsEqual(12, 9)

@Ignore
@Test
fun `large number of even and odd steps`() = assertStepsEqual(1000000, 152)

@Ignore
@Test(expected = IllegalArgumentException::class)
fun `invalid input | zero`() {
steps(0)
}

@Ignore
@Test(expected = IllegalArgumentException::class)
fun `invalid input | negative`() {
steps(-15)
}

}

private fun assertStepsEqual(input: Int, steps: Int) = assertEquals(steps, steps(input))

private fun steps(input: Int) = CollatzCalculator.computeStepCount(input)``````
``````object CollatzCalculator {
fun computeStepCount(start: Int): Int {
if (start < 1) throw IllegalArgumentException("Invalid input for the collatz algorithm: \$start")

return getCountOfSteps(start)
}

private fun getCountOfSteps(value: Int): Int {
if (value == 1) return 0

val newValue = if (value % 2 == 0) value / 2 else value * 3 + 1

return getCountOfSteps(newValue) + 1
}
}``````