A :10000001000200100000000000
B :10000001*000200100000000000
C :100000010002**00100000000000
D :10000001000200100000000000
E :10000001*000200100000000000
F :100000010002**00100000000000
G :10000001000200100000000000
H :10000001*000200100000000000
I :100000010002**00100000000000
J :10000001000200100000000000
K :10000001*000200100000000000
L :100000010002**00100000000000
M :10000001000200100000000000
N :10000001*000200100000000000
O :100000010002**00100000000000
P :10000001000200100000000000
Q :10000001*000200100000000000
R :100000010002**00100000000000
S :10000001000200100000000000
T :10000001*000200100000000000
U :100000010002**00100000000000
V :10000001000200100000000000
W :10000001*000200100000000000
X :100000010002**00100000000000
Y :10000001000200100000000000
Z :10000001*0002001*00000000000
public static void main(String[] args) {
//int buch = new buch[26];
String eingabe = "HALLO";
StringBuffer text = new StringBuffer(eingabe);
int lang = eingabe.length();
int buch[] = new int[26];
for(int i=0;i<26;i++)
{
buch**=0;
}
for (int i=0;i<lang;i++)
{
int z= (int) text.charAt(i);
z= z-65;
buch[z] =buch[z]+1;
}
for(int i =65;i<=90;i++)
{
System.out.print((char) i +" :");
for(int j=0;j<26;j++)
{
System.out.print(buch[j]);
if(buch[j]>0)
{
for(int k = 0;k<buch[j];k++)
{
System.out.print("*");
}
}
}
System.out.println();
}
}
}```
danke euch vielmals
so wie ich das sehe macht Deine Methode einfach zu viel. Die einzige Information die Du brauchst ermittelst Du in Zeile 12. Den ganzen Rest kannst Du im Wesentlichen vergessen. Das Einzige was Du davon brauchts ist die Schleife in Zeile 26 und darin die Ausgabe aus Zeile 46. Dann noch mal abschließend 'nen Zeilenumbruch nach der Schleife ausgeben und fertig…
Ich glaube, ich habe das falsch verstanden…
Also muss ich fragen: warum läufts Du in Zeile 39 nochmal duch alle Buchstaben anstatt duch die Anzahl der gezälten?
public static void main(String[] args) {
// int buch = new buch[26];
String eingabe = "HALLO";
int lang = eingabe.length();
int buch[] = new int[26];
for (int i = 0; i < lang; i++) {
int z = (int) eingabe.charAt(i);
z = z - 65;
buch[z] = buch[z] + 1;
}
for (int i = 65; i <= 90; i++) {
System.out.print((char) i + " :");
for (int j = 0; j < 26; j++) {
if (buch[j] > 0) {
for (int k = 0; k < buch[j]; k++) {
System.out.print("*");
}
}
}
System.out.println();
}
}
}```
in der ausgabe habe ich bei alle Buchstaben 4 Sterne, dabei wenn buch buch[j] ==0 wird doch nicht in die Schleife gehen und deswegen auch kein stern ausgeben
>
> A :*****
> B :*****
> C :*****
> D :*****
aber Ausgabe für HALLO soll so aussehen
A: *
B:
C:
D:
E:
...
H:*
.
.
L:**
O:*
...
Z:
int z = (int) eingabe.charAt(i);
z = z - 65;
buch[z] = buch[z] + 1;
}```
zuerst gebe ich Buchstabe aus , dann laufe ich buch Array und gebe nur in dem Fall Sterne aus wenn die Anzahl der Buchstabe mehr als 0 ist
```for (int i = 65; i <= 90; i++) {
System.out.print((char) i + " :");
for (int j = 0; j < 26; j++) {
if (buch[j] > 0) {
for (int k = 0; k < buch[j]; k++) {
System.out.print("*");
}
}
}```
was ist hier überflüssig? wenn Buchstabe nicht vorhanden ist also buch[j]=0 warum geht in der if (buch[j] > 0) rein?
jetzt müsstest du lediglich buch[indexFürA] anschauen, alle anderen Array-Plätze interessieren nicht, nur dieser einer,
du durchläufst aber sämtliche Buchstaben, die j-Schleife kommt bei A vorbei, malt einen Stern, kommt bei B vorbei, malt keinen Stern, usw., insgesamt 5 Sterne,
immer, für jedes i, weil immer alle 26 Array-Plätze angeschaut werden, statt nur des einen für den aktuellen Buchstaben
statt buch[z] = buch[z] + 1; geht übrigens auch buch[z]++;,
bei Arrays mit evtl. komplizierten Index bietet sich das besonders an,
spart doppeltes Hinschreiben, vermeidet Fehler
die j-Schleife muss weg, der Code darin zur Buchstaben-Verarbeitung bleibt,
aber nicht für den j-Arrayplatz, denn die j-Schleife ist ja weg, einfach den aktuell richtigen Arrayplatz ,
fange an den Code auf buch[0] umzustellen, dann läuft es schon mal ohne j,
gibt immer das an Arrayplatz 0 aus (ein Stern für A),
den richtigen Arrayplatz zum aktuellen Buchstaben i zu bestimmen, das ist deine Aufgabe,
eine Schleife j ist jedenfalls nicht dabei, i sagt den Buchstaben an -> einen Arrayplatz auswählen
komisch dass du es weiter oben so leicht geschafft hast, da hast zu z für einen Buchstaben
und kannst dann eine konkrete Arrayplatz bestimmen um diese zu erhöhen,
ganz ohne Schleife über aller Arrayplätze
ich betone das alles so bewußt, denn genau diese Aufgabe hier, dies zu lösen, ist eine der wichtigsten Programmierfähigkeiten,
solche Dinge einfach durchdenken zu können brauchst du mehr als tausend Klassen zu kennen,
die kann man alle nachschlagen, das hier nicht
for (int i = 65; i <= 90; i++) {
System.out.print((char) i + " :");
char buchstabe = (char) i;
int zahl = (int)buchstabe - 65;
if (buch[zahl] > 0 && zahl < 26) {
for (int k = 0; k < buch[zahl]; k++) {
System.out.print("*");
}
}
System.out.println();
}
a) Die vielen Zahlen: 26, 90, 65 - man braucht sie nicht und sie machen das Programm schwerer lesbar als nötig
b) Wenn man die starre Begrenzung auf ‘A’ bis ‘Z’ aufgibt - und dafür mal eben ein wenig Speicher hergibt (was ja heute wo schon jedes Unterhemd 4GB RAM hat wirklich kein Problem mehr ist) - erhält man ein flexibleres und besser verständlichen Programm.
ist aber bei so einer Programmieraufgabe wahrscheinlich nebensächlich.
