C Fragen zu "verschachtelten Schleifen"

12th Monkey

Cadet 3rd Year
Registriert
Feb. 2010
Beiträge
45
Ahoi ich bins schon wieder...

ich hoffe es ist in Ordnung, dass ich hier meine mittlerweile dritte C Anfrage wegen Übungen stelle - wenn nicht gebt einfach bescheid, dann wird das hier meine letze Anfrage sein!?

Diesmal geht es um eine "verschachtelte Schleife". Undzar sollen in zwei Feldern (a und b) jeweils 100 Zufallszahlen erstellt werden und im Ablauf des Programmes sollen verschiedene Dinge mit diesen Zufallszahlen angestellt werden.
Das eigentliche Problem dabei ist, dass ja in jedem Schritt die Zahlen verändert werden und somit das Programm während des Ablaufes immer "falscher" wird (ich hoffe ihr wisst was ich damit meine).
Um das zu umgehen erstelle ich vor jedem neuen Ablauf neue Zufallszahlen aber irgendwie ist das glaube ich nicht so im Sinne des Erfinders.

Hier ist das bisherige Resultat (es läuft durch und gibt keine Fehlermeldungen aus - aber stimmen tut es leider hinten und vorne nicht):

Code:
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

	int main( void )	{

	    const int size = 200; 

		float kleinste_zahl_1, kleinste_zahl_2, kleinste_zahl_3, groesste_zahl_1, groesste_zahl_2, groesste_zahl_3, a_werte_plus_b_werte;
		float gesamtzahl_1, gesamtzahl_2, gesamtzahl_3, mittelwert_1, mittelwert_2, mittelwert_3, gesamt_a, gesamt_b;
		float a[size], b[size];

		int i, x, y;

		kleinste_zahl_1 = RAND_MAX; groesste_zahl_1 = 0;
		kleinste_zahl_2 = RAND_MAX;	groesste_zahl_2 = 0;
		kleinste_zahl_3 = RAND_MAX;	groesste_zahl_3 = 0;

		gesamtzahl_1 = 0; gesamtzahl_2 = 0; gesamtzahl_3 = 0;
		gesamt_a = 0; gesamt_b = 0;


		//Aufgabenteil 1 - Minimum, Maximum und Mittelwert des Feldes a berechnen...

			for (i = 0; i <= size; i++)											{	
				a[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld a erzeugen
				b[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld b erzeugen
				
			gesamtzahl_1 += a[i];													//Gesamtwert der aufaddierten a's ausrechnen
			mittelwert_1 = gesamtzahl_1 / size;										//Mittelwert aller addierten a's ausrechnen

			if (a[i] < kleinste_zahl_1)			{ kleinste_zahl_1 = a[i]; }			//Bestimmen des kleinsten Wertes aus den Zufallszahlen in Feld a
			else if (a[i] > groesste_zahl_1)	{ groesste_zahl_1 = a[i]; }		}	//Bestimmen des größten Wertes aus den Zufallszahlen in Feld a

						
		//Aufgabenteil 2 - Addiere elementweise die Werte aus a und b, speichere die resultierenden Werte wieder in a, Berechne dann wieder Minimum, Maximum und Mittelwert...
			
			for (i = 0; i <= size; i++)											{	
				a[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld a erzeugen
				b[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld b erzeugen

			gesamtzahl_2 = (gesamt_a += a[i]) + (gesamt_b += b[i]);					//Gesamtwert aller addierten a's und b's ausrechnen
			mittelwert_2 = gesamtzahl_2 / size;										//Mittelwert aller addierten a's und b's ausrechnen

			if (a[i] < kleinste_zahl_2)	{ kleinste_zahl_2 = x;						//Bestimmen der kleinsten Zahl aus Feld a und Feld b
				if (b[i] < x )			{ x = a[i];				}}

			if (a[i] < groesste_zahl_2)	{ groesste_zahl_2 = y;						//Bestimmen der größten Zahl aus Feld a und Feld b
				if (b[i] > y )			{ x = a[i];				}}				}
				
			
		//Aufgabenteil 3 - Quadriere die Werte im Feld b und bestimme wiederum Minimum, Maximum und Mittelwert.

			for (i = 0; i <= size; i++)											{	
				a[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld a erzeugen
				b[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld b erzeugen

			gesamtzahl_3 *= b[i];													//Gesamtwert aller quadrierten b's ausrechnen		
			mittelwert_3 = gesamtzahl_3 / size;										//Mittelwert aller quadrierten b's ausrechnen

			if (b[i] < kleinste_zahl_3)	{ kleinste_zahl_3 = b[i]; }					//Bestimmen der kleinsten Zahl der quadrierten b's
			if (b[i] > groesste_zahl_3)	{ groesste_zahl_3 = b[i]; }				}	//Bestimmen der größten Zahl der quadrierten b's
			
				
				printf("Es wurden insgesamt %d Zufallszahlen erzeugt\n\n", 2*size);
				printf("Alle Werte aus Feld a addiert ergeben: %.2f\n\n", gesamtzahl_1);
  				printf("Die kleinste Zufallszahl aus Aufgabenteil 1 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 1 ist: %.2f\nDer Mittelert aus Aufgabenteil 1 ist: %.2f\n\n", kleinste_zahl_1, groesste_zahl_1, mittelwert_1); 
				
				printf("Werte aus Feld a addiert mit Werten aus Feld b= %.2f\n\n", gesamtzahl_2);
				printf("Die kleinste Zufallszahl aus Aufgabenteil 2 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 2 ist: %.2f\nDer Mittelert aus Aufgabenteil 2 ist: %.2f\n\n", kleinste_zahl_2, groesste_zahl_2, mittelwert_2); 

				printf("Alle Werte aus Feld b multipliziert ergeben: %.2f\n\n", gesamtzahl_3);
				printf("Die kleinste Zufallszahl aus Aufgabenteil 3 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 3 ist: %.2f\nDer Mittelert aus Aufgabenteil 3 ist: %.2f\n\n", kleinste_zahl_3, groesste_zahl_3, mittelwert_3);


	printf("\n\nBitte Enter druecken um das Programm zu verlassen");
	getchar();
	
return 0;

}

P.S.: Die Anordnung im Original ist schöner aber irgendwie zerreisst der Browser das immer ziemlich...
 
Hey,
ohne jetzt deine Aufgabenstellung zu kennen, warum erzeugst du denn die Zufallszahlen in jedem Schritt neu?

Ist es nicht eher so gemeint, dass die Zufallszahlen nur einmal generiert werden sollen?
Also ganz am Anfang deiner Routine?
 
Das Einzige, was mir seltsam vorkommt, ist, dass die geschweiften Klammern bei den for-Schleifen fehlen. Aber ansonsten sehe ich jetzt irgendwie kein Problem?
 
Jo, ohne geschweifte Klammer nach for gilt das nur für die nächste Zeile.
Darüber hinaus: "Addiere elementweise die Werte aus a und b, speichere die resultierenden Werte wieder in a", ich sehe nicht, dass du das machst, wie wär's mit a = a+b; ?
Und dann könntest du dir für die Mittelwertberechnung auch gleich ne Funktion schreiben, dann müsstest du nicht alles zweimal tippen.

Edit: Ich sehe gerade, die Klammern hinter for sind ja da, liegt an der Code-Formatierung.
Und in Aufgeabenteil 3 wird in deinem Programm auch nicht quadriert.
 
Zuletzt bearbeitet:
Und die Frage lautet?

Ok sorry das ging nicht so deutlich hervor. Also die Frage lautet eigentlich wie kann ich die for Schleife platzieren, damit ich eben nicht in jedem Teilschritt neue Zufallszahlen generieren muss.

Hey, ohne jetzt deine Aufgabenstellung zu kennen, warum erzeugst du denn die Zufallszahlen in jedem Schritt neu?

Die Aufgabenstellung steht immer als Kommentar über der jeweiligen Funktion. Und genau dieses immer neu Erzeugen möchte ich ja verhindern!

Das Einzige, was mir seltsam vorkommt, ist, dass die geschweiften Klammern bei den for-Schleifen fehlen.

Doch die müssten eigentlich alle da sein (wie gesagt ist das hier im Browser alles ein wenig verrutscht aber die Klammern sind schon alle da)

Darüber hinaus: "Addiere elementweise die Werte aus a und b, speichere die resultierenden Werte wieder in a", ich sehe nicht, dass du das machst, wie wär's mit a = a+b; ?


Ja richtig das in a schreiben fehlt. Aber ich bin mit dem gesamten Aufbau des Programmes noch so unsicher, dass ich das erstmal weglassen- und dann später ergänzen wollte.

Und dann könntest du dir für die Mittelwertberechnung auch gleich ne Funktion schreiben, dann müsstest du nicht alles zweimal tippen

Das das irgendwie möglich ist, ist mir bewusst aber ich bin momentan mit der Aufgabe ein wenig überfordert und versuche mich Schritt für Schirtt dem Endergbnis zu nähern.

Nachtrag: Jetzt ist die For-Schleife so eingebaut wie ich mir vostellen könnte, dass sie platziert sein muss aber eigentlich kann das nicht gehen, da sich die a's und b's im Verlauf ja ständig ändern und somit wie gesagt von Schritt zu Schritt das Ergebnis falscher wird.

Code:
	int main( void )	{

	    const int size = 200; 

		float kleinste_zahl_1, kleinste_zahl_2, kleinste_zahl_3, groesste_zahl_1, groesste_zahl_2, groesste_zahl_3, a_werte_plus_b_werte;
		float gesamtzahl_1, gesamtzahl_2, gesamtzahl_3, mittelwert_1, mittelwert_2, mittelwert_3, gesamt_a, gesamt_b;
		float a[size], b[size];

		int i, x, y;

		kleinste_zahl_1 = RAND_MAX; groesste_zahl_1 = 0;
		kleinste_zahl_2 = RAND_MAX;	groesste_zahl_2 = 0;
		kleinste_zahl_3 = RAND_MAX;	groesste_zahl_3 = 0;

		gesamtzahl_1 = 0; gesamtzahl_2 = 0; gesamtzahl_3 = 0;
		gesamt_a = 0; gesamt_b = 0;


		//Aufgabenteil 1 - Minimum, Maximum und Mittelwert des Feldes a berechnen...

			for (i = 0; i <= size; i++)											{	
				a[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld a erzeugen
				b[i] = (float) rand()/RAND_MAX;										//Zufallszahlen in Feld b erzeugen
				
			gesamtzahl_1 += a[i];													//Gesamtwert der aufaddierten a's ausrechnen
			mittelwert_1 = gesamtzahl_1 / size;										//Mittelwert aller addierten a's ausrechnen

			if (a[i] < kleinste_zahl_1)			{ kleinste_zahl_1 = a[i]; }			//Bestimmen des kleinsten Wertes aus den Zufallszahlen in Feld a
			else if (a[i] > groesste_zahl_1)	{ groesste_zahl_1 = a[i]; }			//Bestimmen des größten Wertes aus den Zufallszahlen in Feld a

						
		//Aufgabenteil 2 - Addiere elementweise die Werte aus a und b, speichere die resultierenden Werte wieder in a, Berechne dann wieder Minimum, Maximum und Mittelwert...
			
			gesamtzahl_2 = (gesamt_a += a[i]) + (gesamt_b += b[i]);					//Gesamtwert aller addierten a's und b's ausrechnen
			gesamtzahl_2 == a[i];
			mittelwert_2 = gesamtzahl_2 / size;										//Mittelwert aller addierten a's und b's ausrechnen

			if (a[i] < kleinste_zahl_2)	{ kleinste_zahl_2 = x;						//Bestimmen der kleinsten Zahl aus Feld a und Feld b
				if (b[i] < x )			{ x = a[i];				}}

			if (a[i] < groesste_zahl_2)	{ groesste_zahl_2 = y;						//Bestimmen der größten Zahl aus Feld a und Feld b
				if (b[i] > y )			{ x = a[i];				}}
				
			
		//Aufgabenteil 3 - Quadriere die Werte im Feld b und bestimme wiederum Minimum, Maximum und Mittelwert.

		
			gesamtzahl_3 *= b[i];													//Gesamtwert aller quadrierten b's ausrechnen		
			mittelwert_3 = gesamtzahl_3 / size;										//Mittelwert aller quadrierten b's ausrechnen

			if (b[i] < kleinste_zahl_3)	{ kleinste_zahl_3 = b[i]; }					//Bestimmen der kleinsten Zahl der quadrierten b's
			if (b[i] > groesste_zahl_3)	{ groesste_zahl_3 = b[i]; }				}	//Bestimmen der größten Zahl der quadrierten b's
			
				
				printf("Es wurden insgesamt %d Zufallszahlen erzeugt\n\n", 2*size);
				printf("Alle Werte aus Feld a addiert ergeben: %.2f\n\n", gesamtzahl_1);
  				printf("Die kleinste Zufallszahl aus Aufgabenteil 1 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 1 ist: %.2f\nDer Mittelert aus Aufgabenteil 1 ist: %.2f\n\n", kleinste_zahl_1, groesste_zahl_1, mittelwert_1); 
				
				printf("Werte aus Feld a addiert mit Werten aus Feld b= %.2f\n\n", gesamtzahl_2);
				printf("Die kleinste Zufallszahl aus Aufgabenteil 2 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 2 ist: %.2f\nDer Mittelert aus Aufgabenteil 2 ist: %.2f\n\n", kleinste_zahl_2, groesste_zahl_2, mittelwert_2); 

				printf("Alle Werte aus Feld b multipliziert ergeben: %.2f\n\n", gesamtzahl_3);
				printf("Die kleinste Zufallszahl aus Aufgabenteil 3 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 3 ist: %.2f\nDer Mittelert aus Aufgabenteil 3 ist: %.2f\n\n", kleinste_zahl_3, groesste_zahl_3, mittelwert_3);


	printf("\n\nBitte Enter druecken um das Programm zu verlassen");
	getchar();
	
return 0;

}
 
Zuletzt bearbeitet:
Also, A ändert sich hier nirgends, da nirgends ausser in Zeile 22 deines zweiten Beispiels a ein Wert zugewiesen wird. Es steht also nirgends sonst a=...

Ein paar andere Sachen:

Bleib lieber beim obigen System mit meheren for-Schleifen,
also eine für die Initialsierung (Zeile 22 und 23)
und je eine für folgende Aufgaben.

Ausserdem kannst du Zeie 26 (mittelwert_1 = gesamtzahl_1 / size;) einmal nach der for-Schleife durchführen, statt in jedem Durchgang.

Zeilen 34: gesamtzahl_2 = (gesamt_a += a) + (gesamt_b += b); //Gesamtwert aller addierten a's und b's ausrechnen
-Keine Ahnung, ob das geht, aber schreib doch gleich gesamtzahl_2 += a+b;
Zeile 35:
gesamtzahl_2 == a;[/CODE]
-gesamtzahl_2 == a ist keine Zuweisung sondern eine Abfrage auf Gleichheit, übrigens immer falsch, also 0.

Zeile 62: printf("Alle Werte aus Feld b multipliziert ergeben: %.2f\n\n", gesamtzahl_3);
-Dann müsste gesamtzah_3 aber mit 1 und nicht mit 0 initialisiert werden. Ändert zwar nicht viel, da irgendwo noch ne 0 unter den Zahlen sein wird, aber korrekt ist es nur, wenn am Anfag 1* steht (1 ist Neutralelement der Multiplikation);

Ein Versuch, wie das aussehen könnte findest du hier:
Code:
    #include <stdio.h>
    #include <stdlib.h>
    
	#define size 200
	
	void Mittelwert(float *array1, float *minimum, float *maximum, float *mittelwert, float *summe){
	int i;
	float sum=0, min=32767, max=0;
	for (i = 0; i <= size; i++)	{	
	sum += array1[i];	//Gesamtwert der aufaddierten a's ausrechnen
     
    if (array1[i] < min)	{ min = array1[i]; }	//Bestimmen des kleinsten Wertes aus den Zufallszahlen in Feld a
    else if (array1[i] > max)	{ max = array1[i]; }	//Bestimmen des größten Wertes aus den Zufallszahlen in Feld a
	}	
    *summe = sum;
	*mittelwert = sum / size;	//Mittelwert aller addierten a's ausrechnen
	*minimum = min;
	*maximum = max;
	}
	
    int main( void )	{
          
    float kleinste_zahl_1, kleinste_zahl_2, kleinste_zahl_3, groesste_zahl_1, groesste_zahl_2, groesste_zahl_3;
    float gesamtzahl_1, gesamtzahl_2, gesamtzahl_3, mittelwert_1, mittelwert_2, mittelwert_3, produkt_3;
    float a[size], b[size];
     
    int i;
     
    for (i = 0; i <= size; i++)	{	
    a[i] = (float) rand()/RAND_MAX;	//Zufallszahlen in Feld a erzeugen
    b[i] = (float) rand()/RAND_MAX;	//Zufallszahlen in Feld b erzeugen
    }
	
	//Aufgabenteil 1 - Minimum, Maximum und Mittelwert des Feldes a berechnen...
	Mittelwert(a, &kleinste_zahl_1, &groesste_zahl_1, &mittelwert_1, &gesamtzahl_1);
    //Aufgabenteil 2 - Addiere elementweise die Werte aus a und b, speichere die resultierenden Werte wieder in a, Berechne dann wieder Minimum, Maximum und Mittelwert...
    for (i = 0; i <= size; i++)	{
	a[i] = a[i] + b[i];
	}
	Mittelwert(a, &kleinste_zahl_2, &groesste_zahl_2, &mittelwert_2, &gesamtzahl_2);
    //Aufgabenteil 3 - Quadriere die Werte im Feld b und bestimme wiederum Minimum, Maximum und Mittelwert.   
    produkt_3 =1;
	for (i = 0; i <= size; i++)	{	 
    produkt_3 *= b[i];
	b[i] *= b[i];
	}
	Mittelwert(b, &kleinste_zahl_3, &groesste_zahl_3, &mittelwert_3, &gesamtzahl_3);
	
	
    printf("Es wurden insgesamt %d Zufallszahlen erzeugt\n\n", 2*size);
    printf("Alle Werte aus Feld a addiert ergeben: %.2f\n\n", gesamtzahl_1);
    printf("Die kleinste Zufallszahl aus Aufgabenteil 1 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 1 ist: %.2f\nDer Mittelert aus Aufgabenteil 1 ist: %.2f\n\n", kleinste_zahl_1, groesste_zahl_1, mittelwert_1);
    printf("Werte aus Feld a addiert mit Werten aus Feld b= %.2f\n\n", gesamtzahl_2);
    printf("Die kleinste Zufallszahl aus Aufgabenteil 2 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 2 ist: %.2f\nDer Mittelert aus Aufgabenteil 2 ist: %.2f\n\n", kleinste_zahl_2, groesste_zahl_2, mittelwert_2);
     
    printf("Alle Werte aus Feld b multipliziert ergeben: %.2f\n\n", produkt_3);
	printf("Die Quadrate aus Feld b addiert ergeben: %.2f\n\n", gesamtzahl_3);
    printf("Die kleinste Zufallszahl aus Aufgabenteil 3 ist: %.2f\nDie groesste Zufallszahl aus Aufgabenteil 3 ist: %.2f\nDer Mittelert aus Aufgabenteil 3 ist: %.2f\n\n", kleinste_zahl_3, groesste_zahl_3, mittelwert_3);
     
     
    printf("\n\nBitte Enter druecken um das Programm zu verlassen");
    getchar();
    return 0;
     
    }
 
Also, A ändert sich hier nirgends, da nirgends ausser in Zeile 22 deines zweiten Beispiels a ein Wert zugewiesen wird. Es steht also nirgends sonst a=...


Doch ich glaube schon - undzwar zum Beispiel hier:

Code:
if (a[i] < kleinste_zahl_1) { kleinste_zahl_1 = a[i]; } //Bestimmen des kleinsten Wertes aus den Zufallszahlen in Feld a

oder hier:

Code:
else if (a[i] > groesste_zahl_1) { groesste_zahl_1 = a[i]; }

a wird doch in diesen Fällen immer zu einer "kleinsten Zahl" oder "größten Zahl" aber es bleiben nicht alle 200 Zahlen vom Anfang darin gespeichert - oder doch?

Bleib lieber beim obigen System mit meheren for-Schleifen

Das kann ich nicht wenn die Aufgabe richtig werden soll, denn die Aufgabenteile 1, 2 und 3 gehören zum selben zufälligen Feld. So wie ich das geschrieben habe hat ja jeder Aufgabenteil neue Zufallszahlen.

Ausserdem kannst du Zeile 26 (mittelwert_1 = gesamtzahl_1 / size einmal nach der for-Schleife durchführen, statt in jedem Durchgang.

Ok dann nehme ich diesen Befehl aus der Forschleife raus!

Deinen Entwurf verstehe ich leider an einigen Stellen nicht :(
Zum Beispiel:
- Was ist "void Mittelwert" und warum steht " int main( void ) {" erst mitten im Programm?

- Warum das: min=32767, max=0?

- Wo erstellst du am Anfang die Zufallszahlen? Das array1 ist doch gar nicht mit Zahlen gefüllt wenn du am Anfang schon min, max und Mittelwert ausrechnest oder?

- Was machen die * vor den Bezeichnern?

Das soll keine Kritik sein - bitte nicht falsch verstehen - aber ich bin noch nicht lange dabei und kenne micht dementsprechend sehr wenig aus!
 
Sorry, offenbar habt ihr noch nicht mit Pointern gearbeitet.
Mittelwert ist übrigens eine Funktion, die dann erst innerhalb von main aufgerufen wird, d.h. das Programm beginnt trotzdem bei main.

a wird doch in diesen Fällen immer zu einer "kleinsten Zahl" oder "größten Zahl"

eben nicht! Die Variable, die links steht, wird verändert. Mathematisch (aber auch bspw. in Pascal) würde eine solche Definition mit := geschrieben. In C aber einfach =.
Die rechte Seite wird hier nicht geändert, daher bleibt auch a gleich. Nur in die linke Seite, also die in die Variable "kleinste_zahl_1" wird a hineinkopiert.

32767 ist übrigens dein RAND_MAX und der * hat ewtas mit den Pointern zu tun, er dereferenziert ihn nämlich, aber zu Pointern werdet ihr irgendwann später noch kommen.

Edit:
Warum das: min=32767, max=0?
Falls du das komma meinst, du kannst Variablen direkt bei der Daklaration initialisieren, also statt
Code:
int i, j;
i=1;
j=3;
einfach schreiben
Code:
int i=1, j=3;
Wo erstellst du am Anfang die Zufallszahlen?
Die werden in dem Bsp in Zeile 31 bzw. 32 initialisiert, wie gesagt, das Programm beginnt bei int main, die Zeilen 6-19 werden nur berechnet, wenn die Funktion Mittelwert aufgerufen wird, also erst nach Zeile 34.
 
Zuletzt bearbeitet:
Sorry, offenbar habt ihr noch nicht mit Pointern gearbeitet.

Nein haben wir noch nicht also die Aufgabe müsste auch eigentlich ohne "pointer" zu lösen sein.

Nur in die linke Seite, also die in die Variable "kleinste_zahl_1" wird a hineinkopiert.


Gut zu wissen denn das heisst, dass das ganze dann doch auch mit nur einer einzelnen for-Schleife zu lösen ist.

Falls du das komma meinst, du kannst Variablen direkt bei der Daklaration initialisieren, ...

Nein nicht das Komma. Sondern das "min=32767" war gemeint aber du hast es zufällig auch schon erklärt! ;)

Die werden in dem Bsp in Zeile 31 bzw. 32 initialisiert, wie gesagt, das Programm beginnt bei int main, die Zeilen 6-19 werden nur berechnet, wenn die Funktion Mittelwert aufgerufen wird, also erst nach Zeile 34.

Ach so verstehe - du hast so eine Art "Sprung" eingebaut... Aber die Aufgabe verstehe ich noch ganz und gar nicht. Die ist irgendwie viel zu schwer! :(
 
Ja, es ist auch mit einer for-schleife lösbar, ich würde es aber der Übersichtlichkeit halber mit mehreren machen, die dann dein Programm in die Aufgabenabschnitte gliedern.
Also quasi
Abschnitt 1: Arrays mit Zufallszahlen füllen
Abschnitt 2: Mittelwert, Minimum, Maximum von a berechnen und Ergebnisse in der Konsole ausgeben
Abschnitt 3: Jedes Element von a und b aufaddieren und in a speichern und dann Mittelwert, Minimum, Maximum von a ausrechnen und Ergebnis ausgeben.
Abschnitt 4: Jedes Element von b quadrieren (und wieder in b speichern), Mittelwert, Min, Max ausrechnen und Ergebnisse ausgeben.
 
12th Monkey schrieb:
Ach so verstehe - du hast so eine Art "Sprung" eingebaut... Aber die Aufgabe verstehe ich noch ganz und gar nicht. Die ist irgendwie viel zu schwer! :(
Naja, nicht aufgeben, dein Versuch war doch schon nicht schlecht. Dein einziges Problem war eigentlich, dass du mathematisch gedacht hast und daher den "="-Operator falsch verwendet hast. Jetzt weißt du ja, dass es sich um eine Zuweisung an die linke Seite handelt, daran muss man sich eben erst mal gewöhnen, wenn man anfängt zu programmieren. Das weißt du ja jetzt, daher kannst du die Aufgabe doch lösen.
 
Zurück
Oben