# Tannebaum



## ShastyMcNastee (8. November 2007)

Hi all.
Ich soll einen Tannenbaum programmieren, der bei einer Eingabe von z.B. 3 so aussehen soll:
          * 
         *** 
        ***** 
       ******* 
         *** 
        ***** 
       ******* 
      ********* 
     *********** 
        ***** 
       ******* 
      ********* 
     *********** 
    ************* 
   ***************

Es werden also 3 "Äste" generiert.

Ich bin jetzt so weit, dass mein Tannenbaum bei einer Eingabe von 3 so aussieht:

  *
 ***
*****

Quelltext:

```
import java.util.*;
public class SuperTanne
{
    
    public static void main(String[] args)
    { 
    int x,y,n;
    Scanner tastatur=new Scanner(System.in);
    System.out.println("Bitte geben Sie eine ganze Zahl zwischen 0 und 30 ein");
    n=tastatur.nextInt();
    
    if (n <=0 || n >30)
    {
        System.out.println("Fehlerhafte Zahl:" +n);
        
    }      
             
    else
    {
        
        for (x=1; x<=n ;x++)
        {
            for (y=1; y<=n-x; y++)
            {
                System.out.print(" ");
            }
            for (y=1; y<=(2*x-1); y++)
            {
                System.out.print("*");
            }
            
            
                System.out.println();
        }
            System.out.println("Tschuess");
            
        }
    
    } 

    }
```
Wie bekomme ich nun die Äste hin?
Bestimmt mit einer weiteren for-Schleife richtig?

EDIT: Oh ja sorry. Jetzt passts


----------



## MiMi (8. November 2007)

Wuerdest du deinen Source-Code bitte in [.JAVA] .. [./JAVA] packen? So ist das naemlich net sehr schoen zu lesen, bzw gar net.

```
CODE
```


----------



## MiMi (8. November 2007)

Achja du fragst ob das mit einer weiteren for schleife geht, probiers doch einfach aus


----------



## ShastyMcNastee (8. November 2007)

Hehe, ja das habe ich.
Aber entweder setze ich sie an die falsche Stelle oder die Bedingungen sind falsch.
Auf jeden Fall sieht es nie annähernd so aus wie es sein sollte. :-(

Vielleicht ein kleiner Tipp? ;-)


----------



## Tobias Köhler (8. November 2007)

kleiner Tipp: rekursives Arbeiten


----------



## MiMi (8. November 2007)

Also du brauchst fuer die "Aeste" ne for schleife und fuer jede Zeile mit Sternchen die innerhalb der Aeste-Schleife ist


----------



## MiMi (8. November 2007)

Tobias Köhler hat gesagt.:


> kleiner Tipp: rekursives Arbeiten



Naja, meistens wenn man so ne Aufgabe bekommt, hat man noch keine rekursivitaet gehabt.


----------



## ShastyMcNastee (8. November 2007)

Richtig, hatten wir noch nicht.
Bin halt blutiger Anfänger ;-)


----------



## MiMi (8. November 2007)

Dann noch nen Tipp, gib den variablen aussagekraeftige Namen , weil n und x und y sagen nich unbedingt was aus ^^. Dann solltest du dir auch im Klaren sein, was fuer ne Zahl eingegeben wird. Und schaun, was fuer regelmaessigkeiten der zu zeichnende Baum hat. Z.b. beim ersten "Ast" hast du 4 Zeilen und bei dem 2. hast du 5 beim 3. hast du dann 6.


----------



## matdacat (8. November 2007)

Beginn doch damit, dass Du eine Methode schreibst, die Dir einen Ast für ein bestimmtes Startniveau (Anzahl an Sternchen) ausgibt. Für Dein Beispiel würdest Du die dann dreimal aufrufen mit den Parametern 1, 3 und 5 - natürlich in einer for-Schleife


----------



## mki_germo (8. November 2007)

Ich nehme mal an, dass dein Tannenbaum "zentriert sein soll, also in etwa so:


```
*
      ***
     *****
    *******
      ***
     *****
    *******
   *********
  ***********
     *****
    *******
   *********
  ***********
 *************
***************
```

Um das zu erreichen, musst du dir zuerst überlegen, wie der Tannenbaum eigendlich aufgebaut ist:

- Jeder folgende Ast besteht aus jeweils einer Zeile mehr als der vorhergehende.
- Der erste Ast besteht aus 4 Zeilen.

Aus diesen Informationen kannst du die jeweilige Zeilenanzahl für einen Ast berechnen:
Anzahl Zeilen = 3 + Zweignummer

Um die Anzahl der Sterne zu berechnen, kannst du folgende Formel benutzen:
Anzahl Sterne = (Zeilennummer -1) * 2 + 1

Als nächstes benötigst du die Breite des untersten Zweiges. Aus diesem Wert kannst du dann die Anzahl der voranzustellenden Leerzeichen berechnen:

Baumbreite = (Anzahl Zweige + 3) * 2 + 1

Die Anzahl der Leerzeichen berechnet sich dann wie folgt:

Anzahl Leerzeichen = (Baumbreite - Anzahl Sterne) / 2

Jetzt musst du dir nur noch überlegen, wie du diese ganzen Informationen vernünftig in deinem Code unterbringst.


Kleiner Tipp noch:

nenn deine Variablen nicht x, y, z, sondern gib ihnen vernünftige Namen - das macht es für dich wesendlich einfacher.


----------



## ShastyMcNastee (8. November 2007)

So, jetzt sieht der Baum zumindest schon mal so aus:
  *
 ***
*****
  *
 ***
*****
  *
 ***
*****

Mit folgendem Code:

```
import java.util.*;
public class SuperTanne
{
    
    public static void main(String[]args)
    {
        int x,y,n,z;
        Scanner tastatur=new Scanner(System.in);
        System.out.println("Bitte geben Sie eine ganze Zahl zwischen 0 und 30 ein");
        n=tastatur.nextInt();
        
        if (n <=0 || n >30)
        {
            System.out.println("Fehlerhafte Zahl:" +n);
            
        }      
                 
        else
        {
            for (z=1; z<=n; z++)
            {    
                for (x=1; x<=n ;x++)
                {
                    
                    for (y=1; y<=n-x; y++)
                    {
                        System.out.print(" ");
                    }
                
                    
                
                for (y=1; y<=(2*x-1); y++)//2*x-1
                {
                    System.out.print("*");
                }
                    System.out.println();
                
            }
                
                
        }
            System.out.println("Tschuess");
    } 
    }   
}
```

Jetzt müssen nur noch die Äste entsprechend aussehen.


----------



## ShastyMcNastee (8. November 2007)

Ah ok, vielen Dank.
Werd dann noch ein wenig weiter tüfteln.

Tolles Board hier


----------



## Tobias Köhler (8. November 2007)

Naja es war ja auch nur ein kleiner Tipp, bzw Stichwort^^ Die Arbeit damit sollte sich dann ja bestimmt vereinfachen, aber sich erst einmal einlesen und eindenken in Rekursion ist nicht allzu leicht... hatte ich jedenfalls damals so empfunden


----------



## Wyatt (9. November 2007)

Heyho Tobi, 

könntest du den Tannenbaum einmal rekursiv schreiben? ich hatte bisher auch noch keine rekursive programmierung und ich halte es für eine gute Idee ;-)

Liebe Grüße
Felix


----------



## HerbertXXL (9. November 2007)

Hallo Felix,
Code-Beispiel für rekursive Algorithmen findet man im Internet ohne Ende, eines mehr hilft da auch nicht wirklich weiter.

Schwierig ist auch weniger das Erkennen der Rekursion in einem Algorithmus, 
sondern bei einem bestehenden Problem zu erkennen, daß es auf rekursiven Wege gelöst werden kann, dass es sinnvoll ist es so zu lösen und auch die Lösung selber ist sicher etwas Übungssache.

Dass es bei dieser Aufgabe möglich ist, wurde ja schon verraten,  es ist aber weiterhin eine schöne kleine Aufgabe um die Umsetzung zu üben.
Mit anderen Worten: wenn Du es wirklich lernen möchtest, suche dir Beispiele und mach es dann selber 

Viel Spaß wünscht
der Herbert


----------



## Schnacki (9. November 2007)

Ich weiß zwar nicht, ob deu das noch brauchst, aber hier wäre eine einfache rekursive Lösung:


```
public class Tannenbaum {
    int maxSize;
    public Tannenbaum(int maxSize) {
        this.maxSize = maxSize+1;
    }
    public void print() {
        printTanne(0);
    }
    private void printTanne(int size) {
        if(size<=maxSize) {
            for(int i=1; i<size+1; i++) {
                for(int j=0; j<i; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }
            printTanne(size+1);
        }
    }
    
    public static void main(String[] args) {
        Tannenbaum t = new Tannenbaum(30);
        t.print();
    }   
}
```


----------

