 # abomehsen's solution

## to Collatz Conjecture in the Kotlin Track

Published at Oct 21 2019 · 0 comments
Instructions
Test suite
Solution

#### Note:

This exercise has changed since this solution was written.

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 testZeroStepsRequiredWhenStartingFrom1() {
assertEquals(0, CollatzCalculator.computeStepCount(1))
}

@Ignore
@Test
fun testCorrectNumberOfStepsWhenAllStepsAreDivisions() {
assertEquals(4, CollatzCalculator.computeStepCount(16))
}

@Ignore
@Test
fun testCorrectNumberOfStepsWhenBothStepTypesAreNeeded() {
assertEquals(9, CollatzCalculator.computeStepCount(12))
}

@Ignore
@Test
fun testAVeryLargeInput() {
assertEquals(152, CollatzCalculator.computeStepCount(1000000))
}

@Ignore
@Test
fun testZeroIsConsideredInvalidInput() {
expectedException.expect(IllegalArgumentException::class.java)
expectedException.expectMessage("Only natural numbers are allowed")

CollatzCalculator.computeStepCount(0)
}

@Ignore
@Test
fun testNegativeIntegerIsConsideredInvalidInput() {
expectedException.expect(IllegalArgumentException::class.java)
expectedException.expectMessage("Only natural numbers are allowed")

CollatzCalculator.computeStepCount(-15)
}

}``````
``````object CollatzCalculator {
fun computeStepCount(num:Int): Int =find(num) { i: Int -> if (i%2==0) i/2
else i*3+1
}
}
fun find(num:Int, block: (Int) -> Int): Int {
require(num>0){"Only natural numbers are allowed"}
return generateSequence(num){ block(it) }.takeWhile { it>1 }.count()
}``````