class Aufgabe {
  public static void main(String[] args) {

    // Es gibt zwei Möglichkeiten die Fibunacci-Folge zu erstellen.
    // Dabei werden die ersten zwei Felder immer mit festen Werten definiert.
    //    Variante 1: F0 = 0; F1 = 1
    //    Variante 2: F0 = 1; F1 = 1
    // Alle Werte danach werden aber immer nach der gleichen Regel erstellt.
    //    FN = FN-2 + FN-1

    System.out.println("Iterativ:");
    iterativ(45);

    System.out.println("Rekursiv:");
    rekursiv(0, 1, 45);
  }

  /**
   * Ermitteln der Fibonaccizahlen mit einer iterativen Lösung.
   * @param fields Die Anzahl der Felder welche mit Fibonaccizahlen gefüllt werden sollen.
   */
  public static void iterativ(int fields) {

    // Initialisieren der Folge. Die Größe der Folge gibt die Anzahl der Fibonaccizahlen an.
    int[] fibonaccifolge = new int[fields];

    // Alle Felder der Folge initialisieren.
    // Die ersten zwei Zahlen müssen dabei fest definiert werden.
    // Die Felder werden dabei nach Variante 1 definiert.
    for(int i = 0; i < fibonaccifolge.length; i++) {
      if (i == 0 || i == 1) {
        fibonaccifolge[i] = i;
      } else {
        fibonaccifolge[i] = 0;
      }
    }

    // Für alle Felder danach kann dann eine Formel verwendet werden.
    for(int i = 2; i < fibonaccifolge.length; i++) {
      fibonaccifolge[i] = fibonaccifolge[i-1] + fibonaccifolge[i-2];
    }

    // Ausgeben der Fibonaccifolge.
    for(int i = 0; i < fibonaccifolge.length; i++) {
      System.out.println(fibonaccifolge[i]);
    }
  }

  /**
   * Ermitteln der Fibonaccizahlen mit einer iterativen Lösung.
   * @param a Der Wert des Felds FN-2.
   * @param b Der Wert des Felds FN-1.
   * @param max Die Anzahl der Fibonaccizahlen welche ermittelt werden sollen.
   * @return Die ermittelte Fibonaccizahl.
   */
  public static int rekursiv(int a, int b, int max) {

    // Der Beginn der Fibonaccifolge muss mit bestimmten Werten initialisiert werden.
    // Die Werte werden dabei mit den Werten aus Variante 1 initialisiert.
    if((a == 0 && b == 0) || (a == 0 && b == 1)) {
      a = 0;
      b = 1;
      max -= 2;
      System.out.println(a);
      System.out.println(b);
    }

    // Anzahl der Felder reduzieren.
    max--;

    // Ausgeben der aktuellen Fibonaccizahl.
    System.out.println((a + b));

    // Es werden so lange Fibonaccizahlen erstellt so lange noch Felder verfügbar sind.
    if(max > 0) {
      return rekursiv(b, a + b, max);
    } else {
      return a + b;
    }
  }
}