Lösungsverschlag zu Aufgaben Rekursion und Iteration

public class exponentialreihe
{
    //iterative berechnung exponentialreihe
    public double exp(double x, int k) {
        //Initialisierung vars
        double zaehler = x;
        double nenner = 1;
        double erg = 0;

        // e hoch 0 ist immer 1
        if (x == O) {
            return 1;
        }

        //solange i kleiner gleich k, summiere Summanden bestehend aus Brüchen
        for (int i=0; i <= k; i++) {
            if (i == 0) {
                nenner *= 1;
            }
            else {
                nenner *= i;
            }
            zaehler *= zaehler;

            erg += zaehler / nenner;
        }

        return erg;
    }
}

//Sinus - berechnen
public double sin(double x, int k){
    double zaehler;
    double nenner=1;
    double erg=1;
    
    //sinus von 0 ist 0
    if (x == 0) {
        return 0;
    }
    
    for (int i=1; i <= k; i++){
        zaehler =x;
        //definiere den zähler, nach der regel i*2+1
        for (int j=2; j <= i*2+1; j++) {
            zaehler *= x;
        }
        //nenner ist fakultät
        nenner *= i;
        //wenn i gerade wird addiert, wenn ungerade wird subtrahiert
        if (i % 2 == 0) {
            erg += zaehler / nenner;
        }
        else {
            erg -= zaehler / nenner;
        }
    }
    
    return erg;
    
}

    //Cosinus - berechnen
    public double cos(double x, int k){
        double erg = 1;
        double nenner=1;
        double zaehler;

        for (int i=1; i <= k; i++){
            zaehler =x;
            //definiere den zähler, nach der regel i*2
            for (int j=2; j <= i*2; j++) {
                zaehler *= x;
            }
            //berechne nenner
            nenner *= (i+1) * (2*i);

            //wenn i gerade wird addiert, wenn ungerade wird subtrahiert
            if (i % 2 == 0) {
                erg += zaehler / nenner;
            }
            else {
                erg -= zaehler / nenner;
            }
        }        
        return erg;        
    }

public class Zahlensummen
{
    //summe ungerade zahlen - rekursiv   
    public long berechneSummeUngeraderZahlen(int n) {
        //Basisfall
        if (n == 0) {
            return 0;
        }
        else {
            //rekursive aufrufe
            if (n % 2 == 1) {
                return n + berechneSummeUngeraderZahlen(n-1);
            }
            if (n % 2 == 0) {
                return  0 + berechneSummeUngeraderZahlen(n-1);
            }
        }
        return 0;
    }

    //summe gerade zahlen - rekursiv   
    public long berechneSummeGeraderZahlen(int n) {
        //Basisfall
        if (n == 0) {
            return 0;
        }
        else {
            //rekursive aufrufe
            if (n % 2 == 0) {
                return n + berechneSummeGeraderZahlen(n-1);
            }
            if (n % 2 == 1) {
                return  0 + berechneSummeGeraderZahlen(n-1);
            }
        }
        return 0;
    }
    
    //summe gerade zahlen - iterativ   
    public long berechneSummeGeraderZahlen_it(int n) {
        long erg=0;
        if (n == 0 || n == 1) {
            return 0;
        }
        for(int i = 2; i <= n; i++) {    
            if (i % 2 == 0) {
                erg += i;
            }
        }
        return erg;
    }
    
    
}

public class Kubikzahl
{
    public long berechneSummeKubikZahlRekursiv(int n) {
        //Basisfall
        if (n == 0) {
            return 0;
        }
        //rekursiver Aufruf
        return (n * n * n) + berechneSummeKubikZahlRekursiv(n-1);        
    }
    
    public long berechneSummeKubikZahlIterativ(int n) {
        long erg = 0;      
        //falls n = 0, gege 0 zurück
        if (n == 0) {
            return 0;
        }
        //von 1 bis einschließlich n, summiere i hoch 3 
        for (int i=1; i <= n; i++){
            erg +=  i * i * i;
        }
        
        return erg;
    }
}

    public double qRekursiv(double x, int n) {
        //Basisfall
        if (n == 0) {
            return x;     
        }
        //rekursiver Aufruf  
        return (3.0 * qRekursiv(x, n-1) / qRekursiv(x, n-1) - 2.0 ) + (x * qRekursiv(x, n-1));
    }

public class Zahlenfolgen
{
    

    public double qIterativ(double x, int n) {
        double tmperg = x;
        //wenn n gleich 0 gebe direkt x aus
        if (n == 0) {
            return x;
        }
        
        //berechne folge iterativ
        for (int i=1; i <= n; i++){           
            tmperg = 3.0 * tmperg / tmperg - 2+ x * tmperg;     
        }
        return tmperg;
    }

    public double qRekursiv(double x, int n) {
        //Basisfall
        if (n == 0) {
            return x;     
        }
        //rekursiver Aufruf  
        return ((3.0 * qRekursiv(x, n-1) / qRekursiv(x, n-1)) - 2.0 ) + (x * qRekursiv(x, n-1));
    }

    
    
    public double[] qArray(double x, int n){
        double[] ergArray = new double[n+1];
        double tmperg = x;
        //berechne folge iterativ
        for (int i=0; i <= n; i++){           
            if (i == 0) {
                ergArray[0] = x;
            }
            else {
            tmperg = 3.0 * tmperg / tmperg - 2+ x * tmperg;
            ergArray[i] = tmperg;
            }
        }
      
        return ergArray;
    }
    
}

public class Palindrome
{
    public boolean pruefePalindromIterativ(char[] text, int a, int b){
        //Exception erstellen wenn index wert b größer = text länge, oder b - a kleiner gleich 0
        if ( b-a <= 0 || text.length <= b || a < 0 || b < 0) {
            throw new IllegalArgumentException("Falsche Indexwerte!");
        }
        for (int i = 0; a+i < b-i; i++) {
           if (text[a+i] != text[b-i]) {
               return false;
           }
        }
        return true;
    }

 double nenner=1;

 for (int i=1; i <= k; i++){
        //nenner berechnen
        nenner *=  (2*i) * (2*i + 1);
 }

    public boolean pruefePalindromRekursiv(char[] text, int a, int b)
    {
  
        if (b <= a)
        // Basisfall
        {
            return true;
        }
        else
        // Rekursionsfall
        {
            return (Character.toUpperCase(text[a]) == Character.toUpperCase(text[b])) ?
                    pruefePalindromRekursiv(text, ++a, --b) :
                    false;
        }
    }

public long multipliziere (long a, long b) throws IllegalArgumentException {
        
        if (a < 0 | b < 0) {
            throw new IllegalArgumentException();
        }
        
        if (b == 0) {
            return 0;
        }
        
        return a + multipliziere (a, b-1);
    }

     /**
     * Berechnet Iterativ eine gegebene Funktion
     * @param n Erwartet einen integer wert >0
     */
    public long tIterativ(int n)
    {
        //Initialisiert eine Variable in der gezählt wird setzt gleichzeitig t(0) auf 0
        long ausgabe=0; 
        //Prüft ob eingabedaten Korrekt sind
        if(n<0)
        {
            System.out.println("Falsche Eingabe!");
        }
        //For Schleife die aufsteigend Iteriert bis i<n+1
        for(int i=1; i<n+1;i++)
        {
            //Prüft ob i durch 3 teilbar ist
            if(i%3==0)
            {
                // Setzt die ausgabe auf t(n/3)+2
                ausgabe= (i/3)+2;
            }
            
            else
            {
                // Setzt die Ausgabe auf 2*t(n-1)
                ausgabe=2*ausgabe;
            }
        }
        //Liefert das Ergebnis
        return ausgabe;
    }

public long tRekursiv(int n)
    {
      
        if(n<0)
        {
           throw new IllegalArgumentException
        }
       //Basisfall
       if(n<=3)
        {
           return 3;
        }
       //Weitere Unterscheidung nach Teilbar durch 3
      if(n%3==0)
      {
         return tRekursiv(n/3)+2;
      }
      else
      {
        return 2* tRekursiv(n-1);
      }
    }

    /**
     * Berechnet Iterativ eine gegebene Funktion
     * @param n Erwartet einen integer wert >0
     */
    public long tIterativ(int n)
    {
        //Initialisiert eine Variable in der gezählt wird setzt gleichzeitig t(0) auf 0
        int[] test = new int[n+1];
        for(int i=0; i<=3; i++)
        {
            test[i]=3;
        }
            
        //Prüft ob eingabedaten Korrekt sind
        if(n<0)
        {
            System.out.println("Falsche Eingabe!");
        }
        //For Schleife die aufsteigend Iteriert bis i<n+1
        if(n<=3)
        {
            return 3;
        }
        for(int i=4; i<n+1;i++)
        {
            //Prüft ob i durch 3 teilbar ist
            if(i%3==0)
            {
                // Setzt die ausgabe auf t(n/3)+2
                test[i-1]=test[(i-1)/3]+2;
            }
            
            else
            {
                // Setzt die Ausgabe auf 2*t(n-1)
                test[i-1]=2*test[i-2];
            }
        }
        //Liefert das Ergebnis
        return test[n-1];
    }