Sternmuster auf Konsole ausgeben

[Hopeless]

Hi, also ich hab folgende Aufgabe versucht zu lösen :

Schreiben Sie ein Java-Programm, das das folgende Muster auf der Konsole ausgibt:

*
**
***
****
*****

Schreiben Sie jeweils eine Methoden, die das Muster:
1. horizontal spiegelt (an der x-Achse)
2. vertikal spiegelt (an der y-Achse)
3. um 180 dreht
Die Anzahl der Sternchen pro Zeile wird beim Konstruktor angegeben. Die Anzahl der Zeilen ist gleich
der Anzahl Spalten. Arbeiten Sie mit For-Schleifen und einem zweidimensionalen Array mit Char
Werten, das die * aufnehmen kann.

Ich hab da jetzt ewig dran gesessen und es leider nicht hinbekommen. Im Moment isses sogar soweit dass ich den Code der einigermaßen ging (also wenigstens ne reihe dieser Sterne ausgegeben hat) auch nicht mehr geht ???:L

Hier der Code :

public class Sternchen
{
   
    char star = '*';
       char[][]stern;
    
  
    public Sternchen(int anzahl1)
 {
   stern = new char [anzahl1][anzahl1];
   stern [][] = star;
  }
          

 void sternchenAnzeigen()
 {
     for (int i=0; i<stern.length;i++)
     for (int j = 0; i<stern.length;j++)
      
        System.out.print(stern[i][j]);
    }
    }

Help me. Was genau stimmt da denn nicht? und wie kann ich die Fehler beheben?

 

[Hopeless]

Ups ich sehs grad die 2te for schleife ist falsch da muss noch ein j rein anstatt i. Aber selbst dann gehts nicht ...

 

[Gast]

mit prinln machst du nen zeilen umbruch, und der ist notwendig

 

[Hopeless]

Was ich nicht verstehe ist, dass ich ein 2d array erstellen soll und im Konstruktor nur einen Wert für die Anzahl der * eingebe. Wie mache ich dass dass er in dem int Array die char speichert und vorallem dass es so ausgegeben wird wie vorgesehen?

 

[Azrahel]

Ist nicht getestet aber guck halt mal

public class Sternchen{ 
	char star = '*'; 
	char[][]stern; 

	public Sternchen(int anzahl1) { 
		stern = new char [anzahl1][anzahl1]; 
	       for (int i=0; i<anzahl1;i++) 
	    	   for (int j = 0; j<anzahl1;j++) 
	    		   stern [i][j] =star ;
	} 
          

	void sternchenAnzeigen() { 
	     for (int i=0; i<stern.length;i++) 
	    	 for (int j = 0; j<stern.length;j++){ 
	    		 System.out.print(stern[i][j]);
	    		 if(j==stern.length-1)
		    		 System.out.println("");
	    	 }
	} 
}

 

[moormaster]

Wieso willst du das unbedingt in einem Array aus int Werten speichern? und: Wieso willst du chars speichern, wenn es nur 2 Zustände für jedes Feld gibt: * oder Leerzeichen. Da ist es doch eine riesen Speicherverschwendung für sowas char oder int Werte zu nehmen. Ein Array aus boolean Werten reicht völlig aus.

Bei der Ausgabe des Arrays auf die Konsole kannst du dann berücksichtigen, dass true für * und false für Leerzeichen steht (je nach dem, wie man das festlegen möchte).

Was ich nicht verstehe ist, dass ich ein 2d array erstellen soll und im Konstruktor nur einen Wert für die Anzahl der * eingebe.

Wieso solltest du 2 Werte im Konstruktor eingeben müssen? Anzahl der Sternchen pro Zeile entspricht der Spaltenanzahl, welche wiederum der Zeilenanzahl entspricht (laut Aufgabenstellung). Somit genügt es, nur die Spaltenanzahl (bzw. Anzahl der Sternchen in der letzten Zeile) im Konstruktor anzugeben.

Der Konstruktor bekommt also diese Werte übergeben und fängt dann erstmal an, den Ausgangszustand des Arrays zu erstellen, so dass in der 1. Zeile 1 Stern, in der 2. 2 Sterne usw. gespeichert sind. (Das alles natürlich in Form von true oder false, weil im Array ja boolean Werte abgelegt werden).

Wenn du das hast, kannst du dir eine Methode schreiben, welche dieses Array lesen kann und in Form von * oder Leerzeichen jeweils auf der Konsole ausgibt. Damit siehst du dann schonmal, ob das Muster so erstellt und ausgegeben wird, wie es soll.

Danach kannst du dich dann um die anderen Methoden kümmern, welche das Array so verändern, dass das Muster gedreht bzw. gespiegelt wird. So wie es eben verlangt wurde in der Aufgabenstellung.

 

[Lupo4u2]

@moormasster: In der Aufgabenstellung steht aber:

Arbeiten Sie mit For-Schleifen und einem zweidimensionalen Array mit Char Werten, das die * aufnehmen kann.

Ist zwar wirklich nicht notwendig, aber man sollte sich dennoch dran halten :roll:

@Hopeless:
Ich glaube du denkst zu kompliziert.
Schau dir die Aufgabe nochmal in Ruhe an. Am besten mit einem Blatt papier daneben auf dem du dir Notizen machst... Denn man kann so eine Aufgabe z.b. in folgende einzelne Etappen aufteilen:

1. die ausgabe von einem zweidimensionalen Char Array mit Zeilenumbrüchen (egal, was der Array enthält)
2. Diesen zweidimensionalen Char Array mit Sternchen bzw. Leerzeichen füllen
3. Den Array mit einem Parameter aus dem Konstruktor heraus erstellen und füllen
4. Überprüfen ob die Ausgabe des Arrays immer noch richtig ist
Jetzt hättest du schonmal das meiste geschafft

5. Sich die drei Methoden (horizontal, vertikal spiegeln & 180° drehen) nochmal anschauen und (vielleicht auch mal auf einem Blatt papier) überprüfen was da gemacht werden muss... Denn du musst eigentlich nur die Ausgabe ein bisschen verändern, damit der Array anders dargestellt wird. Innerhalb des Char Arrays musst du gar nix ändern!

Das war es eigentlich schon... Wie gesagt, wenn du bis punkt 4 kommst ist der rest eigentlich nur noch ein bisschen Logik

Gruß

 

[Hopeless]

Ich dachte an zwei Parameter die übergeben werden müssen, da bei mir das mit dem : in die erste Zeile nur einen * in die zweite ** usw nicht funktioniert.

 

[Azrahel]

Kann das sein das mit dem einen Parameter der übergeben werden soll die maximale anzahl sterne gemeint ist?
D.h.: wenn Parameter = 3 -> 1, 2, 3 wenn Parameter = 4 -> 1, 2, 3, 4 ?
weil ansonsten komm ich immer auf ein Quadrat.

Oder steh ich aufm Schlauch?

 

[Hopeless]

Denkst richtig, weil ich hatte bisher auch immer ein Quadrat.

 

[Azrahel]

Hmm dann nehme ich an das du als Parameter nur übergibst wieviele Sternchen max erscheinen sollen, und du musst dann von 1 an Hochzählen. Drehen und so sollte eigentlich über das ändern von [j] -> [j] realisierbar sein, naja und rückwärtszählen zum Spiegeln ist ja Standard :toll:

 

[Hopeless]

Das mit dem Hochzählen klappt bei mir grad nicht kann ja nicht -1 machen, da es ein int is und ich ja char hab. Ach man

 

[Azrahel]

hochzählen -1? Die Zählvariable hat doch nix mit deinem char zu tun? i und j sind doch int.

D.h. du initialisierst dein charArray immer im positiven Bereich. Nur bei der Ausgabe zählst du dann statt

i=0;i<charArray.length();i++

i=charArray.length();i>0;i--

oder so ähnlich

 

[Hopeless]

Ich hab jetzt mal versucht das Array so anzupassen wie hier :

int[][] m = new int[3][];
for ( int i = 0; i < 3; i++ )
  m[i] = new int[i+1];

Hier soll auch ein Dreieckiges Array ausgeben werden. Leider weiß ich nicht wie ich das einbauen kann. Hab das oben in meinen Code geschrieben nur kann ich die zahlen im array dann wieder nicht durch die *ersetzen :x

 

[Hopeless]

Kann man denn eigentlich den Konstruktor mehrmals hintereinander aufrufen? Dann könnte man eigene Zeilen erzeugen und dann jeweils im Konstuktor eine andere Zahl pro Zeile angeben.

 

[The_S]

Klar kann man den Konstruktor öffters aufrufen

this(parameter);

Aber in deinem Fall is das doch äußerst unschön (auch wenn ich den Thread nur n bisschen überflogen hab)

 

[Lupo4u2]

vergiss das mit deinem Int... nimm gleich Chars...

Mal ein kleines Beispiel
(grml... will dir eigentlich nicht direkt den source geben...
deshalb versuch ich es zu verallgemeinern [Jetzt wäre ein Struktogramm programm hilfreich um die Logik zu zeigen ]):

int anzahl_sterne;//wieviele Sterne angezeigt werden sollen...
char[][] tabelle = new char[anzahl_sterne][anzahl_sterne];

So, jetzt hast du einen Array (tabelle) der für jede Spalte & Zeile einen Wert hat (der muss natürlich auch noch initialisiert werden, du weisst aber wie das geht, oder?).
Wenn du diese tabelle jetzt komplett mit '*' füllen würdest und ausgibst würde folgendes rauskommen:

// anzahl_sterne = 4;
****
****
****
****

// anzahl_sterne = 6;
******
******
******
******
******
******

Das ist klar, oder? gut.
damit es am ende aber so aussieht ('_' sind gleich Leerzeichen!):

// anzahl_sterne = 4;
*___
**__
***_
****

musst du mit zwei Schleifen arbeiten, die ineinander geschachtelt sind (die erste läuft durch die Zeilen, die zweite durch die Spalten!):

for (aktuelle_zeile=0;aktuelle_zeile<letzte_zeile;nächste_zeile)
for (aktuelle_spalte=0;aktuelle_spalte<letzte_spalte;nächste_spalte)
{
//Hier kannst du jetzt mittels den Werten die in aktuelle_spalte und aktuelle_zeile stehen deine tabelle füllen!
//jetzt musst du nur noch herausfinden wann ein Stern rein muss und wann ein Leerzeichen
}

Ich hoffe das ist verständlich...

Gruß

 

[Hopeless]

//jetzt musst du nur noch herausfinden wann ein Stern rein muss und wann ein Leerzeichen

Ein * kommt doch solange rein, solange aktuelle_zeile<letzte_zeile ist.


Versuch :

if(aktuelle_zeile<letzte_zeile)
stern[i][j]=star;
else
stern [i][j]="";

:roll:

 

[Hopeless]

Ach man ich geb auf

 

[moormaster]

In das Feld [aktuelle_zeile][aktuelle_spalte] kommt genau dann ein Stern rein, wenn...

 

[Lupo4u2]

Ein * kommt doch solange rein, solange aktuelle_zeile<letzte_zeile ist.

nicht ganz... die Anzahl der Sternchen pro Zeile sind ja abhängig von der aktuellen Spalte... Hier nochmal bildlich:

//Tabelle:
Spalte|
      |Zeile_______________________________
      |    1       2       3        4
1     |    *      [ ]
2     |    *       *
3     |   [*]      *       *
4     |    *       *       *        *

und jetzt das was moormaster geschrieben hat...

Schau mal:
in zeile 1, Spalte 2 --> kein Stern (warum?)
in zeile 3, Spalte 1 --> Stern (warum?)
usw... usw...

P.S. Sorry, aber du musst bzw. sollst alleine drauf kommen... denn nur so lernt man auch was.

 

[Hopeless]

Ich finds auch gut, wenn ich von alleine drauf kommen soll. Wills ja nicht abschreiben sondern verstehen.

 

[Hopeless]

Eigentlich zieht man doch immer von der letzten Spalte einen Stern ab um auf die nächste zu kommen, oder?

 

[DaKo]

Nein.

Jede Zeile kommt ein neuer Stern hinzu.

D.h.

1 Zeile -> 1 Stern
2 Zeile -> 2 Sterne

Jetzt aber

 

[Hopeless]

Ja, ok wenn man Zeilenweise geht. Bin jetzt Spaltenweise gegangen

 

[Lupo4u2]

Man muss auch Zeilenweise gehen, weil das die Art ist wie ein Computer die Sachen auf den Bildschirm schreibt. (oder auch wie menschen Sachen schreiben )

 

[moormaster]

Du kannst dir mal überlegen, ab welcher Zeile in Spalte s ein Stern reinkommt...
In der ersten Spalte ist z.B. ab der 1. Zeile jedes Mal ein * drin... Wenn du dir das für die restlichen Spalten überlegst, kommst du auch drauf. Am besten ist, wenn du dir das einfach mal irgendwo aufzeichnest

 

[Hopeless]

Ok, also müsste ich dann nur die Zahl der Sterne um 1 erhöhen. Nur geht das nicht

 

[moormaster]

Du sollst nicht in Anzahl von Sternen denken... sondern dich nur auf ein Feld konzentrieren.
Durch die 2 Schleifen hast du im Prinzip Koordinaten gegeben. Jetzt musst du dir nur überlegen, wie du mit gegebenen Koordinaten entscheidest, ob an die Position ein * oder ein Leerzeichen hin gehört. Das kann man aus der Zeilennummer und der Spaltennummer bestimmen... ich weiss nicht, wie man das noch erklären soll, ohne die Lösung zu verraten

 

[Lupo4u2]

edit: wegen langsamkeit gelöscht... moormaster hat das schon richtig erkannt.

 

[Hopeless]

Ich glaub das wird nix mehr :shock:

public class Sternchen
{
int aktuelle_zeile, aktuelle_spalte;
char star= '*';
char leer = '_';
int sterne;

char[][] tabelle; 

   public Sternchen(int anzahl_sterne) 
  {
      
      anzahl_sterne=sterne;
   tabelle = new char[sterne][sterne]; 
   
   
} 

void sterneAnzeigen()
{
for ( aktuelle_zeile=0;aktuelle_zeile<sterne;aktuelle_zeile++)
for ( aktuelle_spalte=0;aktuelle_spalte<sterne;aktuelle_spalte++)

    if (aktuelle_zeile ==aktuelle_spalte)
    tabelle[aktuelle_zeile][aktuelle_spalte]=star;
    else
    tabelle [aktuelle_zeile][aktuelle_spalte]=leer; 

    System.out.print(tabelle[sterne][sterne]);
   }}

 

[Hopeless]

Ich krieg das nicht hin, dass ich in der Methode sterneAnzeigen() auch die Variable die ich im Konstruktor eingelesen hab verwenden kann

 

[DaKo]

Dieses Programm dürfte nichts ausgeben, da du im Konstruktor anzahl_sterne (was du nicht brauchst) überschreibst

 

[moormaster]

public class Sternchen
{
 int aktuelle_zeile, aktuelle_spalte;
 char star= '*';
 char leer = '_';
 int sterne;

 char[][] tabelle;

 public Sternchen(int anzahl_sterne)
 {
  sterne=anzahl_sterne;
  tabelle = new char[sterne][sterne];
  
  for ( aktuelle_zeile=0;aktuelle_zeile<sterne;aktuelle_zeile++)
  {
   for ( aktuelle_spalte=0;aktuelle_spalte<sterne;aktuelle_spalte++)
   {
    if (aktuelle_spalte == aktuelle_zeile)
     tabelle[aktuelle_zeile][aktuelle_spalte]=star;
    else
     tabelle [aktuelle_zeile][aktuelle_spalte]=leer;
   }
  }
 }

 public String toString()
 {
  String res = "";
  
  for (int j=0;j<tabelle.length;j++)
  {
   for (int i=0;i<tabelle[j].length;i++)
   {
    res += tabelle[j][i];
   }
   
   res += "\n";
  }
  
  return res;
 }
}

public class Main
{
 public static void main(String[] args)
 {
  System.out.println(new Sternchen(6).toString());
 }
}

In Zeile 13 von deinem geposteten Quelltext muss es genau andersherum stehen:

sterne = anzahl_sterne;

anstatt

anzahl_sterne=sterne;

Ich hab das mal ein wenig korrigiert... Das Anlegen des Arrays gehört in den Konstruktor. Wenn du das schon in einer extra Methode machst, dann sollte diese auch vom Konstruktor aus aufgerufen werden. Das Anlegen des Arrays hat nix mit der Ausgabe zu tun, von daher ist sterneAnzeigen ein unsinniger Bezeichner für eine solche Methode

Die Ausgabe der Sterne gehört da auch nicht rein; dafür macht man sich ne extra Methode, die im Idealfall nicht gleich die Sterne ausgibt, sondern als String zurückgibt. Dann kann man diesen String hinterher ausgeben, wo man ihn braucht.

Die Bedingung, wann ein Stern und wann ein Leerzeichen kommt, habe ich mal nicht verändert... die tut nämlich noch nicht, was sie soll

 

[Hopeless]

Zu der If-Anweisung: (noch ein Versuch)

if (aktuelle_zeile <= aktuelle_spalte)
     tabelle[aktuelle_zeile][aktuelle_spalte]=star;
    else
     tabelle [aktuelle_zeile][aktuelle_spalte]=leer;

Ich weiß stimmt sicher immernoch nicht aber einen Versucht isses Wert. :x

 

[moormaster]

Geht schon in die richtige Richtung... ist nur nicht ganz richtig

Zeichne doch mal ein Beispiel auf... z.B. für ein 4x4 Feld... dann schreibst du mal die Koordinaten von jedem Stern untereinander... dann siehst du, wie Zeilen und Spaltennummer miteinander zusammenhängen bzgl der Entscheidung ob * oder Leerzeichen.

 

[Hopeless]

Kann es sein dass die Zeilennummer auch gleichzeitig die anzahl der * ist die in dieser Zeile stehen?

 

[moormaster]

Kann es sein dass die Zeilennummer auch gleichzeitig die anzahl der * ist die in dieser Zeile stehen?

Ja sicherlich ist das so... aber das allein reicht nicht, um festzulegen, wann in ein Feld an Stelle (i,j) ein * reingehört.

Guck dir doch mal die Spaltennummern an über all wo ein * steht und dann guck, ob Spalte und Zeilennummer in irgendeiner Weise zusammenhängen... kann doch nun wirklich nicht so schwer sein, wenn du einfach mal richtig drüber nachdenkst...

 

[Lupo4u2]

Es sollte dir eigentlich helfen wenn du einfach mal die Werte der aktuellen zeile & der aktuellen Spalte ausgibt. So in etwa:

for ( aktuelle_zeile=0;aktuelle_zeile<sterne;aktuelle_zeile++)
  {
   // die aktuelle zeile ausgeben
   System.out.println("\nzeile: "+aktuelle_zeile);
   for ( aktuelle_spalte=0;aktuelle_spalte<sterne;aktuelle_spalte++)
   {
    // hab die Abfrage mal auskommentiert, weil sie für die Ausgabe nicht wichtig ist
    //if (aktuelle_spalte == aktuelle_zeile)
    // tabelle[aktuelle_zeile][aktuelle_spalte]=star;
    //else
    // tabelle [aktuelle_zeile][aktuelle_spalte]=leer;*/

    // die Spalten ausgeben
    System.out.print("s"+aktuelle_spalte+"\t");
   }
  }

 

[Hopeless]

So hab die If-Anweisung nochmal angepasst:

public class Sternchen
{
int aktuelle_zeile, aktuelle_spalte;
char star= '*';
char leer = '_';
int sterne;

char[][] tabelle;

public Sternchen(int anzahl_sterne)
{
  sterne=anzahl_sterne;
  tabelle = new char[sterne][sterne];
 
  for ( aktuelle_zeile=0;aktuelle_zeile<sterne;aktuelle_zeile++)
  {
   
   for ( aktuelle_spalte=0;aktuelle_spalte<sterne;aktuelle_spalte++)
   {

    if (aktuelle_spalte <= aktuelle_zeile)
    tabelle[aktuelle_zeile][aktuelle_spalte]=star;
   else
     tabelle [aktuelle_zeile][aktuelle_spalte]=leer;

    
    System.out.print(tabelle[aktuelle_zeile][aktuelle_spalte]);
   }
  } }
}

Allerding gibt er mir die Sterne (bei print) so aus:

*__**_***

Und bei println:

*
_
_
*
*
_
*
*
*

Hmm

 

[DaKo]

print macht gar keinen Zeilenumbruch und println macht am Ende einen Zeilenumbruch. Du musst also schauen, wo du denn den Zeilenumbruch beötigst.

 

[Leroy42]

public class Sternchen  { 
final char star= '*'; 
final char leer = '_'; 

  public Sternchen(int sterne) { 
    char [][] tabelle = new char[sterne][sterne]; 
    for (int aktuelle_zeile=0;aktuelle_zeile<sterne;aktuelle_zeile++) { 
      for (iont aktuelle_spalte=0;aktuelle_spalte<sterne;aktuelle_spalte++) { 
        tabelle[aktuelle_zeile][aktuelle_spalte] = aktuelle_spalte <= aktuelle_zeile ? star : leer;
        System.out.print(tabelle[aktuelle_zeile][aktuelle_spalte]); 
      }
      System.out.println();
    }
  }
}

 

[Hopeless]

Vielen DANK an euch alle, dass ihr mir geholfen habt !!

ES GEHT *freu* und geschnallt hab ich das jetzt auch :toll: :toll: :toll: :toll: :toll: :toll:

Greetz Hopeless :applaus:

 

[Lupo4u2]

das war aber auch ne schwere geburt...

Hast du das mit dem Spiegel & Drehen jetzt auch schon?

 

[Hopeless]

Hab erstmal noch die _ durch Leerzeichen ersetzt.

Was ich bisher noch hab ist Vertikal Spiegeln:

****
 ***
  **
   *

 

[Hopeless]

*g* sorry meinte Horizontal

 

[Leroy42]

Was ich bisher noch hab ist Vertikal Spiegeln:

****
 ***
  **
   *

Das ist die Ausgabe? :shock:

Naja, haut mich irgendwie noch nicht so richtig vom Hocker. ( )

 

[Hopeless]

Sorry der Code Tag hats verschoben, normalerweise ist alles richtig untereinander(so wie das sein soll)

:wink:

****
***
**
*

Irgendwie kann ich das hier nicht richtig einfügen *lol*[/code]