Logisches Problem (Blutiger Anfänger)

[StupidAttack]

Hallo liebe Java Community

Ich beschäftige mich nun seit 2 Wochen autodidaktisch mit Java, da ich Kenntnisse von
Programmiersprachen für die immer rascher vernetzte Gesellschaft als ein Muss betrachte.

Bis hierher habe ich keine grösseren Probleme gehabt, doch nun bin ich in einen logischen Sumpf geraten.

Die Aufgabe:

Schreiben Sie ein Programm, das einen Baum aus Sternen auf den Bildschirm ausgibt:
*
***
*****
*******
*********
***********
*************
***************
***
***
***

Unglücklich formatiert; ich weiss.

Diese Aufgabe will ich mit While-Schleifen meistern. Soweit bin ich gekommen (folgender Code ist fehlerfrei compilierbar):

import java.io.*;
class Baum		//Dieses Programm berechnet X hoch N
{	
	public static void main( String [] args) throws IOException
	{
	BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in));

	String Einlesen;
 	int N;
	int zaehler1 = 1;
	int zaehler2;
	int N2;
	

	System.out.println("Geben sie nun die Baumbreite ein! (ungerade ZAHL!)");
	Einlesen = stdin.readLine();
	N = Integer.parseInt(Einlesen);
	
	while ( N >= 1)
	{
	
	while ( N >=zaehler1)
	{
	
	
	System.out.print("*");
	zaehler1 = zaehler1 + 1;
	}
	N = N - 2;
	zaehler1 = 1;
	System.out.println();
	}
	

	
	
	
	}
}

Dieses Programm gibt eine umgekehrte Piramidenhälfte ohne Baumstamm aus. Die Baumbreitenhälfte soll kann der Benutzer eingeben. Alao vereinfacht gesagt so etwas:

***********
*********
*******
*****
***
*
usw.


Konkret habe ich nun folgendes Problem: Ich kriege es hin eine While Schleife zu coden die die korrekte Zahl Sterne ausgibt. Doch ich weiss nicht wie ich das Setzen der Leerzeichen vor und nach den Schleifen einbauen soll. Folgendes Grundgerüst habe ich mir überlegt:

...
BLUB = 1;


while ((N-3) >= zaehler1 ) // (N-3) ist die genaue Anzahl Zeilen für einen Baum mit Baumbreite N
{
While()
{
//Leerzeichen ausgeben
}


While(zaehler1> = BLUB)
{
System.out.println("*"); // Gibt die Sterne (*) aus.

BLUB = BLUB +0.5;
}

While()
{
//Leerzeichen ausgeben
}



zaehler1 = zaehler1+1;
BLUB = 1;
System.out.println();
}


Also: Die äusserste Schleife legt fest wie viele Zeilen erstellt werden. Die erste und dritte While Schleife gibt die Leerzeichen aus. Die zweite Schleife gibt die Sterne aus.

Nun die Frage: Wie kann ich die 1. und 3. Schleife mit dem inkrement zaehler1 so verknüpfen dass die
Leerzeichen nach der Bedingung (Leerzeichen = N - Sterne ) ausgegeben werden...?

Oder ist der Ansatz komplett falsch?

Ich bin dankbar für jede Hilfe und wünsche euch allen schöne Osterfeiertage...

 

[thomasmk]

Schreiben Sie ein Programm, das einen Baum aus Sternen auf den Bildschirm ausgibt:

Setze doch [ code ] - tags, dann kann man auch sehen, was denn eigentlich rauskommen soll:

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

class Baum		//Dieses Programm berechnet X hoch N

Und ich dachte das Programm zeichnet einen Baum ;-)

	String Einlesen;
 	int N;
	int zaehler1 = 1;
	int zaehler2;
	int N2;

Nur ein kleiner Hinweis am Rande: laut Convention beginnen Klassennamen mit einem Großbuchstabe und Variablennamen mit einem Kleinbuchstabe. Den Konventionen enstprechend wäre dies dann:

	String einlesen;
 	int n;
	int zaehler1 = 1;
	int zaehler2;
	int n2;

Konkret habe ich nun folgendes Problem: Ich kriege es hin eine While Schleife zu coden die die korrekte Zahl Sterne ausgibt. Doch ich weiss nicht wie ich das Setzen der Leerzeichen vor und nach den Schleifen einbauen soll.

Vor UND nach den Schleifen? Es reicht doch nur vor. Oder willst du auch auf der rechten Seite des Baums Leerzeichen setzen? Gut, das würde nicht schaden, aber die Leerzeichen vor dem Zeilenende sieht man ja normalerweise nicht.

Folgendes Grundgerüst habe ich mir überlegt:

...
BLUB = 1;


while ((N-3) >= zaehler1 ) // (N-3) ist die genaue Anzahl Zeilen für einen Baum mit Baumbreite N
{
While()
{
//Leerzeichen ausgeben
}

Also: Die letzte Zeile vom Baum (vergessen wir den Stamm erstmal) bekommt wieviele Leerzeichen vorangestellt? Ich würde sagen 0. Und die vorletzte Zeile? ich würde sagen 1 Leerzeichen. Und davor 2 und davor 3. Die x-te Zeile bekommt also n-x Leerzeichen vorangestellt, wobei n die Anzahl der Zeilen ist. n in meiner Rechnung ist bei dir wohl N-3 und x ist bei dir zaehler 1.
Reicht das als Gedächtnisanstubs?

 

[StupidAttack]

Also: Die letzte Zeile vom Baum (vergessen wir den Stamm erstmal) bekommt wieviele Leerzeichen vorangestellt? Ich würde sagen 0. Und die vorletzte Zeile? ich würde sagen 1 Leerzeichen. Und davor 2 und davor 3. Die x-te Zeile bekommt also n-x Leerzeichen vorangestellt, wobei n die Anzahl der Zeilen ist. n in meiner Rechnung ist bei dir wohl N-3 und x ist bei dir zaehler 1.
Reicht das als Gedächtnisanstubs?

Danke Dir!

Und ja du hast recht, einmal eine Leerzeichen-Schleife reicht vollkommen, da hat sich bei mir wohl die Logik schon deutlich früher verabschiedet...

Und ja du hast mir auch sehr geholfen, das Ding schreibe ich noch heut fertig, wär ja gelacht ohne Sterne schlafen zu gehen!

Nochmals Danke...

 

[StupidAttack]

Ich habe mich wohl gestern übernommen. Heute morgen einen frischen Versuch gestartet und von Grund auf alles nochmals überlegt. Kannst du das so bestätigen?


Leerzeichen Sterne (*)
1.Zeile n-1 n-(n-1)
2.Zeile n-2 n-(n-3)
3.Zeile n-3 n-(n-5)
4.Zeile n-4 n-(n-7)
5.Zeile n-5 n-(n-9)
X.Zeile n-x n-(n-(2x-1)) = 2x-1

n-(n-(2x-1)) = n-(n-2x+1) = n-n+2x-1= 2x-1

Weswegen ich da das n mit reingenommen habe ist komisch...

Jedenfalls habe ich folgendes, fehlerfrei compilierbares Programm erstellt, welches den Baum ohne Strunk zeichnet:

import java.io.*;
class Baum		//Dieses Programm macht nen hübschen Baum
{	
	public static void main( String [] args) throws IOException
	{
	BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in));

	String Einlesen;
	int x = 1;
	int n;
	int zaehler = 1;
	int zaehler2 = 1;
	

	System.out.println("Geben sie nun die Baumbreite ein! ");
	Einlesen = stdin.readLine();
	n = Integer.parseInt(Einlesen);
	
	while ( n >= x)
	{
	
		while ( (n-x) >= zaehler )
		{
		System.out.print(" ");
		zaehler = zaehler + 1;	
		}


		while ( (2*x-1) >= zaehler2 )
		{
		System.out.print("*");
		zaehler2 = zaehler2 + 1;	
		}
		


	

	zaehler = 1;
	zaehler2 = 1;
	x = x + 1; 

	System.out.println();
	
	
	}
	
	
	}
}

Ps: Quellcode ist lizenzfrei allen zugänglich

 

[Java.getSkill()]

hi,

Du solltest viel aussagekräftigere Variablennamen benutzen. In 3 Tagen hast du 0 Plan was x, n, oder z war.

Die Lösungsidee hat mir aber sehr gut gefallen .
Den ersten Stern finden und dann die restlichen in dieser Zeile dazuschreiben.



[XML]Wie hoch ist der Baum?

10
Baumstammbreite?
4
*
***
*****
*******
*********
***********
*************
***************
*****************
*******************
****
****
****[/XML]

package baum;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ZeichneBaum {

	public static void main(String[] args) throws Exception, IOException {
		
	   BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in));

		int spaltencounter=1;
		
		System.out.println("Wie hoch ist der Baum?\n");
		int baumhoehe=Integer.parseInt(stdin.readLine());
		
		System.out.println("Baumstammbreite?");
		int baumStammBreite=Integer.parseInt(stdin.readLine());
		//startpunkt ab welchem Stern der Baumstamm anfangen soll
		int startpunkt =((baumhoehe*2-1)-baumStammBreite)/2;

		
		for(int zeile=1;zeile<=baumhoehe;zeile++){
			
			for(int spalte=1;spalte<=(baumhoehe*2)-1;spalte++){
							
				if(baumhoehe>spaltencounter){
					System.out.print(" ");
					spaltencounter++;}
					}
			
			int sterne =1;
			while(sterne<=(zeile*2-1)){
				System.out.print("*");
				sterne++;
			}
						
			spaltencounter=zeile+1;
			System.out.println();
			
	
		if (zeile==baumhoehe){
			zeichneBaumStamm( baumhoehe);
			
		for(int baumStammHoehe=1;baumStammHoehe<4;baumStammHoehe++){
			for(int spalteBaumStamm=1;spalteBaumStamm<baumhoehe*2-1;spalteBaumStamm++){
			
			if(spalteBaumStamm<=startpunkt){
			System.out.print(" ");
			}else if(spalteBaumStamm<=startpunkt+baumStammBreite){
				System.out.print("*");
			}
		}
		System.out.println();
		}		
	}
	}
			
	}

	private static void zeichneBaumStamm(int baumhoehe) {
		
		
}
}
/*

import java.io.*;
public class ZeichneBaum      //Dieses Programm macht nen hübschen Baum
{   
    public static void main( String [] args) throws IOException
    {
    BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in));
 
    String Einlesen;
    int x = 1;
    int baumhoehe;
    int zaehler = 1;
    int zaehler2 = 1;
    
 
    System.out.println("Geben sie nun die Baumbhoehe ein! ");
    Einlesen = stdin.readLine();
    baumhoehe = Integer.parseInt(Einlesen);
    
    while ( baumhoehe >= x)
    {
    
        while ( (baumhoehe-x) >= zaehler )
        {
        System.out.print(" ");
        zaehler = zaehler + 1;  
        }
 
 
        while ( (2*x-1) >= zaehler2 )
        {
        System.out.print("*");
        zaehler2 = zaehler2 + 1;    
        }
        
 
    zaehler = 1;
    zaehler2 = 1;
    x = x + 1; 
 
    System.out.println();
    
    
    }
    
    
    }
}
*/

 

[StupidAttack]

Danke für die Mühe! Obwohl ich noch nicht alles verstehe sehe ich die Idee hinter dem Code...

Ich denke dieses Thema hat sich geklärt...

Ps: ich konnte nicht früher antworten; war bis eben verreist.