# Zeichen darstellung



## Micha8989 (15. Okt 2009)

Ich hab ne frage zu meinen Aufgaben, und zwar habe ich folgende aufgabenstellung:

Schreiben Sie ein Programm, das zu einer als Konstanten vorgegebenen Zahl n ein
Balkendiagramm mit n Balken wie nachstehend dargestellt ausgibt. Im Beispiel
wurde n=20 gewählt.
# 1
## 2
### 3
#### 4
##### 5
###### 6
####### 7
######## 8
######### 9
########## 10
######### 9
######## 8
####### 7
###### 6
##### 5
#### 4
### 3
## 2
# 1
0

Hab auch schon fast alles fertig, hier ma der Quellcode:

```
class Aufgabe14
{
    public static void main()
    {
        final int N= 20;
        int x;
        char y= 0x23;
        int c=0;
             for (x=1; x<=N; ++x)
                {
                    if (x%N<=(N/2) && x%N!=0)
                        {
                            System.out.println(y+ " "+ x );
                        }
                     else 
                        {
                            c=c+2;
                            System.out.println (y + " " + (x-c));
                        }
                }
    }
}
```

Bekomme aber die # zeichen nicht hin, bin noch anfänger in java^^
Habs mit \u0023 * (x-c) vresucht klappt aber leider nicht...
Hoffe mir kann einer helfen


----------



## SlaterB (15. Okt 2009)

char y= '#';

kannst dir noch den int-Wert ausgeben lassen und nach Hex umrechnen, falls dir 0x lieber ist


----------



## micha8989 (15. Okt 2009)

Die # bekomme ich hin, aber ich muss ja für z.B x=5 folgendes darstellen:
##### 5
im prinzip müsste ich ja nur mein y*x nehmen, bzw für Rückwärts y* (x-c)


----------



## SlaterB (15. Okt 2009)

String * 5, in manch höheren Sprachen als Java geht das wohl sogar 
in Java brauchst du aber z.b. ne Schleife von 0 bis 5 die je einmal das Zeichen ausgibt


----------



## Micha8989 (15. Okt 2009)

So hab es jetzt soeit fertig:


```
class Aufgabe14 //° Balkendiagramm mit N als Konstante; x,z als Schleifenzähler und c als Bestimmungsvarialble
{
    public static void main()
    {
        final int N= 11;
        int x;
        char y= '#';
        int c=0;
        int z;
             for (x=1; x<=N; ++x)                                 //* Hauptschleife Beginn
                {
                    if (x%N<=(N/2) && x%N!=0)
                                 {
                                     for (z=1; z<=x;++z)                    //* Nebenschleife beginn
                                        {
                                            System.out.print(y);        // Ausgabe von "#"
                                        }                                               //* Nebenschleife ende
                                   {
                                       System.out.println (" " +x);     //* Ausgabe der Zählstelle
                                    }
                                } 
                            
                     else 
                            {
                                c=c+2;
                                    for (z=N; z>x || x==N;--z)      // Beginn Nebenschleife
                                        {
                                            if (x<N)
                                                {
                                                    System.out.print (y);   // Ausgabe "#"
                                                }
                                            else
                                                {
                                                    System.out.print ("0"); // Ausgabe 0 --> Nur bei x>=N
                                                    x=N+1;                      // Keine Bedeutung, nur damit es keine Endlosschleife wird
                                                }
                                         }                          // Ende Nebenschleife
                                         if (x!=N+1)                // Damit am ende nur "0" steht
                                            {
                                                System.out.println ( " " +(x-c));
                                            }
                            }
                        
                }               // Ende Hauptschleife
    }
}
[/Java]

kann man die evtl noch kürzen?
```


----------



## eRaaaa (15. Okt 2009)

```
public static void main(String... args) {
		char y= '#';
		print(y, 5);  //  5 mal # ausgeben
	}

public static void print(char zeichen, int anzahl){
		char[] zeichenArray = new char[anzahl];
		Arrays.fill(zeichenArray, zeichen);
		System.out.println(zeichenArray);
	}
```



/edit: ach ich lahme ente


----------



## SlaterB (15. Okt 2009)

kürzer wäre beispielsweise

```
public class Test
{
    public static void main(String[] args)
    {
        final int N = 20;
        char y = '#';

        final int nHalb = N / 2;
        for (int x = 1; x <= N; ++x) 
        {
            int anzahlSterne = x;
            if (x > nHalb)
            {
                anzahlSterne = N - x;
            }
            for (int z = 1; z <= anzahlSterne; ++z)
            {
                System.out.print(y); // Ausgabe von "#"
            }
            if (anzahlSterne > 0)
            {
                System.out.print(" ");
            }
            System.out.println(anzahlSterne);

        }
    }
}
```

Denkweise: nichts doppelt machen, die #-Schleife braucht bestimmt nur genau einmal gecodet werden,
vorher eben deren Anzahl für alle Fälle ausrechnen

falls doch doppelt nötig: in einer Untermethode auslagern!, diese dann mehrmals aufrufen


----------

