# artemkorsakov's solution

## to Collatz Conjecture in the Java Track

Published at Mar 16 2019 · 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.

# Running the tests

You can run all the tests for an exercise by entering

``````\$ gradle test
``````

## 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.java

``````import org.junit.Before;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

import static org.junit.Assert.assertEquals;

public class CollatzCalculatorTest {

@Rule
public ExpectedException expectedException = ExpectedException.none();

private CollatzCalculator collatzCalculator;

@Before
public void setUp() {
collatzCalculator = new CollatzCalculator();
}

@Test
public void testZeroStepsRequiredWhenStartingFrom1() {
assertEquals(0, collatzCalculator.computeStepCount(1));
}

@Ignore("Remove to run test")
@Test
public void testCorrectNumberOfStepsWhenAllStepsAreDivisions() {
assertEquals(4, collatzCalculator.computeStepCount(16));
}

@Ignore("Remove to run test")
@Test
public void testCorrectNumberOfStepsWhenBothStepTypesAreNeeded() {
assertEquals(9, collatzCalculator.computeStepCount(12));
}

@Ignore("Remove to run test")
@Test
public void testAVeryLargeInput() {
assertEquals(152, collatzCalculator.computeStepCount(1000000));
}

@Ignore("Remove to run test")
@Test
public void testZeroIsConsideredInvalidInput() {
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Only natural numbers are allowed");

collatzCalculator.computeStepCount(0);
}

@Ignore("Remove to run test")
@Test
public void testNegativeIntegerIsConsideredInvalidInput() {
expectedException.expect(IllegalArgumentException.class);
expectedException.expectMessage("Only natural numbers are allowed");

collatzCalculator.computeStepCount(-15);
}

}``````
``````class CollatzCalculator {

int computeStepCount(int start) {
if (start < 1) {
throw new IllegalArgumentException("Only natural numbers are allowed");
}

int count = 0;
while (start != 1) {
start = start % 2 == 0 ? start / 2 : 3 * start + 1;
count++;
}
return count;
}

}``````