ASCII-Zeichnungen

ASCII¹-Zeichnungen sind eine ausgezeichnete Möglichkeit, um Programmieranfängern auf relativ einfache Weise das Prinzip algorithmischen Denkens zu vermitteln.

Der Quelltext eines Programms sollte i.A. so einfach, allgemein und universell wie möglich gehalten sein und sein Aufbau sowie der Verlauf des Programms selbst sollten so erfolgen, dass Erweiterungen und Varianten möglichst einfach zu implementieren sind und dabei eine einfache Lesbarkeit des Quelltextes gewährleistet bleibt.

Anhand von ASCII-Zeichnungen lässt sich dies gut demonstrieren bzw. üben. Hierbei handelt es sich um kleine Zeichnungen, die aus Tastatur-Zeichen¹ bestehen und dadurch Zeile für Zeile auf einer Konsole ausgegeben werden können. Der Großteil der hier gezeigten Beispiele besteht aus der gleichen Anzahl an Spalten und Zeilen und stellt somit Quadrate² dar, bei denen die Anzahl der Zeichen pro Zeile gleich der Anzahl an Zeilen ist. Sie bestehen aus den beiden Zeichen '+' und '-' in einer jeweils durch die Programmierung vorgegebenen Ordnung.
Hierauf basieren die folgenden Vorüberlegungen:

Das Speichern von Zeilen-/Spaltenzahl in einer einzigen Variablen ermöglicht es, unter gewissen Vorassetzungen später lediglich durch Ändern dieser einen Variablen die Größe der Zeichnung beliebig zu variieren.
In jeder Grafik werden die Zeilen von oben nach unten der Reihe nach durchlaufen. Innerhalb jeder Zeile werden wiederum deren Spalten von links nach rechts durchlaufen.
Der Spaltendurchlauf ist also ein wiederkehrender Prozess, der innerhalb jeder Zeile erneut erfolgt. Da identische Abläufe in Programmen i.A. mit Hilfe von Schleifen realsiert werden, lässt sich der Ablauf hier durch zwei ineinander geschachtelte Schleifen realisieren, bei der die äußere nacheinander die Zeilen durchläuft und die innere in jeder Zeile die Spalten. In dieser findet dann auch der Ausdruck der Zeichen ohne Zeilenumbruch statt. Da beide Schleifen bei den Quadraten bis zum selben Maximalwert laufen, können deren Abbruchbedingungen von der deklarierten Variablen zur Spaltenzahl direkt abhängig gemacht werden. Nach jedem vollständigen Durchlauf der inneren Spalten-Schleife muss dann ein Zeilenumbruch erfolgen.
Im schwierigsten Schritt gilt es, sich zu überlegen, welche Bedingungen erfüllt sein müssen, um entweder das eine oder das andere Zeichen auszugeben. Hierbei sollten keine Hardcodierungen in Form von im Quelltext fest vorgegebenen absoluten Werten vorgenommen werden, sondern vielmehr nach Abhängigkeiten zwischen Spalten- und Zeilenindexen gesucht werden, bei denen die jeweilige Zeichenposition von den vorhandenen Variablen abhängig gemacht wird.
Es ist sehr sinnvoll, sich vor der Programmierung diese Zusammenhänge zunächst explizit klarzumachen.
Die entsprechenden Überlegungen sind hier jeweils zu Beginn den Beispielen vorangestellt.

In einigen Beispielen wird die Division eines int-Wertes verwendet. Man beachte, dass in diesen Fällen eine eventuelle Nachkommastelle ersatzlos wegfällt.

Diagonale links

Gib dort ein '+' aus, wo der Zeilenindex gleich dem Spaltenindex ist, ansonsten gib ein '-' aus.

private void diagLinks() {
    int n = 5;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

+----
-+---
--+--
---+-
----+

Diagonale links

Gib dort ein '+' aus, wo die um 1 und den Zeilenindex verminderte Spaltenzahl gleich dem Spaltenindex ist, ansonsten gib ein '-' aus.

private void diagRechts() {
    int n = 5;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (j == n-1-i) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

----+
---+-
--+--
-+---
+----

Diagonale links

Gib dort ein '+' aus, wo der Zeilenindex oder wo der Spaltenindex jeweils der Hälfte der Spaltenzahl entspricht, ansonsten gib ein '-' aus.

private void kreuzOrtho() {
    int n = 5;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if(i==n/2 || j==n/2) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
            System.out.println();
        }
    }
}

Ausgabe:

--+--
--+--
+++++
--+--
--+--

Diagonale links

Gib dort ein '+' aus, wo entweder der Zeilenindex gleich dem Spaltenindex ist oder wo die um 1 und den Zeilenindex verminderte Spaltenzahl gleich dem Spaltenindex ist, ansonsten gib ein '-' aus.

private void kreuzDiag(){
    int n=5;
    for(int i=0; i<n; i++){
        for(int j=0; j<n; j++){
            if(i == j || j == n-1-i) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

+---+
-+-+-
--+--
-+-+-
+---+

Diagonale links

Gib dort ein '+' aus, wo der Spaltenindex größer oder gleich dem Zeilenindex ist, ansonsten gib ein '-' aus.

private void dreieckRechts() {
    int n = 5;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (j >= i) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

+++++
-++++
--+++
---++
----+

Diagonale links

Gib dort ein '+' aus, wo die Differenz von Spaltenanzahl und Spaltenindex größer als der Zeilenindex ist, ansonsten gib ein '-' aus.

private void dreieckLinks() {
    int n = 5;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (n - j > i) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

+++++
++++-
+++--
++---
+----

Diagonale links

Gib dort ein '+' aus, wo der Zeilenindex entweder 0 oder gleich der um 1 verminderten Zeilenzahl ist oder wo der Spaltenindex entweder 0 oder gleich der um 1 verminderten Spaltenzahl ist, ansonsten gib ein '-' aus.

private void rahmen() {
    int n=5;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if((i == 0 || i == n-1) || (j == 0 || j == n-1)) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

+++++
+---+
+---+
+---+
+++++

Die folgenden Beispiele umfassen Zeichnungen, bei denen die Spalten und Zeilenzahlen ungleich sind. Hier muss ebenfalls auf die Abhängigkeiten von Zeilen- und Spaltenindex geachtet werden.

Diagonale links

Gib dort ein '+' aus, wo der Index der aktuellen Spalte kleiner oder gleich der halben Spaltenzahl plus dem Index der aktuellen Reihe ist und wo er größer oder gleich der halben Spaltenzahl minus dem Index der aktuellen Reihe ist, ansonsten gib ein '-' aus.

private void dreieckOben() {
    int n = 7;
    int zeilen = n / 2 + 1;
    for (int i = 0; i < zeilen; i++) {
        for (int j = 0; j < n; j++) {
            if (j <= n/2 + i &&
                j >= n/2 - i) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

---+---
--+++--
-+++++-
+++++++

Diagonale links

Gib dort ein '+' aus, wo der Spaltenindex größer oder gleich dem Zeilenindex ist, der Spaltenindex aber kleiner der Spaltenanzahl minus dem Zeilenindex ist, ansonsten gib ein '-' aus.

private void dreieckUnten() {
    int n = 7;
    for (int i = 0; i <= n/2; ++i) {
        for (int j = 0; j < n; ++j) {
            if(j >= i && j < n-i) {
                System.out.print("+");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
    }
}

Ausgabe:

+++++++
-+++++-
--+++--
---+---

Diagonale links

Unterscheide zwischen den Zeilen in der aufgerundeten oberen Hälfte und der unteren.
Gib in der oberen dort ein '+' aus, wo der Index der aktuellen Spalte kleiner oder gleich der halben Spaltenzahl plus dem Index der aktuellen Reihe ist und wo er größer oder gleich der halben Spaltenzahl minus dem Index der aktuellen Reihe ist.
Gib in der unteren dort ein '+' aus, wo der Spaltenindex größer als ein Drittel der Spaltenzahl und kleiner als die Spaltenzahl minus einem Drittel der Spaltenzahl ist.

private void pfeilOben() {
    int n = 11;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i < (n/2 + 1)) {
                if (j <= n/2 + i && j >= n/2 - i) {
                    System.out.print("+");
                } else {
                    System.out.print("-");
                }
            } else {
                if (j > n/3 && j < n - n/3 - 1) {
                    System.out.print("+");
                } else {
                    System.out.print("-");
                }
            }
        }
        System.out.println();
    }
}

Ausgabe:

-----+-----
----+++----
---+++++---
--+++++++--
-+++++++++-
+++++++++++
----+++----
----+++----
----+++----
----+++----
----+++----

Diagonale links

Unterscheide zwischen den Zeilen in der abgerundeten oberen Hälfte und der unteren.
Gib in der oberen dort ein '+' aus, wo der Spaltenindex größer als ein Drittel der Spaltenzahl und kleiner als die Spaltenzahl minus deren Drittel ist.
Gib in der unteren dort ein '+' aus, wo der Spaltenindex größer als der um die halbe Spaltenzahl verminderte Zeilenindex ist und wo der Spaltenindex kleiner als die Spaltenzahl minus des um die halbe Spaltenzahl verminderten Zeilenindex ist.

private void pfeilUnten() {
    int n = 11;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i < (n/2)) {
                if (j > n/3 && j < n - n/3 - 1) {
                    System.out.print("+");
                } else {
                    System.out.print("-");
                }
            } else {
                if (j > (i - n/2) -1 && j < n - (i- n/2)) {
                    System.out.print("+");
                } else {
                    System.out.print("-");
                }
            }
        }
        System.out.println();
    }
}

Ausgabe:

----+++----
----+++----
----+++----
----+++----
+++++++++++
-+++++++++-
--+++++++--
---+++++---
----+++----
-----+-----

1) American Standard Code for Information Interchange - Eine 7-bit Zeichenkodierung (128 Zeichen), die im Wesentlichen die Zeichen des amerikanischen Alphabets nebst Ziffern, sowie einigen Satz- und Sonderzeichen umfasst.
2) Bei der Ausgabe auf der Konsole können die Zeichnungen aufgrund der Ungleichheit zwischen einerseits Zeichenabstand und -größe und andererseits Zeilenhöhe u.U. nicht als Quadrate erscheinen. Dies wurde bei den Abbildungen aus Demonstrationsgründen angepasst.

Wenn Ihnen javabeginners.de gefällt, freue ich mich über eine Spende an diese gemeinnützigen Organisationen.