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`

.

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
```

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:

```
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.

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

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**.

To submit your work, follow the same procedure you used for Reading 00:

```
$ cd path/to/cse-30872-fa24-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 add challenge05/program.cpp # Stage your changes
$ 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-fa24/challenge05
{"result": "Success", "score": 6, "time": 1.80951787948608398}
```

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.