# Bestimmte Muster mit For-Schleife ausgeben



## javaaa (21. Mrz 2012)

Hallo. Ich brauche Hilfe beim Verständnis folgender Aufgabe. 
Man soll mit For-Schleifen ein bestimmtes Muster darstellen. 

Hier erstmal der Quelltext:


```
public class  Flagge {
	public static void main (String args[]){
		
		//a = Spalte (y-Richtung), b = Zeile (x-Richtung)
		for(int a=0; a<10; a++) {
			for (int b=0;b<a;b++) {
				System.out.print("*");
			}
			System.out.println();
		}
}

}
```

Ich habe es im Programm ausgestet. Es kommt dieses Muster raus (siehe Anhang). Soweit ich es verstanden habe, füllt a die Sterne in y-Richtung aus und b die Sterne in x-Richtung.
Aber was passiert genau durch die Aussage b<a.
Es heißt doch, dass dann zum Beispiel, wenn a 5 ist...dann ist b 4.
Was ich nicht verstehe, ist, woran man sieht, dass die Sterne pro Reihe immer weiter zunehmen?

LG


----------



## jwiesmann (21. Mrz 2012)

schreib dir doch einfach mal die a's und b's auf und guck was dann passiert.
Noch als kleiner Tipp:

```
System.out.print
// ist nicht gleich
System.out.println
```


```
System.out.println
```
erzeug immer eine leerzeile....

wenn du nun die schleifen "aufschreibst" bekommst du sowas hier ..
a=0

dann wird solange ein * ausgegeben, bis a>b ist.

sprich:
a=0

for (int b=0;b<a;b++) ..
erster durchlauf:
b = 0
Schleife bricht ab, da b=a (0=0)

zweiter durchlauf der ersten spalte
a = 1
b=0
* ausgeben
b=1 --> abbruch 
usw...


----------



## Andi_CH (21. Mrz 2012)

Das Programm kommt zu Zeile 5
setzt a auf 0
prüft ob a < 10 ist (Ja!)
geht zu Zeile 6
setzt b auf 0
prüft ob b < a ist (Nein!)
geht zu Zeile 8 (wegen dem Nein)
führt Zeile 9 aus (Zeilenumbruch ausgeben)
Geht zu Zeile 5
Es erhöht den Wert von a (ist nun 1)
Geht zu Zeile 6
Setzt den Wert von b auf 0
prüft ob b kleiner ist als a (Ja!)
Geht zu Zeile 7
Gibt einen * aus
Geht zu Zeile 6
Erhöht den Wert von b (ist 1)
prüft ob b<a ist (Nein!)
führt Zeile 9 aus (Zeilenumbruch ausgeben)
Geht zu Zeile 6

und so weiter

Die einzige Schwierigkeit ist die zu erkennen, dass die for-Schleife etwas anderes macht, wenn man von oben oder von unten kommt ....

Spiel das weiter so durch und du wirst sehen warum es so ist wie es ist.

EDIT: BTW ein Debugger ist extrem hilfreich zu erkennen was im Code abgeht.


----------



## javaaa (21. Mrz 2012)

Danke für die Antworten. Habe es eben noch mal in Ruhe selber angeschaut und nun verstanden.

Jetzt wollte ich versuchen, das Muster "umzukehren". Sodass die Sterne nach unten abnehmen.
Habe versucht, die Kleiner-Zeichen zu einem "Größer" zu verändern, aber es tut sich nichts.

Kann mir da jemand helfen?

LG


----------



## bobbsen (21. Mrz 2012)

du solltest eher versuchen, die äußere Schleife von 9 bis 0 laufen zu lassen, dann drehst du das Muster um.

Im Code oben ist a minimal 0, b ist am Anfang jeden Durchlaufs auch 0, also trifft b > a nie zu.


----------



## babuschka (22. Mrz 2012)

Hallo Leute,
wisst ja auch, wie man mittels einfacher Schleifen ein "X" als Muster erstellt? 

meine Idee wäre:
public class muster {
	public static void main (String[]args){

		for (int i=1;i<11;i++){
			for (int j=1;j<11;j++){


if( i==j || i+j==10  ){
	System.out.print(" * ");

aber das haut nicht hin..

thx


----------



## javaaa (23. Mrz 2012)

Danke! Das umgedrehte Dreieck hat nun geklappt.

Ich bin nun dabei zu versuchen, das Dreieck horizontal zu spiegeln. Das heißt dann ja, dass nach unten hin immer mehr Sterne zu sehen sind. 

Doch wie kann ich das realisieren? Habe schon versucht bei den zwei For Schleifen jeweils die Werte und Zeichen zu ändern, aber es klappt nicht.


```
//a = Spalte (y-Richtung), b = Zeile (x-Richtung)
		for(int a=10; a>0; a--) {
			for (int b=0;b<a;b++) {
				System.out.print("*");
			}
			System.out.println();
			
		}
		System.out.println();
```

LG


----------



## pappawinni (23. Mrz 2012)

Die äussere Schleife zählt die Zeilen.
D.h. beim ersten Durchlauf wird die erste Zeile ausgegeben, beim zweiten die zweite usw., 
ganz egal welchen Wert der Schleifenzähler hat.
Der inneren Schleife musst du also beibringen, wieviele und welche Zeichen
da in abhängig vom Zähler der äußeren Schleife ausgegeben werden sollen.
Schreib dir doch vielleicht mal auf Papier, wie sich die Schleifenzähler entwickeln,
bzw. wie sie sich entwickeln sollten.
Dann wird dir vielleicht klar, was du machen musst.


----------



## javaaa (23. Mrz 2012)

Also es soll ja wie folgt aussehen (siehe Anhang).

Ich habe mir gedacht, dass wenn man das Muster von links nach rechts betrachtet...

dann wird die Anzahl der Sterne pro Reihe immer weniger und pro Spalte nehmen die Sterne immer zu.

Das heißt ja quasi, dass a(Spalte) bei jedem Schleifendurchlauf um 1 erhöht wird. Wiederum müsste b(Reihe) pro Durchlauf um 1 reduziert werden.


```
//a = Spalte (y-Richtung), b = Zeile (x-Richtung)
		for(int a=10; a>0; a++) {
			for (int b=10;b>a;b--) {
				System.out.print("*");
			}
			System.out.println();
```

Der Startwert bei b müsste ja im Prinzip 10 sein, da die erste Reihe voll ausgefüllt ist. Aber so richtig komme ich noch nicht drauf.

LG


----------



## pro2 (23. Mrz 2012)

```
for(int a=10; a>0; a++)
```

Überleg dir mal was in der Zeile steht..
Von a = 10, solange a größer als 0 ist, erhöhe immer a immer um eins.


----------



## javaaa (23. Mrz 2012)

pro2 hat gesagt.:


> ```
> for(int a=10; a>0; a++)
> ```
> 
> ...



So müsste es sein, oder?


```
for(int a=0; a<10; a++)
```


----------



## pappawinni (23. Mrz 2012)

Wie ich das sehe, musst du für JEDE Zeile 10 Zeichen ausgeben.
Dabei sind jeweils bei der 
1. Zeile ab dem 1ten Zeichen '*', davor Leerzeichen ' '
2. Zeile ab dem 2ten Zeichen '*', davor Leerzeichen ' '
3. Zeile ab dem 3ten Zeichen '*', davor Leerzeichen ' '
..
10. Zeile ab dem 10ten Zeichen '*', davor Leerzeichen ' '
auszugeben.

Warum steht da eigentlich als Kommentar Zeile = X-Richtung und Spalte wäre Y-Richtung..
wenn man um die Ecke denkt, dann geht das schon irgendwie...
warum auch einfach, wenn es auch kompliziert geht, nichtwahr?


----------



## javaaa (23. Mrz 2012)

pappawinni hat gesagt.:


> Wie ich das sehe, musst du für JEDE Zeile 10 Zeichen ausgeben.
> Dabei sind jeweils bei der
> 1. Zeile ab dem 1ten Zeichen '*', davor Leerzeichen ' '
> 2. Zeile ab dem 2ten Zeichen '*', davor Leerzeichen ' '
> ...


Das heißt, dass a nun doch den Startwert 10 haben muss? Jetzt bin ich ganz durcheinander...


----------



## pappawinni (23. Mrz 2012)

javaaa hat gesagt.:


> Das heißt, dass a nun doch den Startwert 10 haben muss? Jetzt bin ich ganz durcheinander...



Welchen Startwert a hat, ist doch relativ egal.
Wichtig ist, dass die äußere Schleife 10mal durchlaufen wird.
dann wird mittels Print Line ( System.out.println(); ) 
10 mal der Zeilenvorschub erzeugt. 
Das ist alles was die äußere Schleife tut.

In der inneren Schleife entscheidest du, welche Zeichen und wie viele ausgeben werden.
Man könnte das prizipiell unabhängig von der äußeren Schleife tun.
Es bietet sich hier aber an, den äußeren Schleifenzähler für die innere(n) Schleife(n) zu nutzen

In Pseudocode zum Beispiel:

```
Sei a von 0 bis 9
      Sei b von 0 bis 9
          wenn b< a 
               gib leerzeichen aus
          wenn b >= a 
               gib stern aus
      nächstes b
  Zeilenvorschub
  nächstes a
```


----------



## javaaa (23. Mrz 2012)

Danke...aber es klappt nicht.


```
public class  muster4 {
	public static void main (String args[]){
		
		//a = Spalte (y-Richtung), b = Zeile (x-Richtung)
		for(int a=0; a<10; a++) {
			for (int b=0;b<10;b++) {
				if(b<a){
					System.out.println();
				}
				else {
					System.out.print("*");
				}
			
			}
			System.out.println();
			
		}
		
	}
	
}
```

Das Dreieck soll ja horizontal gespiegelt werden. Und irgendwie sind die Abstände zwischen den Zeilen nun sehr groß bzw. wird der Zeilenabstand von Zeile zu Zeile größer.


----------



## pappawinni (23. Mrz 2012)

Ja, meine Befürchtung trifft ein.
unterscheide bitte Print und Print Line
Print : System.out.print("*") gibt aus, OHNE Zeilenvorschub
Print Line : System.out.println("*") git aus MIT Zeilenvorschub

Wenn du also ein Leerzeichen ausgeben willst, ohne einen Zeilenvorschub, dann bitte so:
System.out.print(" ")


----------



## javaaa (23. Mrz 2012)

Besten Dank! Es funktioniert nun.

Wie könnte man das nur mit den For-Schleifen realisieren und ohne der If-Else-Abfrage? Weil bei der Ausgangssituation auch nur die For-Schleifen eine Rolle gespielt haben.

LG


----------



## pappawinni (23. Mrz 2012)

```
Sei a von 0 bis 9
      Sei b von 0 bis b< a 
               gib leerzeichen aus
      nächstes b
      Sei b von a bis 9 
               gib stern aus
      nächstes b
  Zeilenvorschub
  nächstes a
```
:lol:


----------

