# Musteraufgabe



## Extacy (16. Nov 2014)

Hallo Java-Forum Community,

mir wurde in der Uni eine Aufgabe gestellt die ich einfach nicht gelöst bekomme. Die Aufgabe sollte für jede eingegebene Zahl lösbar sein. Hier die Aufgabe:
Aufgabe 3 (Muster ausgeben)Schreiben Sie ein Javaprogramm, das Muster einer bestimm
ten Struktur ausgibt. Das Programm soll so geschrieben sein, dass die Größe des Musters durch
Benutzereingabe bestimmt werden kann, d.h das Programm fordert zur Eingabe einer Zahl auf.
Wird z.B. eine 3 eingegeben, dann wird das folgende Muster vom Programm ausgegeben:

```
+++
+--
+-+
```
Im Falle der Eingabe von 8 sieht das Muster so aus:

```
++++++++
+-------
+-++++++
+-+-----
+-+-++++
+-+-+---
+-+-+-++
+-+-+-+-
```
Es handelt sich also um eine gewisse Art „geschachtelter“ Strukturen, wobei ausgehend von „links
oben“ abwechselnd Zeilen und Spalten mit „+“und„-“befülltwerden.

Normal bin ich im Java-Kurs sehr stark aber diese Aufgabe leuchtet mir einfach nicht ein. Ich freu mich auf eure Überlegungen 

Gruß 

Extacy


----------



## Androbin (16. Nov 2014)

Naja, du könntest ja für jeden "Pixel" prüfen, ob er in X-/Y-Richtung an einer "geraden" Stelle steht (mit Modulo 2).
Das dürfte als Ansatz genügen!


----------



## Foxei (16. Nov 2014)

Müsste genau das sein was du Suchst:

```
import java.util.Scanner;


public class PlusMinus {
	public static void main(String[] args){
		String text="";
		Scanner scan=new Scanner(System.in);
		int loop=scan.nextInt();
		int x=0;
		for(int i=0;i<loop;i++){
			if(x%2==0){
				text+="+";
				auffüllen(text, '+', loop);
			}else{
				text+="-";
				auffüllen(text, '-', loop);
			}
			
			
			x++;
		}
	}
	public static void auffüllen(String text,char auffüllen,int loop){
		for(int i=text.length();i<loop;i++){
			text=text+auffüllen;
		}
	
		System.out.println(text);
	}
}
```
Ausgabe:

```
6
++++++
+-----
+-++++
+-+---
+-+-++
+-+-+-
```
Wenn Fragen sind einfach her damit.
LG Foxei


----------



## Flown (16. Nov 2014)

Ahja der Code ist ein wenig graußig. Wieso for-loops verwenden, wenn du so und so eine eigene Zählvariable einführst. Außerdem schließt du deinen Scanner zum Schluß nicht.

Definitiv sauberer gehts so:


```
import java.util.Scanner;

public class PlusMinusStructure {
  public static void main(String... args) {
    try (Scanner scanner = new Scanner(System.in)) {
      int n = scanner.nextInt();
      for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
          System.out.print(j % 2 == 0 ? "+" : "-");
        }
        for (int j = i; j < n; j++) {
          System.out.print(i % 2 == 0 ? "+" : "-");
        }
        System.out.println();
      }
    }
  }
}
```


----------



## Foxei (16. Nov 2014)

Den muss ich zustimmen aber ich glaube das es wenn man noch nicht so tief in der Materie ist deine Lösung weniger verständlich ist.  Schließt der Try block den Scanner Automatisch?


----------



## Flown (16. Nov 2014)

Ahja hier zum nachlesen mit try-resource.

Welche tiefe Materie? for-loops? Geschachtelte Schleifen? Ternäre Operatoren?

Das muss ich echt jetzt sagen, dass das weder fortgeschritten, noch kompliziert ist.

Wäre es einfacher, wenn man von einem schlechten Code lernt und damit sich einen schlechten Stil aneignet? Oder man erhält einen korrekten, sauberen Code, der die Konventionen einhält, ist vielleicht etwas zum nachdenken dabei, aber man versteht, wie man Code strukturiert und aufbaut?

Aber damits verständlich wird, schreib ich dir noch ein paar Kommentare hinein!


```
import java.util.Scanner;

public class PlusMinusStructure {
  public static void main(String... args) {
    try (Scanner scanner = new Scanner(System.in)) {
      int n = scanner.nextInt();
      // n Zeilen
      for (int i = 0; i < n; i++) {
        // Alternierend + und - bis zur i-ten Stelle in der i-ten Zeile
        // +-+-+-...+
        // 012345...i
        for (int j = 0; j < i; j++) {
          System.out.print(j % 2 == 0 ? "+" : "-");
        }
        // Ab der i-ten Stelle in der i-ten Zeile - abhängig ob die Zeile i un-/gerade ist + oder - auffüllen
        // i gerade
        // +...+
        // i...n
        // i ungerade
        // -...-
        // i...n
        for (int j = i; j < n; j++) {
          System.out.print(i % 2 == 0 ? "+" : "-");
        }
        System.out.println();
      }
    }
  }
}
```


----------



## Foxei (16. Nov 2014)

Ja dein Code ist viel besser als meiner dem habe ich nichts entgegen zu setzten  und danke für das mit dem Try Block wusste ich noch nicht das der das macht.


----------



## Flown (16. Nov 2014)

Ich will nicht sagen, dass er schlecht ist. Er ist nur ein wenig chaotisch. Wenn man ihn verbessert, dann würde er auch in ordnung sein, denn ich habe redundante Berechnungen die jedes mal von 0 bis i reichen. Du speicherst diese Berechnungen zwischen, dass ist ein Vorteil.

So könnte er für dich aussehen:


```
import java.util.Scanner;

public class PlusMinus {
  public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int n = scan.nextInt();
    StringBuilder cache = new StringBuilder();
    for (int i = 0; i < n; i++) {
      char cur = i % 2 == 0 ? '+' : '-';
      cache.append(cur);
      appendNCharAndPrint(cache, cur, n - i - 1);
    }
    scan.close();
  }
  
  public static void appendNCharAndPrint(StringBuilder prefix, char c, int n) {
    StringBuilder builder = new StringBuilder(prefix);
    for (int i = 0; i < n; i++) {
      builder.append(c);
    }
    System.out.println(builder.toString());
  }
}
```

Anmerkungen:
- Scanner händisch geschlossen.
- Mit Strings arbeitet man normalerweise nicht, darum StringBuilder benutzen.


----------



## Extacy (16. Nov 2014)

Super, ich danke für die Antworten.
Ich schau mir die Wege später mal an und meld mich nochmal falls ich Fragen habe.

Gruß Extacy


----------

