Dreiecke

Bei unserer Dreiecksaufgabe wird eine Zahl eingelesen. Diese Zahl muss 3 Bedingungen erfüllen: 1. sie muss größer oder gleich 3 sein 2. sie muss kleiner oder gleich 9 sein 3. sie muss ungerade sein

public class dreieck {
    public static void main(String[] args) throws Exception{
        int a = System.in.read();
        int input = a - '0';

        if(input >= 3 && input <= 9 && input % 2 == 1){
            // Zahl erfüllt die Bedingungen!
        }
    }
}

Ob eine Zahl gerade oder ungerade ist, lässt sich ganz einfach mit dem Modulo-Operator (%) herausfinden. Verwendet wird er wie in einem Bruch - mit dem Unterschied dass das Ergebnis der Rest der Division ist. z. B.: 3 % 2 = 1, 5 % 2 = 1, 4 % 2 = 0

Wenn die Zahl gültig ist, also mindestens eine 3 und höchstens eine 9 und zusätzlich eine ungerade Zahl ist, dann durchlaufen wir zwei verschachtelte Schleifen. (Eine Schleife steckt in einer anderen Schleife)

        int zeile = 4;
        int breite = 9;
        
        for(int y = zeile; y >= 0; y--){
            for(int x = 0; x < breite; x++){
                System.out.print('*');
            }
            System.out.println();
        }

Hier geben wir zu Testzwecken ein rechteckiges Feld aus '*'-Zeichen aus. (9 breit und 5 hoch) System.out.print() und System.out.println() unterscheiden sich in einem kleinen Detail: System.out.println() fügt der übergebenene Zeichenkette noch einen Zeilenumbruch hinzu.

Die Breite ist natürlich nicht immer 9, sondern soll den Wert der Eingabe erhalten. Das Gleiche gilt für die Variable 'zeile'. Sie soll die maximale Zeilenzahl repräsentieren, was der halben Breite entspricht (abgerundet!)

z. B. breite = 9 => zeile = breite / 2 (= 4.5 - da es aber int-Variablen sind und int nur Ganzzahlen kennt werden die Nachkommastellen einfach abgeschnitten => 4)

Warum 4? Ein Dreieck, das 9 Zeichen lang ist, ist doch 5 Zeilen hoch...

Ja richtig! Aber wir verwenden ja auch die 0 zum Zählen! (0, 1, 2, 3, 4 => 5 Zeilen)

        int breite = input;
        int zeile = breite / 2;

Wir wollen ja nicht immer ein Rechteck von '*'-Zeichen ausgeben, sondern ein Dreieck.

Das heißt, dass wir von unserem Rechteck links und rechts der Mitte einige Zeichen "wegnehmen" müssen um ein Dreieck zu erhalten. In der ersten Zeile müssen (bei einer Breite von 9) 4 Zeichen von links und 4 Zeichen von rechts Leerzeichen sein. Bei den nächsten nur noch jeweils 3, 2, 1, 0.

Dies erreichen wir durch die Variable y, die die aktuelle Zeile repräsentiert, wobei "ganz unten" 0 ist.

Hier wird überprüft, ob an der aktuellen Position (Variable x) nun ein '*' oder ein ' ' ausgegeben werden soll:

                if(x < y || x >= breite-y){
                    System.out.print(' ');
                } else {
                    System.out.print('*');
                }

Bei der Ausgabe von x sieht man sehr schön, wie die Positionen von links nach rechts verteilt sind:

    4    
   345   
  23456  
 1234567 
012345678

Wenn man y ausgeben lässt sieht man die aktuelle Zeile:

    4    
   333   
  22222  
 1111111 
000000000

Taschenrechner

Um unseren Taschenrechner das Rechnen mit allen vier Grundrechenarten beizubrigen, führen wir eine "Operatoren-id" ein: Wenn diese id (hier: int-Variable operator) z. B. 1 ist, soll addiert werden, bei einer 2 subtrahiert, etc.

        if(input == '+'){
            operator = 1;
        } else if (input == '-'){
            operator = 2;
        } else if (input == '*'){
            operator = 3;
        } else if (input == '/'){
            operator = 4;
        }

Durch diese "id" können wir nach dem Einlesen der zweiten Zahl durch eine switch oder if-Abfrage die richtige Rechenoperation ausführen :)

Nun aber erst einmal zum Einlesen der Zahlen:

        int input;
        int zahl1 = 0;

        while(true){
            input = System.in.read();
            if(input >= '0' && input <= '9') {
                zahl1 = zahl1 * 10 + (input-'0');
            } else if (input == '\n'){
                break;
            } else if (input == '\r') {
                // ignore
            } else {
                System.out.println("Ungültiges Zeichen!");
                return;
            }
        }

In dieser while-Schleife werden die übergebenen Zeichen als Dezimale Ganzzahl interpretiert. Da System.in.read() immer nur das vorderste Zeichen nimmt und es danach "weglegt", müssen wir dieses Zeichen in eine Zahl umwandeln (den Ascii-Wert von 0 abziehen) und zu der bereits existierenden Zahl (die mit 10 multipliziert wurde) addieren.

Dies sieht zwar auf den ersten Blick etwas seltsam aus, aber macht durchaus Sinn ;)

Beispieleingabe: 3720 Im ersten Durchlauf hat unsere Zahl den Wert 0. Dieser Wert bleibt auch 0 wenn sie mit 10 multipliziert wird. Addiert man nun die erste Zahl hinzu hat man 3!

Im zweiten Durchlauf is unsere Zahl 3. Mit 10 Multiplizieren => 30. 7 dazuaddieren: 37!

Im dritten Durchlauf multiplizieren wir 37 mit 10 und addieren anschließend 2 dazu: 372!

im vierten Durchlauf wird die 372 mit 10 multipliziert und eine 0 dazuaddiert, was den Wert aber bei 3720 belässt.

Fertig!

Kombinieren wir unsere bisherigen Errungenschaften erhalten wir auch schon ein (fast) fertiges Programm:

zahl1 einlesen
operator einlesen
zahl2 einlesen
operator auswerten
ergebnis ausgeben