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

### Example Input

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

## Submission

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

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

\$ 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 GitLab``````

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

``````\$ .scripts/submit.py
Submitting challenge05 assignment ...
Submitting challenge05 code ...
Result Success
Score 6.00
Time 2.22

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

Once you have commited your work and pushed it to GitLab, member to create a merge request. Refer to the Reading 03 TA List to determine your corresponding TA for the merge request.