ITFE2_AE_Aufgaben

ITFE2_AE_Aufgaben

import java.util.*; //java.util.* enthält die Klasse: "Scanner". Deshlab ist sie notwendig!

public class Aufgaben //Klassennamen sind normalerweise groß geschrieben, um Klassen von Methoden zu unterscheiden zu können
{
    //Aufgabe: Primzahl ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    public static void primZahl() //Methodennamen sind normalerweise klein geschrieben.
    {
        System.out.print("Primzahlprüfung\nGanze Zahl eingeben: "); //Im Text (\n) bedeutet: (NewLine).
        
        long eingegebene_zahl = istLong(); //Variablen sind normalerweise auch klein geschrieben.
                                           //Die Methode "istLong()" prüft ob der Benutzer einen gültigen "long" Wert eingegeben hat, dann weist sie den Wert zu. In diesem Fall zur Variable (eingegebene_zahl).
        
        for (int i = 2 ; i*i < eingegebene_zahl ; i++) //Der Zähler i soll mit 2 anfangen, solange i^2 kleiner als (eingegebene_zahl) ist. Jedesmal soll der Wert von i auf 1 erhöht werden.
        {
            if (eingegebene_zahl%i == 0) //Hier wird geprüft, ob (eingegebene_zahl/i) einen Rest lässt, und ob dieser Rest gleich 0 ist.
            {
                System.out.println(eingegebene_zahl + " ist keine Primzahl.\nProgrammende Primzahl.");
                return; //Normalerweise benutzt man hier den Befehl (break;) um die Schleife abzubrechen aber in diesem Fall muss das Programm beendet werden, weil es schon klar ist, dass (eingegebene_zahl) keine Primzahl ist.
            }
        }
        
        System.out.println(eingegebene_zahl + " ist eine Primzahl.\nProgrammende Primzahl."); //Wenn die schleife durchgelaufen ist, ohne Teiler von (eingegebene_zahl) zu finden, dann ist (eingegebene_zahl) eine Primzahl.
    }//Ende: Methode primZahl()
    
    //Gehört zur Methode primZahl()
    public static long istLong() //Hier soll man den passenden Datentyp nicht vergessen
    {
        Scanner scan = new Scanner(System.in);
        if (scan.hasNextLong()) //Ob der Benutzer einen "long" Wert eingegeben hat.
            return scan.nextLong(); //Wenn ja, dann den Long-Wert zurückgeben.
        //Wenn es keine Klammer nach (if/else) gibt, wird NUR ein Befehlt ausgeführt. In diesem Fall, wenn der obige Fall true ist, wird die Methode mit dem Befehl (return) beendet und der übrige Code wird in dieser Methode nicht durchgeführt.
        //Ab hier wird nur durchgeführt, wenn die If-Klausel false ist.
        scan.close(); //Wenn nein, soll der Scanner geschlossen werden und die Methode nochmal aufgerufen werden, um den selben Vorgang zu wiederholen.
        System.out.println("Sie haben keine ganze Zahl eingegeben! Bitte versuchen Sie es nochmal...");
        return istLong(); //Die Methode wird nochmal aufgerufen um die Eingabe zu wiederholen.
    } //Ende: Methode istLong()
    //Ende: Aufgabe Primzahl ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    
    //Aufgabe: Summe +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    public static void summe()
    {
        System.out.print("Summenberechnung\nBitte geben Sie einen Grenzwert für die Summe ein: ");
        int grenzzahl = istInt(); // Zusächtliche Methode "istInt()" prüft ob der Benutzer einen gültigen "int" Wert eingegeben hat.
        Scanner scan = new Scanner(System.in); //Neuer Scanner für die Auswahl der Summenrechnung.
        System.out.println("Welche Summe möchten Sie nehmen?\nFür (1+2+3+4+...+n+...) drücken Sie A, a, oder 1.\nFür (1-2+3-4+5-...+(2n-1)-2n+...) drücken Sie B, b, oder 2.\nFür (1/1+1/2+1/3+...+1/n+...) drücken Sie C, c, oder 3.\nUnd für (1+2²+3²+4²+...+n²+...) drücken Sie D, d, oder 4.");
        char x = scan.next().charAt(0); //Befehl um den ersten Char im Scanner zu nehmen.
        switch (x)
        {
            case 'A':   
            case 'a':
            case '1': sumA(grenzzahl); return; //Hier werden die Fälle (A),(a), und (1) behandelt. Der Befehl (return) sorgt dafür, dass die Methode "summe()" hier beendet wird.
            case 'B':
            case 'b':
            case '2': sumB(grenzzahl); return;
            case 'C':
            case 'c':
            case '3': sumC(grenzzahl); return;
            case 'D':
            case 'd':
            case '4': sumD(grenzzahl); return;
            default : System.out.println("Falsche eingabe. Programm wird beendet."); return;
        }
    } //Ende: Methode summe()
    
    public static int istInt() //Gehört zur Methode summe()
    {
        Scanner scan = new Scanner(System.in);
        if (scan.hasNextInt())
            return scan.nextInt();
        
        scan.close();
        System.out.println("Sie haben keine ganze Zahl eingegeben! Bitte versuchen Sie es nochmal...");
        return istInt();
    } //Ende: Methode istInt()
    
    public static void sumA(int grenzzahl) //Gehört zur Methode summe()
    {
        int i,summe = 0;
        for (i = 1 ; summe < grenzzahl ; i++)
            summe+=i; //Das ist das selbe, wenn man schreibt: summe = summe + i;  also: (neuer Wert von summe) = (alter Wert von summe) + i;
        //Auch für (for) und (while) Befehle gilt, dass nur ein Befehl ausgeführt wird, wenn es keine Klammer gibt.
        
        System.out.println("SumA\nBerechnung der Summe 1+2+3+4+... bis zum Grenzwert: "+ grenzzahl +"\nNach "+ (i-1) +" Gliedern ist "+ grenzzahl +" erreicht. Die Summe ist "+ summe +".\nProgrammende SumA.");
    } //Ende: Methode sumA(int grenzzahl)
    
    public static void sumB(int grenzzahl) //Gehört zur Methode summe()
    {
        int i,summe = 0;
        for (i = 1 ; summe < grenzzahl ; i++)
        {
            if (i%2==0)
                summe-=i; //Bei gerade Zahlen: summe = summe - i; (also wenn i gerade ist).
            else
                summe+=i; //Bei ungerade Zahlen: summe = summe + i; (also, wenn i ungerade ist).
        }
        System.out.println("SumB\nBerechnung der Summe 1-2+3-4+... bis zum Grenzwert: "+ grenzzahl +"\nNach "+ (i-1) +" Gliedern ist "+ grenzzahl +" erreicht. Die Summe ist "+ summe +".\nProgrammende SumB.");
    } //Ende: Methode sumB(int grenzzahl)
    
    public static void sumC(int grenzzahl) //Gehört zur Methode summe()
    { //Mathe: Harmonische Reihe.   Für große Summen(grenzzahl), muss der Wert von dem Zähler (i) extrem groß sein. Deshalb werde ich den (grenzzahl auf 10) begrenzen.
        if (grenzzahl<=21)
        {
            int i;
            double summe = 0;
            for (i = 1 ; summe < grenzzahl ; i++)
                summe+=(1/(double)i); //summe = summe + (1/i) //Hier (double) [englischer Befehlsname: "casting"] bedeutet, dass (i) mit dem Int-Wert als Datentype (double) behandelt werden muss. Wenn man das nicht macht, werden die Nachkommastellen verloren gehen.
            System.out.println("SumC\nBerechnung der Summe 1/1+1/2+1/3+1/4+... bis zum Grenzwert: "+ grenzzahl +"\nNach "+ (i-1) +" Gliedern ist "+ grenzzahl +" erreicht. Die Summe ist "+ summe +".\nProgrammende SumC.");
        }
        else
            System.out.println("Die Grenzzahle für diese Summe ist zu hoch! Realistisch wird es sehr lange dauern bis die Summe gerechnet wird.\nProgramm wird abgebrochen.");
    } //Ende: Methode sumC(int grenzzahl)
    
    public static void sumD(int grenzzahl) //Gehört zur Methode summe()
    {
        int i,summe = 0;
        for (i = 1 ; summe < grenzzahl ; i++)
            summe+=(i*i); //summe = summe + (i*i);
        System.out.println("SumD\nBerechnung der Summe 1+2²+3²+4²+... bis zum Grenzwert: "+ grenzzahl +"\nNach "+ (i-1) +" Gliedern ist "+ grenzzahl +" erreicht. Die Summe ist "+ summe +".\nProgrammende SumD.");
    } //Ende: Methode sumD(int grenzzahl)
    //Ende: Aufgabe Summe +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    
    //Aufgabe: Teiler +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    public static void teiler()
    {
        System.out.print("Teiler\nGeben Sie eine Ganzezahl ein: ");
        int n = istInt(); //Methode istInt ist oben geschrieben. Prüft ob der User einen gültigen int-Wert eingegeben hat, und weist den Wert zu.
        if (n!=0)
        {
            System.out.print(n +" ist durch: 1 ");
            for (int i = 2 ; i <= Math.abs(n/2) ; i++)  //Math.abs() Java-Klasse: Math, Methode in dieser Klasse: abs() [englisch: Absolute Value] gibt den Absolutbetrag.
            {
                if (n%i==0)
                System.out.print(", "+ i + " "); //Mit jedem neuen Teiler, wird der neue Teiler und ein Leerzeichen geschrieben.
            }
            System.out.println("und "+ Math.abs(n) +" teilbar.\nProgrammende Teiler.");
        }
        else
            System.out.println("0 ist durch alle natürlichen Zahlen teilbar!");
    } //Ende: Methode teiler()
    //Ende: Aufgabe Teiler +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    //Aufgabe: Summe und Durchschnitt +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    public static void summeUndDurchschnitt()
    {
        int i = 1, summe = 0;
        System.out.println("Summe und Durchschnitt\nGeben Sie beliebige Anzahl von Zahlen ein. Geben Sie die 0 ein um die Berechnung durchzuführen:");
        int eingegebene_zahl = istInt(); //Methode istInt ist oben geschrieben. Prüft ob der User einen gültigen int-Wert eingegeben hat, und weist den Wert zu.
        while (eingegebene_zahl!=0) //Die Schleife endet, wenn der User 0 eingibt.
        {
            summe+=eingegebene_zahl; //summe = summe + eingegebene_zahl;
            i++;
            eingegebene_zahl = istInt();
        }
        System.out.print("Die Gesamtsumme ist: "+ summe +" und der Durchschnitt ist: ");
        if (i>0)
            System.out.println((double)summe/(double)i+ "\nProgrammende Somme und Durchschnitt."); //Casting to double... Damit die Nachkommastellen durch den int-Datentyp nicht verloren gehen.
        else
            System.out.print(0); //Wenn der User 0 als erste Zahl eingibt, soll nur die 0 angezeigt werden.
    } //Ende: Methode summeUndDurchschnitt()
    //Ende: Aufgabe Summe und Durchschnitt +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    
    //Aufgabe: Neue Summe +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    public static void summe_V2()
    {
        System.out.print("Summe_v2.0\nBitte geben Sie einen Grenzwert ein: ");
        int n = istInt(); //Methode istInt ist oben geschrieben. Prüft ob der User einen gültigen int-Wert eingegeben hat, und weist den Wert zu.
        Scanner scan = new Scanner(System.in);
        System.out.println("Welche Summe möchten Sie nehmen?\nFür (1²+2²+3²+4²+...+n²) drücken Sie A, a, oder 1.\nFür (1²+3²+5²+...+(2n-1)²) drücken Sie B, b, oder 2.\nFür (2²+4²+6²+...+(2n)²) drücken Sie C, c, oder 3.\nFür (1/1+1/2+1/3+...+1/n) drücken Sie D, d, oder 4.");
        char x = scan.next().charAt(0); //Der erste Char vom Scanner wird genommen.
        switch (x)
        {
            case 'A':
            case 'a':
            case '1': sumNa(n); return; //Die ersten drei Fälle werden hier behandelt.
            case 'B':
            case 'b':
            case '2': sumNb(n); return; //Die nächsten drei Fälle ... usw.
            case 'C':
            case 'c':
            case '3': sumNc(n); return; //return, damit das Programm beendet wird.
            case 'D':
            case 'd':
            case '4': sumNd(n); return;
            default : System.out.println("Falsche eingabe. Programm wird beendet."); return;
        }
    } //Ende: Methode summe_V2()
    
    public static void sumNa(int grenzzahl)
    {
        int i,summe = 0;
        for (i = 1 ; i <= grenzzahl ; i++)
            summe+=i*i;
        System.out.println("SumNa\nBerechnung der Summe (1²+2²+3²+4²+...+"+ grenzzahl +"²\nNach "+ (i-1) +" Gliedern ist die Summe "+ summe +"erreicht.\nProgrammende SumNa.");
    } //Ende: Methode sumNa(int grenzzahl)
    
    public static void sumNb(int grenzzahl)
    {
        int i,summe = 0;
        for (i = 1 ; i <= grenzzahl ; i++)
        {
            if (i%2!=0)
                summe+=i*i;
        }
        System.out.println("SumNb\nBerechnung der Summe (1²+3²+5²+...+"+ grenzzahl +"²\nNach "+ (i-1) +" Gliedern ist die Summe "+ summe +"erreicht.\nProgrammende SumNb.");
    } //Ende: Methode sumNb(int grenzzahl)
    
    public static void sumNc(int grenzzahl)
    {
        int i,summe = 0;
        for (i = 1 ; i <= grenzzahl ; i++)
        {
            if (i%2==0)
                summe+=i*i;
        }
        System.out.println("SumNc\nBerechnung der Summe (2²+4²+6²+...+"+ grenzzahl +"²\nNach "+ (i-1) +" Gliedern ist die Summe "+ summe +"erreicht.\nProgrammende SumNc.");
    } //Ende: Methode sumNc(int grenzzahl)
    
    public static void sumNd(int grenzzahl)
    {
        if (grenzzahl<=21)
        {
            int i;
            double summe = 0;
            for (i = 1 ; i <= grenzzahl ; i++)
                summe+=1/(double)i;
            System.out.println("SumNd\nBerechnung der Summe (1/1+1/2+1/3+...+1/"+ grenzzahl +"\nNach "+ (i-1) +" Gliedern ist die Summe "+ summe +"erreicht.\nProgrammende SumNd.");
        }
        else
            System.out.println("Die Grenzzahle für diese Summe ist zu hoch! Realistisch wird es sehr lange dauern bis die Summe gerechnet wird.\nProgramm wird abgebrochen.");
    } //Ende: Methode sumNd(int grenzzahl)
    //Ende: Aufgabe Neue Summe +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    
    //Aufgabe: Struktogramm
    public static void struktogramm()
    {
        boolean weiter = true;
        Scanner scan = new Scanner(System.in);
        do
        {
            System.out.println("Menü:\n\tFür \"Summe\" drucken Sie die 1.\n\tFür \"Quadrat\" drucken Sie die 2.\n\tFür \"Wurzel\" drucken Sie die 3.\n\tUm das Programm zu verlassen drucken Sie die 4.\n");
            char menüpunkt = scan.next().charAt(0);
            switch (menüpunkt)
            {
                case '1':
                {
                    System.out.print("Summe:\n\tEingabe: ");
                    int summe = 0, eingelesene_zahl = istInt();
                    for (int i=0 ; i <= Math.abs(eingelesene_zahl) ; i++)
                        summe+=i;
                    if (eingelesene_zahl>0)
                        System.out.println("\tDie Summe von 0 bis "+ eingelesene_zahl +" ist: "+ summe);
                    else
                        System.out.println("\tDie Summe von 0 bis "+ eingelesene_zahl +" ist: "+ (-summe));
                    break;
                }
                case '2':
                {
                    System.out.print("Quadrat:\n\tEingabe: ");
                    int eingelesene_zahl = istInt(), quadrat = eingelesene_zahl * eingelesene_zahl;
                    //System.out.println("\t"+ eingelesene_zahl +" Quadrat ist: "+ (int)quadrat);
                    break;
                }
                case '3':
                {
                    System.out.print("Wurzel:\n\tEingabe: ");
                    int eingelesene_zahl = istInt();
                    if (eingelesene_zahl > 0)
                    {
                        double w = Math.sqrt(eingelesene_zahl);
                        System.out.println("\tDie Wurzel von "+ eingelesene_zahl +" ist: "+ w);
                    }
                    else
                        System.out.println("\tZahl muss > 0 sein");
                    break;
                }
                case '4':   
                {
                    weiter = false;
                    //System.out.println("Tschüß!");
                    break;
                }
                default:    System.out.println("Fehler:\tFehleingabe!");
            }
            System.out.println();
        } while (weiter);
    }
    //Ende: Aufgabe Struktogramm
    
    
    public static void main() //MAIN METHODE
    {
        //primZahl();
        //summe();
        //teiler();
        //summeUndDurchschnitt();
        //summe_V2();
        //struktogramm();
    } //Ende: Main-Methode
} //PROGRAMMENDE