# Simple program, probably easy solution?

• 01-13-2011, 08:56 PM
falkon114
Simple program, probably easy solution? [SOLVED!]
My class' first assignment was to create a program that computes the hailstone sequence for an arbitrary number n. That was easy enough to do, heres my code:
Code:

```package assignment01; import java.io.*; import java.util.Scanner; /**  * This program computes hailstone sequence  *  * @author Sean Repanshek  * @version 1-10-2011  */ public class HailstoneSequence {         static Scanner scanner = new Scanner(System.in);         @SuppressWarnings("null")         public static void main(String[] args) throws IOException {                 Scanner s = null;                 int inputNum; // our variable to hold users number                 int numIterations = 1; // number of iterations to get to zero                 try {                         System.out.println("Enter an integer: ");                         inputNum = scanner.nextInt(); // get inputNum from user                         System.out.println("You entered " + inputNum);                         if (inputNum == 1) { // special case that inputNum is 1                                 numIterations = 0;                                 System.out.println("You entered 1");                                 System.out.println("Number of iterations: " + numIterations);                                 System.exit(inputNum);                         } else if (inputNum % 2 == 1) { // if inputNum is odd to start, terminate (assignment criteria)                                 System.out.println("You entered an odd num. Terminated.");                                 System.exit(inputNum);                                 s.close(); // stop scanner                         }                         while (inputNum != 1) { // so long as inputNum is larger than 1, do hailstone algorithm                                 if (inputNum % 2 == 1) { // if inputNum is odd, make even according to algorithm                                         inputNum = inputNum * 3 + 1;                                         numIterations++; // increase iterations.                                         System.out.println(inputNum);                                 }                                 inputNum = inputNum / 2; // inputNum is even, divide by 2 for next part of algorithm                                 numIterations++; // increase iterations                                 System.out.println(inputNum);                         }                 } finally {                         if (s != null) { // make sure everything terminates and                                 s.close(); // stop scanner                         }                 }                 System.out.println("Number of repetitions to zero: " + numIterations); // print iterations in algor.         } }```
So that works fine and dandy for computing an even integers Hailstone sequence. I"m sure there are redundancies in it, but this is the first real java program I've written :P

Now, my next part of the assignment is to figure out which integer is the largest that can be computed using this method before overflow happens with the int data type. using that as a rough template, I come out with:
Code:

```package assignment01; /**  * This program computes ...  *  * @author Sean Repanshek  * @version 1-10-2011  */ public class smallestHailstone {         public static void main(String[] args) {                 int inputNum = 2; // our variable to hold users number                 int nextNum = inputNum;                 while (inputNum > 0) { // so long as inputNum is larger than 1, do hailstone algorithm                         if (inputNum % 2 == 1) { // if inputNum is odd, make even                                                                                 // according to algorithm                                 inputNum = inputNum * 3 + 1;                         }                         else {                                 inputNum = inputNum / 2; // inputNum is even, divide by 2 for next part of algorithm                         }                                                                        nextNum = inputNum;                         inputNum++;                         System.out.println(nextNum);                         System.out.println(inputNum);                         //System.out.println("Smallest number not computable: " + nextNum);                 }                 } }```
and it definitely doesn't work. This is where I'm stumped... not quite sure what to do or how to go about increasing it until it hits overflow, and then prints the largest hailstone number that can be computed as an int.
Hints?
****Solved. I'll post the solution on the last post. ****
• 01-14-2011, 12:37 AM
Junky
I'm confused. In your post you mention finding the largest hailstone and yet your class is called smallestHailstone. Which is it?

In either case if you want to find largest/smallest then you will need an if statement somewhere: if current number is larger/smaller than previous value, reset previous value to current number.

Or maybe I still do not understand what you are trying to do. Then you need to explain yourself again.
• 01-14-2011, 03:47 AM
Prompt
Quote:

figure out which integer is the largest that can be computed using this method before overflow happens with the int data type
A easy brute force way is to do the following :

Psuedo-Code:
Code:

```do while not Done   long currentHailStoneNumber = getNextHailStoneNumber();   if(currentHailStoneNumber >= Integer.MAX_VALUE) output currentHailStoneNumber and quit```
• 01-14-2011, 06:31 AM
falkon114
Sorry about the confusion. The program is called "smallestHailstone" for this reason:
Quote:

From part #2 (make a program that x = 0 and y = -1, increment x++ until it's = to y) you should see that some integers cannot be computed in Java. This means that some Hailstone sequences cannot be properly computed using int variables in Java. You are to write an application that automatically determines the smallest integer that cannot have its Hailstone sequence computed using int variables.
When your application is run, it should print a message like the following message:
The integer (some integer here) cannot have its Hailstone sequence computed using int variables.
So i guess i was thinking i needed to do something different =/ guess i didn't understand the program, but that there is my assignment, which, i now assume, is probably different than my initial question. Sorry!
• 01-16-2011, 01:14 AM
falkon114
So i'm still lost as to what I need to do next... The input has helped, but i still don't quite understand what I need to change, and where to put what... My most recent attempt has lead to...
Code:

```package assignment01; public class largestHailstone {                 public static void main(String[] args) {                         int inputNum = 2; // our variable to hold users number                         //int count = 1;                         if (inputNum > 0) {                                 inputNum++;                                                 while (inputNum != 1) { // so long as inputNum is larger than 1, do hailstone algorithm                                 //inputNum++;                                 //count++;                                 if (inputNum < 0) {                                         break;                                 }                                 if (inputNum % 2 == 1) { // if inputNum is odd, make even                                                                                         // according to algorithm                                         inputNum = inputNum * 3 + 1;                                 }                                 else {                                         inputNum = inputNum / 2; // inputNum is even, divide by 2 for next part of algorithm                                 }                                 System.out.println (inputNum);                         }                         //System.out.println (inputNum);                                 }         } }```
As you can see, it's quite a mess with all my attempts at controlling new variables, and placing things in different spots.
• 01-16-2011, 08:57 AM
JosAH
Suppose a current number n in the sequence still fits in an int. If it is even then n/2 also fits in an int but possibly 3*n+1 doesn't fit in an int. This is true if n > (Integer.MAX_VALUE-1)/3. Check for that value when n is odd and you're done.

kind regards,

Jos
• 01-18-2011, 09:31 PM
falkon114
Solved solved solved. Here's the code we were looking for...
Code:

```public class largestHailstone {         public static void main(String[] args) {                 int inputNum = 1;                 int nextNum = inputNum;                 while (true) {                         inputNum = nextNum; //assign the variable being computed to the next integer                         while (inputNum != 1) { // so long as inputNum is larger than 1, do hailstone algorithm                                 if (inputNum % 2 == 1) { // if inputNum is odd, make even according to algorithm                                         inputNum = inputNum * 3 + 1;                                 }                                 inputNum = inputNum / 2; // inputNum is even, divide by 2 for next part of algorithm                                 if (inputNum < 0) {                                         System.out.println("The first number that cannot have its Hailstone computed is: " + nextNum + ".");                                         System.exit(0);                                        }                         }                         nextNum++; //increase next number for Hailstone computation.                 }         } }```