Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
public class Bruchzahlen {
public static void main(String[] args) {
double[] bruch = new double[20];
double nenner = 1;
double zaehler = 1;
double ergebnis = 0;
for (int i=0; i<nenner; i++) {
nenner = i+2;
ergebnis = zaehler / nenner;
}
for (int j=0; j<bruch.length; j++) {
bruch[j] = ergebnis;
System.out.println(bruch[j]);
}
}
}
Da ich erstmal keine Idee habe wie ich von -1/3 zu 1/5 kommen soll hab ich erstmal versucht das Minuszeichen zu ignorieren. Nun, wenn ich den Code ausführe passiert nur eins und das ist das meine CPU-Auslastung auf 100% steigt. :lol:
Meine Idee war es den Nenner immer um zwei zu erhöhen und dann den Zähler durch den Nenner zu teilen um dann auf den Bruch von z.B. 1/3 zu kommen. Danach wollte ich das Ergebnis mit der zweiten For-Schleife im Array abspeichern.
Ich bräuchte einen Tipp, einen Denkanstoß in die richtige Richtung.
for (int i = 0; i < nenner; i++) {
nenner = i + 2;
Schaue dir mal deine Bedingung an und dann was du mit "nenner" machst....
Mach doch vllt die Aufgabe erstmal per Hand auf einem Blatt Papier, vllt hilft dir das ja weiter
public class Bruchzahlen {
public static void main(String[] args) {
double[] bruch = new double[20];
double nenner = 1;
double zaehler = 1;
double ergebnis = 0;
for (int i=0; i<nenner; i++) {
nenner = i+2;
ergebnis = zaehler / nenner;
}
for (int j=0; j<bruch.length; j++) {
bruch[j] = ergebnis;
System.out.println(bruch[j]);
}
}
}
Da ich erstmal keine Idee habe wie ich von -1/3 zu 1/5 kommen soll hab ich erstmal versucht das Minuszeichen zu ignorieren. Nun, wenn ich den Code ausführe passiert nur eins und das ist das meine CPU-Auslastung auf 100% steigt. :lol:
Meine Idee war es den Nenner immer um zwei zu erhöhen und dann den Zähler durch den Nenner zu teilen um dann auf den Bruch von z.B. 1/3 zu kommen. Danach wollte ich das Ergebnis mit der zweiten For-Schleife im Array abspeichern.
Ich bräuchte einen Tipp, einen Denkanstoß in die richtige Richtung.
Du erzeugst eine Endlosschleife, da Du Nenner in jedem Schleifendurchgang mehr als i erhöhst, als SchliefenBedingung aber hast, dass i<n sein soll, dies ist bei Dir immer der Fall, daher dann auch die Prozessorauslastung
Du hast generell einen Gedankenfehler in Deinem Vorgehen, warum willst Du das in zwei Schleifen machen? wenn die erste Schleife funktionieren würde, hättest Du am Ende genau einen Wert für ergebnis, diesen würdest Du dem gesamten Bruch-Array zuweisen
im Prinzip brauchst Du nur eine Schleife, die von 0-19 (steht irgendwo, dass ihr 20 Werte berechnen sollt?) geht
Nenner ist 1 + i*2 (im ersten durchlauf also 1, dann 3, dann 5 usw.)
Dein Vorzeichenproblem kriegst Du zum Beispiel mit einer int-variablen vorzeichen=1 in den Griff
bei deiner berechnung des ergebnis, nimmst Du alles noch mal vorzeichen
dann weist du bruch ergebnis zu
und am ende musst du für den nächsten durchlauf das vorzeichen noch umsetzen, z.b. wenn vorzeichen==1, dann vorzeichen =-1, sonst vorzeichen =1
das wars
public class Bruchzahlen {
public static void main(String[] args) {
double[] bruch = new double[20];
double nenner = 1;
double zaehler = 1;
double ergebnis = 0;
for (int i = 0; i < 20; i++) {
nenner += 2;
ergebnis = zaehler / nenner;
for (int j = i; j < bruch.length; j++) {
bruch[j] = ergebnis;
System.out.println(bruch[j]);
}
}
}
}
Okay, jetzt macht es mehr Sinn und es kommen die richtigen Brüche raus. Nur wird nun jeder Bruch 20-mal gespeichert. Da frag ich mich doch direkt, wie kann das sein wenn das Array doch ingesamt nur eine Länge von 20 hat.
Ich hab mal an dem Code ein bißchen rumgespielt und schon mal herausgefunden wenn ich bei
Java:
bruch[j] = ergebnis;
statt dem j eine 1 einsetze wird der Wert immer nur an der 1sten Stelle gespeichert und die anderen Felder bleiben leer.
Einfach irgendwie am Code rumzuprobieren bringt dich nicht weiter.
Du hast eine Schleife von 0 bis < 20 und innerhalb dieser Schleife hast du nochmal eine Schleife die jeweils von i bis < 20 geht.
Spiele das doch mal mit einem beliebigen i durch....dann wirst du deinen Denkfehler schon erkennen
Und der Tipp mit Papier half auch nicht?
nenner = 1;
i von 0 bis < 20{
bruch = 1/nenner;
wenn i % 2 != 0 dann bruch *= -1;
nenner um 2 erhöhen;
}
Das sollte es doch schon gewesen sein. Das jetzt noch als Java-Code überlegen....
public class Bruchzahlen {
public static void main(String[] args) {
double[] bruch = new double[20];
double nenner = 1;
double zaehler = 1;
double ergebnis = 0;
for (int i = 0; i < 20; i++) {
nenner += 2;
ergebnis = zaehler / nenner;
bruch[i] = ergebnis;
System.out.println(bruch[i]);
}
}
}
Ich hab jetzt wie dirk1970 geschrieben hat die zweite Schleife weggelassen und das Ergebnis direkt dem Array zugewiesen. Die Brüche hab ich jetzt alle raus, zumindest mit einem positiven Vorzeichen.
Zeile 11 und 12 tauschen dann sieht`s doch schon gar nicht schlecht aus
Dann wie oben schon angedeutet, musst du doch einfach nur jedes zweite (ungerade i) das Vorzeichen umdrehen...
