# Bruchzahlen im Array ausgeben



## El Kabong (1. Sep 2010)

> Definieren Sie ein double-Feld der L¨ange 20 und belegen Sie die Komponentenmit denWerten 1,
> -1/3, 1/5, -1/7, 1/9.....




```
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.


----------



## eRaaaa (1. Sep 2010)

El Kabong hat gesagt.:


> nur eins und das ist das meine CPU-Auslastung auf 100% steigt.
> [...]
> 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


----------



## dirk1970 (1. Sep 2010)

El Kabong hat gesagt.:


> ```
> public class Bruchzahlen {
> public static void main(String[] args) {
> 
> ...



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_


----------



## El Kabong (1. Sep 2010)

```
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

```
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.


----------



## eRaaaa (1. Sep 2010)

El Kabong hat gesagt.:


> Ich hab mal an dem Code ein bißchen rumgespielt und schon mal herausgefunden wenn ich bei
> 
> ```
> bruch[j] = ergebnis;
> ...



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...._


----------



## El Kabong (1. Sep 2010)

```
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.


----------



## eRaaaa (1. Sep 2010)

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...


----------



## Landei (1. Sep 2010)

Am einfachsten ist es,  bei jedem Schleifendurchlauf

```
zaehler *= -1;
```
zu machen.


----------



## El Kabong (1. Sep 2010)

```
public class Bruchzahlen {
	public static void main(String[] args) {

		double[] bruch = new double[20];
		double nenner = 1;
		double zaehler = 1;
		double ergebnis = 0;
		int vorzeichen = 1;

		for (int i = 0; i < 20; i++) {
			ergebnis = zaehler / nenner * vorzeichen;
			nenner += 2;
			
			bruch[i] = ergebnis;

			if (vorzeichen == 1) {
				vorzeichen = -1;
			} else {
				vorzeichen = 1;
			}
			System.out.println(bruch[i]);
		}
	}
}
```

So müsste es jetzt richtig sein. 
Danke an euch!


----------



## dirk1970 (1. Sep 2010)

Landei hat gesagt.:


> Am einfachsten ist es,  bei jedem Schleifendurchlauf
> 
> ```
> zaehler *= -1;
> ...



ok, ok
ist natürlich schöner...


----------

