Stanislav Ulam

Wählen Sie eine beliebige positive Zahl, die größer als 1 ist. und führen Sie den folgenden Algorithmus durch:

Wiederhole
     wenn Zahl gerade dann halbiere sie
     sonst nimm sie mal 3 und füge 1 hinzu

Nehmen wir als Startwert 3, so ergibt sich folgende Folge:

3 - 10 - 5 - 16 - 8 - 4 - 2 - 1 - 4 - 2 - 1 - 4 - 2 - 1....

Eigentlich können wir bei 1 aufhören, da sich danach die Zahlen 4 - 2 - 1 immer wieder wiederholen.

Für die Startzahl 23 erhalten wir die Zahlenfolge:

23 - 70 - 35 - 106 - 53 - 160 - 80 - 40 - 20 - 10 - 5 - 16 - 8 - 4 - 2 - 1

Das eigenartige an diesen nach unserer Spielregel erzeugten Zahlenfolge ist, dass sie Zahlen liefert, die mal größer mal kleiner ohne, ohne dass eine Regel für das Auf und Ab gefunden werden könnte. Auch dass alle bekannten Folgen irgendwann auf die 1 stoßen wirkt überraschend. Für die Vermutungen, dieser Zahlenfolgen betreffend hat man bis heute noch keinen mathematischen Beweis gefunden.  Benannt wird diese Folge nach ihrem Erfinder, dem Mathematiker Ulam. Was ist nahe liegender, als die Zahlen einer Ulamfolge durch ein Programm errechnen zu lassen.

Der eigentliche Algorithmus zur Berechnung der Folgengleider ist nicht sehr schwer:

if (i % 2 ==0){
  i = i/2;
}
else{
  i = i*3+1;
}

while (i != 1){
  if (i % 2 ==0){
    i = i/2;
  }
  else{
    i = i*3+1;
  }
}

Fehlt noch die Einbindung in ein lauffähiges Programm. Wir verwenden dazu die folgende Vorlage:
 

public class Ulam {

  public static void main (String[] args) {
     //hier kommt der 'eiogentliche' Programmkode hin
  }
}

public class Ulam {

  public static void main (String[] args) {
    int i = 23;
    while (i != 1){
      if (i % 2 ==0){
        i = i/2;
      }
      else{
        i = i*3+1;
      }
      System.out.println(i);
    }
  }
}

int i = 23;

die wir auch ausführlicher in zwei Zeilen:

int i;
i = 23;

hätten schreiben können, wird eine Variable vom Typ int deklariert und mit dem Wert 23 initialisiert. Die zweite markierte Zeile

System.out.println(i);

veranlasst, dass der Wert von i, der bei jedem Schleifendurchgang einmal berechnet wird auch ausgegeben wird. So können wir das Verhalten der Folgenglieder beobachten. In unserem Fall ergeben sich als Ausgabewerte:

70 - 35 - 106 - 53 - 160 - 80 - 40 - 20 -10 - 5 - 16 - 8 - 4 - 2 - 1
 

import info1.*;
public class Ulam {

  public static void main (String[] args) {
    System.out.print("Ganze Zahl > 1: ");
    int i = Console.in.readInt();        
    while (i != 1){
      if (i % 2 ==0){
        i = i/2;
      }
      else{
        i = i*3+1;
      }
      System.out.println(i);
    }
  }
}

Ein weiteres Beispiel:
 

Diese Definition lässt sich leicht in ein Struktogramm mit einer einfachen Verzweigung übersetzen:

Schließlich übersetzen wir die dargestellte Struktur in Javacode:

if (x >= 0){
  System.out.println("abs("+x+") = "+x);
}
else {
  System.out.println("abs("+x+") = "+(-x));
}

Die Ausgabe in den beiden Zweigen ist einfach zu lesen. Wir erinnern uns, System.out.println(...) gibt das aus, was in den Klammern steht . Das hier rot innerhalb der "-Zeichen geschriebene Text wird so ausgegeben, wie er geschrieben ist. Die x bzw. -x sind Variabel mit einem bestimmten Wert. Sie sind nicht in Anführungsstrichen geschrieben, es wird also nicht x bzw. -x  sondern die Werte von x und -x auf den Bildschirm ausgegeben. Die Teilausgaben werden mit dem +-Zeichen zusammengehängt, oder wie wir im Fachjargon gerne sagen, konkateniert.
 

import info1.*;
public class DemoAbs {

  public static void main (String[] args) {
    System.out.print("Geben Sie eine ganze Zahl ein: ");
    int x = Console.in.readInt();
    if (x >= 0){
      System.out.println("abs("+x+") = "+x);
    }
    else {
      System.out.println("abs("+x+") = "+(-x));
    }
  }
}

import info1.*;
public class DemoMax2 {

  public static void main (String[] args) {
    System.out.print("Geben a ein: ");
    int a = Console.in.readInt();
    System.out.print("Geben b ein: ");
    int b = Console.in.readInt();
    int max;
    if (a>=b){
      max = a;
    }
    else{
      max = b;
    }
    System.out.println("Max("+a+","+b+") = "+max);
  }
}

Wir betrachten nun eine kleine Variante. Es soll die sie größte von drei eingegebenen Zahlen bestimmt werden. Das Struktogramm sieht jetzt so aus, wie es rechts dargestellt ist.

Nach der Eingabe von drei Zahlen a, b und c, hier im Struktogramm nicht dargestellt, wird zunächst die größere der ersten beiden bestimmt und in max gespeichert. Danach wird geprüft ob die dritte Zahl vielleicht noch größer ist als max und gegebenenfalls wird max mit dem Wert von c überschritten. Ist c dagegen kleiner als das zuerst berechnete Maximum, muss nichts mehr berechnet werden. Der Zweig bleibt leer.
 

import info1.*;
public class DemoMax3 {

  public static void main (String[] args) {
     System.out.print("Geben a ein: ");
     int a = Console.in.readInt();
     System.out.print("Geben b ein: ");
     int b = Console.in.readInt();
     System.out.print("Geben c ein: ");
     int c = Console.in.readInt();
     int max;
     if (a>=b){
       max = a;
     }
     else{
       max = b;
     }
     if (c>max){
       max = c;
     }
     System.out.println("Max("+a+","+b+","+c+") = "+max);
  }
}