Problems in Computer Science are often classified as belonging to a certain class of problems (e.g. NP, Unsolvable, Recursive, etc.). In this problem you will be analyzing a property of an algorithm whose classification is not known for all possible inputs:

```1. input n
2. print n
3. if n = 1 then STOP
4.      if n is odd then n = 3n + 1
5.      else n = n / 2
6. GOTO 2
```

Given the input `22`, the following sequence of numbers would be printed:

`22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1`

It is conjectured that the algorithm above will terminate (when a `1` is printed) for any integral input value. Despite the simplicity of the algorithm, it is unknown whether this conjecture is true. It has been verified, however, for all integers `n` such that `1 <= n <= 1,000,000` (and, in fact, for many more numbers than this.)

Given an input `n`, it is possible to determine the number of numbers printed before and including the `1` is printed. For a given `n` this is called the cycle-length of `n`. In the example above, the cycle length of `22` is `16`.

For any two integers `i` and `j` you are to determine the maximum cycle length over all numbers between and including both `i` and `j`.

## Input¶

The input will consist of a series of pairs of integers `i` and `j`, one pair of integers per line, where the integers will be between `1` and `1,000,000` (inclusive).

You should process all pairs of integers and for each pair determine the maximum cycle length over all integers between and including `i` and `j`.

```1 10
100 200
201 210
900 1000
```

## Output¶

For each pair of input integers `i` and `j` you should output `i`, `j`, the number with the maximum cycle length for integers between and including `i` and `j`, and the length of this maximum cycle as shown below:

### Example Output¶

```1 10 9 20
100 200 171 125
201 210 206 89
900 1000 937 174
```

Note: The integers `i` and `j` must appear in the output in the same order in which they appeared in the input and should be followed by the number with the maximum cycle length, and then maximum cycle length (on the same line). If there are multiple numbers with the maximum cycle length, choose the smallest number.

#### Programming Challenges¶

This is based on The 3n + 1 problem on the UVa Online Judge and "Problem 13.16" of Elements of Programming Interviews.

#### Algorithmic Complexity¶

For each input test case, your solution should have the following targets:

 Time Complexity `O(N^3)`, where `N` is the largest of the pair of input integers. Space Complexity `O(N^2)` where `N` is the largest of the pair of input integers.

Your solution may be below the targets, but it should not exceed them.

## Submission¶

```\$ cd path/to/cse-30872-fa21-assignments     # Go to assignments repository
\$ git checkout master                       # Make sure we are on master
\$ git pull --rebase                         # Pull any changes from GitHub

\$ git checkout -b challenge05               # Create and checkout challenge05 branch

\$ \$EDITOR challenge05/program.cpp           # Edit your code

\$ git commit -m "challenge05: done"         # Commit your changes

\$ git push -u origin challenge05            # Send changes to GitHub
```

To check your code, you can use the `.scripts/check.py` script or curl:

```\$ .scripts/submit.py
Checking challenge05 code ...
Result Success
Time 1.81
Score 6.00 / 6.00

\$ curl -F source=@challenge05/program.cpp https://dredd.h4x0r.space/code/cse-30872-fa21/challenge05
{"result": "Success", "score": 6, "time": 1.80951787948608398}
```

#### Pull Request¶

Once you have committed your work and pushed it to GitHub, remember to create a pull request and assign it to the appropriate teaching assistant from the Reading 03 TA List.