Zweidimensionales Array mit Raute erstellen.

ConfusionZero

Grünschnabel
Hallo Leute,

ich hab folgendes Problem:
Ich soll in Java mit Hilfe eines zweidimensionales Arrays eine Raute programmieren, die später auf der Konsole durch Auslesen ausgegeben wird.

Beispiel: Konsolenausgabe:
# # # + # # #​
# # + + + # #​
# + + + + + #​
# # + + + # #​
# # # + # # #​

Allerdings soll das mit n-Zahlen >= 3 && ungrade geschehen koennen.

Ich bin bis hierhin gekommen:
# # # + # # #​
# # + + + # #​
# + + + + + #​
# # # + # # #​
# # # + # # #​

Hier mein Code:
Code:
public Legespiel(int n)
	{
		if(n >= 3 && n%2 != 0)
		{
			feld = new boolean[n][n];
			anzahl = n;
			legeRaute();			
		}
		else
		{
			System.out.println("Fehler: Zahl ist nicht groeßer oder gleich 3 bzw ist grade.");
		}

[...........................]

                           int a = ((anzahl-1)/2);
		//Senkrechte Linie in der Mitte des Arrays
		for (int i = 0; i < anzahl; i++) 
		{
			if (i <= anzahl / 2) 
			{
				int leerzeichen = anzahl / 2 - i;
				int anzahlSterne = 1 + 2 * i;
				for(int j=leerzeichen; j < leerzeichen + anzahlSterne; j++)
				{
					feld[i][j] = true;
				}
			}
			feld[i][a] = true;
			feld[a][i] = true;
			
		}


Wäre cool, wenn mir jmd mal auf die Sprünge helfen könnte. Ich bin kein erfahrener Programmierer und meine Mathe/Logik lässt auch noch zu wünschen übrig.

Liebe Grüße
und schonmal danke fürs Lesen.

ConfusionZero
 
Zuletzt bearbeitet:
Hi, ich habs mal so gelöst.
Hoffe damit konnte ich dir helfen!

Code:
public class Raute {

	public static void main(String[] args) {

		int n = 9;
		String[][] raute;
		int pos;
		int anzahl;

		if (n < 3 || n % 2 == 0) {
			System.out.println("Ungültige Zahl");
		} else {
			raute = new String[n][n];
			pos = (n - 1) / 2;
			anzahl = 1;

			for (int i = 0; i < (raute.length / 2)+1; i++) {
					int hilfspos = pos;
					int hilfsanzahl = anzahl;
					while (hilfsanzahl != 0) {	
						raute[i][hilfspos] = "+";
						raute[raute.length - 1 - i][hilfspos] = "+";
						hilfspos++;
						hilfsanzahl--;
					}
					pos--;
					anzahl+=2;
			}

			for (int i = 0; i < raute.length; i++) {
				for (int j = 0; j < raute[0].length; j++) {
					if (raute[i][j] == null) {
						System.out.print("#");
					} else {
						System.out.print(raute[i][j]);
					}
				}
				System.out.println("");
			}
		}

	}

}
 
Danke für die schnelle Antwort. Deine Lösung ist echt super und funktioniert auch.
Allerdings gibt es ein Problem für mich. Das Feld muss boolean sein. Macht das einen Unterschied?

Ich sollte letztens einen Tannenbaum zur Übung machen(was ich net geschafft hab)
Mit der Musterlösung davon lässt sich kaum etwas anfangen.

Ich sitz seit knapp 6 Arbeitsstunden daran und knacks einfach nicht.
Vielleicht einfach nur Unkenntnis oder einfach mangelhafte Mathe bzw Logik-Vorstellung.

Aber auf jedenfall ein großes DANKE an dich für die schnelle Antwort.

GreeTz

ConfusionZero
 
Hey,
also zunächst dazu:
Das Feld muss boolean sein. Macht das einen Unterschied?

das macht erstmal keinen wirklichen Unterschied bis auf die Inizialisierung. Die Frage ist nun was genau du willst?! Wenn du genau nochmal schildern würdest was dein Anliegen ist, könnte ich dir vllt auch weiterhelfen!

Was deinen "Tannenbaum" betirfft ist das, so wie ich das verstehe, ja nur eine halbe Raute!?

Und von welcher Musterlösung ist hier die Rede?!

Versuch doch einfach nochmal genau zu schildern was eigentlich dein Problem ist! Dann versuche ich dir möglichst genau zu helfen ;)
 
Ich danke dir auch für die hilfe, hab das in mein programm gepackt und das ganze auf booleans abgeändert und es funktioniert echt gut.
Ein dickes dankeschön von mir :)
 
Die Aufgabenstellung ist folgende:
Programmieren Sie die Klassen Legespiel und LegespielTest
1 Die Java-Klasse Legespiel muss folgende Eigenschaften besitzen:
/11/ Der Konstruktor Legespiel (int n)erzeugt ein zweidimensionales Feld vom
Typ boolean der Größe nxn
/12/ Die Methode legeRaute()setzt einzelne Feldkomponenten auf den Wert true,
so dass alle auf true gesetzten Komponenten zusammen das Muster einer
Raute ergeben. Die Raute soll jeweils in der Mitte der Feldseiten mit ihrer Spitze
die Feldseite berühren. (siehe Bild)
/13/ Die Methode toString() erzeugt einen String aus dem Feld. Sie startet mit
dem leeren String und hängt für jede Feldkomponente ein Zeichen daran:
Wenn die Feldkomponente den Wert
- false hat, dann wird ein Leerzeichen angehängt
- true hat, dann wird ein '*'-Zeichen angehängt.
Nach jeder Zeile des Feldes, soll auch im String ein Zeilenvorschub angehängt
werden (Hinweis: '\n' erzeugt einen Zeilenvorschub).
2 Die Java-Klasse LegespielTest muss folgende Eigenschaften besitzen:
/21/ Die main-Methode liest eine ganze Zahl von der Konsole ein, die größer gleich 3
und ungerade sein muss. Sie sorgt anschließend dafür, dass ein Feld in der geforderten
Größe erzeugt wird, veranlasst das Legespiel dazu die Raute zu legen
und gibt das Ergebnis mittels toString() auf der Konsole aus.
 
Hier ist die Lösung für deine Aufgabe 1, Aufgabe 2 solltest du selber lösen können.

Java:
class Raute
{
  private int groesse;
  private boolean feld[][];
  // bei Konstruktoren wird nie ein Rückgabewert definiert
  Raute(int n)
  {
    groesse = n;
    feld = new boolean[n][n];
    int row,col;
    // die Initialisierungsschleife ist normalerweise
    // nicht notwendig, da boolean's mit false initialisiert sind
    for ( row = 0; row < n; row++ )
    for ( col = 0; col < n; col++ )
    { feld[row][col] = false; }
  }
  // Die Raute wird in das feld geschrieben
  public legeRaute()
  {
    int n = groesse;
    int last  = n-1; // index der letzten Zeile
    int mitte = n/2; // index der Mitte
    int min, max; // linker und rechter Rand fuer die Rautenzeile 
    int row, col; // Schleifenzaehler fuer Zeile und Spalte

    // Die Schleife fue die haelfte der Zeilen
    min = max = mitte;
    for ( row = 0; row < mitte; row++, cnt++, min--, max++ )
    {
      // rautenelemente auf true setzen
      for ( col = min; col <= max; col++ )
      {
        feld[     row][col] = true; // von oben her fuellen
        feld[last-row][col] = true; // von unten her fuellen
      }
    }
    // die mittlere Zeile wird komplett gefuellt
    for ( col = 0; col < n; col++ )
    { feld[mitte][col] = true; }
  }
  // das feld als String ausgeben
  string toString()
  {
    int row,col;
    string str = "";
    for ( row = 0; row < groesse; row++ )
    {
      for ( col = 0; col < groesse; col++ )
      { str += feld[row][col] ? "*" : " "; }
      str += "\n";
    }
  }
}

PS: Ich habe nur einen normalen Text-Editor verwendet, aber der Code müsste eigentlich trotzdem fehlerfrei sein *hoff*
 
Zuletzt bearbeitet:
@Gocca
Hier im Forum wird Wert auf Eigeninitiative gelegt. Wenn nur Aufgabe geposten wird ohne einen Lösungsansatz, wird normal nicht drauf geantwortet.

Es hat schon seine Gründe warum ihr die Aufgaben von eurem Prof. gestellt bekommt.

Was ich hier allerdings richtig dreist finde ist, dass du dir nichtmal die Mühe machst, das Thema durchzulesen, da die Frage schon beantwortet.
http://www.tutorials.de/forum/java/272545-zum-thema-ubungszettel.html


Gruß

Sascha
 
Zurück