Project 3 -- The Three-Halves Problem

Project 3 -- Three-Halves Problem

25 points

This is one of four major individual assignments that you are required to complete in this class. You MUST design and code this project on your own. You can ask for debugging help, particularly from the tutors, TA or instructor, but this project is to be your own work. The project relies on knowledge and skills that you will develop in Recitation Laboratories 1-8. If you are having trouble with these recitations after your in-class session, please be sure that you come to the lab at another time and sit down with a tutor.

Objectives:

Try out a step-wise software development process, in which you write code for the lowest-level object first and test it with a driver main before proceeding.
Design two classes and test them from a driver class
Write more complicated methods
Use the Comparable interface and compareTo to find the maximum element in an array
Work with Strings

Overview:

There is a famous mathematical property of integers, almost like a game one can play:

The Three-Halves Problem
Start with any positive integer `n`, and carry out Step 2, a replacement step. if `n` is odd then replace `n` by `(3n+1)/2` else if `n` is even then replace `n` by `n/2`. Repeat Step 2 over and over again until a `1` appears. If no `1` appears, repeat Step 2 indefinitely.

For example, if we start with n=17, the game produces the following sequence of integers, called a run, of length 10:

17, 26, 13, 20, 10, 5, 8, 4, 2, 1

In this case and in every other case that individuals have tried, the sequence reaches 1, and repeats 2, 1, 2, 1, ... indefinitely, so once 1 is reached, the sequence is regarded as at an end. In calculating the length, the initial number counts, and numbers count up to and including the first time 1 is reached. (Check that 1 is replaced by 2 and then by 1, so nothing more happens after one of these sequences gets to 1.) Researchers conjecture that the sequence converges to 1 for any starting positive integer n, but no one has ever been able to prove this. For this assignment, you are to write a program to investigate this game and to practice with features of Java. The work should proceed in three phases.

Phase I: Initial Software Development Strategy:

Initially you should implement the basic run from an initial integer to 1. To do this write a class ThreeHalvesRun with the following outline:

Data members:
- int myN;
  Initial integer for the run.
- int myRunLen;
  Length of run, including intial integer and final 1.
- int myMaxValue;
  Max integer that occurs in run; might be myN.
Constructor:
- public ThreeHalvesRun(int n)
  Initial integer for the run. Could call run() to initialize.
Methods:
- public void run()
  Chase down the run, counting as you go (to calculate myRunLength), and calculating myMaxValue as you go. You could call this in the constructor.
- public void runPrint()
  Same as run(), except that myRunLength and myMaxValue are already calculated, and this is to print the integer values, 10 to a line, starting with a tab character ("\t")as shown below.
- public String toString()
  return a string with the three data members in it.

There should also be a ThreeHalvesTest class that reads an integer n, creates an instance of ThreeHalvesRun with input n, and uses the toString and an explicit call to runPrint to print the run. The output after reading 27 could look as follows:


Project 3, Phase I: Simple run from initial integer
Enter integer ---> 27
Initial integer: 27, Length: 71, Maximum value: 4616
        27, 41, 62, 31, 47, 71, 107, 161, 242, 121,
        182, 91, 137, 206, 103, 155, 233, 350, 175, 263,
        395, 593, 890, 445, 668, 334, 167, 251, 377, 566,
        283, 425, 638, 319, 479, 719, 1079, 1619, 2429, 3644,
        1822, 911, 1367, 2051, 3077, 4616, 2308, 1154, 577, 866,
        433, 650, 325, 488, 244, 122, 61, 92, 46, 23,
        35, 53, 80, 40, 20, 10, 5, 8, 4, 2,
        1

Phase II: Finding the longest run for any integer up to a limit:

For this phase you should start in a new folder with new copies of the classes from Phase I. Your program should examine all runs for integers less than an initial value n. From among all these runs, the program should find the one with the longest run length (first occurrence).

You should modify your class ThreeHalvesRun as follows:

Interface: now it must "implement Comparable"
Data members: the same as before.
Constructor: the same as before.
Methods:
- public void run()
  The same as before.
- public String runString()
  Similar to the earlier runPrint(), except that instead of printing, just concatenate the same characters in a string and return the string.
- public String toString()
  return a string with the three data members in it, along with the String returned by runString()
- public int compareTo(Object d)
  Do the comparison based on the run length, that is, myRunLen.

There should be a new class ThreeHalves with just a few things in it:

Data member:
- public ThreeHalvesRun[] runs;
  Array to hold results.
Constructor:
- public ThreeHalves(int n)
  Allocate the array. For each integer i with i < n, allocate a ThreeHalvesRun class and store into runs[i]. (You can't do this for i == 0, so store runs[1] into runs[0] just to make things tidy.
Method:
- public ThreeHalvesRun[] getRunsArray()
  Return array of results that was calculated in the constructor.

Finally, as before, there should also be a ThreeHalvesTest class, with a main method that reads an integer n, creates an instance of ThreeHalves with input parameter n. Then it should fetch the array created by ThreeHalves, and pass the array to a static method:

public static Comparable findMax(Comparable[] c)
Uses compareTo to find the largest element of the input array. In this case of course, you are finding the integer less than n with the longest run length. You should print out the information about this run, including the initial integer, the run length, the maximum value, and then the actual run with 10 items printed per line, and with commas in between items.

Notice that in this case the above static method would find the maximum element in any array that implements the Comparable interface.

The output after reading 28 should be the same as above, since it gives the integer less than 28 producing the longest run, and this will be 27. In fact all integers up to 55 keep giving 27 as the answer, but 55 gives 54 as an answer, since there is a run of length 72 starting with 54.

Entering 1000 should produce:


Project 3, Phase II: Longest run of any integer less than initial integer
Enter integer ---> 1000
Initial integer: 871, Length: 114, Maximum value: 95498
        871, 1307, 1961, 2942, 1471, 2207, 3311, 4967, 7451, 11177,
        16766, 8383, 12575, 18863, 28295, 42443, 63665, 95498, 47749, 71624,
        35812, 17906, 8953, 13430, 6715, 10073, 15110, 7555, 11333, 17000,
        8500, 4250, 2125, 3188, 1594, 797, 1196, 598, 299, 449,
        674, 337, 506, 253, 380, 190, 95, 143, 215, 323,
        485, 728, 364, 182, 91, 137, 206, 103, 155, 233,
        350, 175, 263, 395, 593, 890, 445, 668, 334, 167,
        251, 377, 566, 283, 425, 638, 319, 479, 719, 1079,
        1619, 2429, 3644, 1822, 911, 1367, 2051, 3077, 4616, 2308,
        1154, 577, 866, 433, 650, 325, 488, 244, 122, 61,
        92, 46, 23, 35, 53, 80, 40, 20, 10, 5,
        8, 4, 2, 1

Phase III: Finding the maximum value in any run for any integer up to a limit:

For this phase it would probably be best to start in a new folder with new copies of everything, but if everything has been done correctly, all you need to is replace the compareTo method in the ThreeHalvesRun class, so that comparisons are based on the maximum value, rather than on the length of run. (Thus you could just carefully comment out the old compareTo method and put in a new one.)

Notice that with just the change of the single method in a single class, one is answering a completely different question:

What is the maximum value attained in any run for any integer less than some limit integer?

This time entering any number less than 256 should produce the answer integer 27 with maximum length 4616. However, initial number 256 produces the result:


Project 3, Phase III: Maximum value in any run less than initial integer
Enter integer ---> 256
Initial integer: 255, Length: 33, Maximum value: 6560
        255, 383, 575, 863, 1295, 1943, 2915, 4373, 6560, 3280,
        1640, 820, 410, 205, 308, 154, 77, 116, 58, 29,
        44, 22, 11, 17, 26, 13, 20, 10, 5, 8,
        4, 2, 1

Here the run length is much shorter than for 27, but the maximum value is larger.

Notice also that there are other integers between 27 and 255 with maximum value 4616, but your software is supposed to produce the first (smallest) one.

If 1000 is entered, the result is:


Project 3, Phase III: Maximum value in any run less than initial integer
Enter integer ---> 1000
Initial integer: 703, Length: 109, Maximum value: 125252
        703, 1055, 1583, 2375, 3563, 5345, 8018, 4009, 6014, 3007,
        4511, 6767, 10151, 15227, 22841, 34262, 17131, 25697, 38546, 19273,
        28910, 14455, 21683, 32525, 48788, 24394, 12197, 18296, 9148, 4574,
        2287, 3431, 5147, 7721, 11582, 5791, 8687, 13031, 19547, 29321,
        43982, 21991, 32987, 49481, 74222, 37111, 55667, 83501, 125252, 62626,
        31313, 46970, 23485, 35228, 17614, 8807, 13211, 19817, 29726, 14863,
        22295, 33443, 50165, 75248, 37624, 18812, 9406, 4703, 7055, 10583,
        15875, 23813, 35720, 17860, 8930, 4465, 6698, 3349, 5024, 2512,
        1256, 628, 314, 157, 236, 118, 59, 89, 134, 67,
        101, 152, 76, 38, 19, 29, 44, 22, 11, 17,
        26, 13, 20, 10, 5, 8, 4, 2, 1

Deliverables:

Phase I (7 points): Listings of ThreeHalvesRun.java and ThreeHalvesTest.java, along with runs for input integers 27, 11111, and some number of your choosing between 11111 and 113383 (see comments below).
Phase II (10 points): Listings of new versions of the sources ThreeHalvesRun.java and ThreeHalvesTest.java, along with a listing of the new source ThreeHalves.java. Include runs for input integers 1000, 22222, and some number of your choosing between 22222 and 113383 (see comments below).
Phase III (5 points): If the only change you made was to the method compareTo inside ThreeHalvesRun, then the source for that method is the only source you need. You should include runs for 1000, for 33333, and some number of your choosing between 33333 and 113383 (see comments below).
Question 1 below (3 points)
Questions 2 and 3 below (bonus points)

Questions:

Can you think of an intuitive reason why the sequence eventually reaches 1?
What is the "mysterious overflow number" described in the comments below?
(Hard) What happens if odd integers n are replaced by (5n + 1)/2 instead of (3n + 1)/2 in the three-halves run? (You would really have to experiment in order to answer this.)

Other Comments:

For initial numbers less than or equal to 113 382, the largest value in any run is already attained using initial number 77 671, which gives length 149, but maximum value 785 412 368. Since this was obtained after dividing by 2, internally the largest value appearing is 1 570 824 736. Calculations involving 113 383 result in integer overflow for 32-bit integers, that is, larger than 2³¹ - 1 = 2 147 483 647. In C, C++, or Java, one can use double type for calculations. This effectively gives exact integer arithmetic up to size 52 bits. In Java one can also use the long type, giving 64-bit integers. Finally, Java has the BigInteger class that provides integers of arbitrary size. You could try one of these methods to discover the mysterious overflow number in the run starting with 113 383.