Example: Ulam sequence

The Ulam Sequence

A mathematician named Ulam proposed a sequence of numbers starting at any positive integer n (n > 1):

Here are some examples for the first few integers.

   2 ->  1
   3 -> 10 ->  5 -> 16 ->  8 ->  4 ->  2 ->  1
   4 ->  2 ->  1
   5 -> 16 ->  8 ->  4 ->  2 ->  1
   6 ->  3 -> etc as for 3 above.
   7 -> 22 -> 11 -> 34 -> 17 -> 52 -> 26 -> 13 -> 40 -> 20 -> 10 -> 5 -> see 5 above.

This is a well known problem. See The 3x+1 problem and its generalizations for more information.

Does every sequence stop? It's unknown if all sequences end at 1. Perhaps there are sequences that get into a loop, or increase indefinitely.

Programming 1 - Write a loop that shows the Ulam sequence

Write a loop that reads an integer n (in range 1 - 1000) and computes and displays the values in the sequence.

Solution using dialog I/O

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
 48 
 49 
 50 
 51 
// File   : ulam/Ulam0Dialog.java
// Purpose: Compute Ulam sequence.  Uses dialog I/O,
// Author : Fred Swartz
// Date   : 2006-04-20

import javax.swing.*;

public class Ulam0Dialog {

    public static void main(String[] args) {

        while (true) {
            //... Read an int.  Quit if there is no input.
            String inputLine = JOptionPane.showInputDialog("Enter a number"
                                              + " between 1 and 1000");
            if (inputLine == null) {
               break;
            }
            int n = Integer.parseInt(inputLine);

            //... Make sure it's in the correct range.
            if (n > 0 && n <= 1000) {

                //... Initialize variables.
                int count = 0;
                String result = "" + n;

                //... Loop until n gets to the value 1
                while (n > 1) {
                    if (n%2 == 0) {  // if even
                        n = n / 2;
                    } else {         // if odd
                        n = 3 * n + 1;
                    }

                    //... Build output string.
                    count++;   // Count number of elements.
                    //... Start a new line every 20 numbers
                    if (count % 20 == 0) {
                        result = result + "\n";
                    }
                    result = result + " " + n;
                }

                //... Display result
                JOptionPane.showMessageDialog(null, "\nSequence = " + result
                     +  "\nElements in sequence = " + count);
            }
        }
    }
}

Solution using console I/O

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 
 40 
 41 
 42 
 43 
 44 
 45 
 46 
 47 
// File   : ulam/Ulam0Console.java
// Purpose: Compute Ulam sequence.
// Author : Fred Swartz
// Date   : 2006-04-20

import java.util.*;

public class Ulam0Console {

    public static void main(String[] args) {
        //... Initialization.
        Scanner in = new Scanner(System.in);

        System.out.println("Enter a number between 1 and 1000");
        while (in.hasNextInt()) {
            int n = in.nextInt();

            //... Make sure it's in the correct range.
            if (n > 0 && n <= 1000) {

                //... Initialize variables.
                int count = 0;           // Number of elements in the sequence.
                String result = "" + n;  // Build output string here.

                //... Loop until n gets to the value 1
                while (n > 1) {
                    if (n%2 == 0) {  // if even
                        n = n / 2;
                    } else {         // if odd
                        n = 3 * n + 1;
                    }

                    //... Build output string.
                    count++;   // Count number of elements.
                    if (count % 20 == 0) {
                        result = result + "\n";  // New line every 20 numbers.
                    }
                    result = result + " " + n;   // Append to end of result.
                }

                //... Display result
                System.out.println("Sequence = " + result
                     +  "\nElements in sequence = " + count);
            }
        }
    }
}