Funktion zum berechnen eines Pascalschen Dreiecks

[Jonsc1]

Bin gerade dabei aus Spass ein Programm zu schreiben das jede Gleichung der Form (a+^n lösen kann.

Dazu brauche ich eine Funktion die mir die Zahlen des Pascalschen Dreiecks in ein Array schreibt....

Da ich an diesem Punkt langsam verzweifle bitte ich hier mal um Hilfe.

1 <.. das muss in ein Array wenn 0 übergeben wird

11 <.. 1

121 <.. 2

1331 <.. 3

14641 <.. 4

usw...

Sry das ich das Problem jetzt nicht genauer schildern kann, bin wirklich fertig weil ich schon seit Stunden an dem Problem arbeite...

Morgen wenn ich wieder ein wenig Kraft geschopft habe stell ich noch dazu zu was das ganze gut ist

mfg

Jonsc1

[Der Kleine]

Bin gerade dabei aus Spass ein Programm zu schreiben das jede Gleichung der Form (a+^n lösen kann.

Dazu brauche ich eine Funktion die mir die Zahlen des Pascalschen Dreiecks in ein Array schreibt....

Warum benötigst du ein Array? Das frisst Speicher (wenn es schlecht programmiert ist) und Rechenzeit (wenn deine Aufgabe mal etwas Anspruchsvoller wird - also z. B. (a+^1001.

Du kannst die einzelnen Zahlen anhand der Position berechnen.

5 Zeile 3 Spalte :

5!/[3!*(5-3)!]

bzw. Allgemein:

n te Zeile, m te Spalte:

n!/[m!*(n-m)!]

! bedeutet Fakultät bzw. Produkt der Zahlen von 1 bis n.

Wenn du erst kürzt, dann berechnest, dann stößt du nicht so schnell an Grenzen.

[Jonsc1]

Das Array brauche ich um die Koeffizienten zwischenzuspeichern...

Ich will das Ergebniss als Term ausgeben.

Bsp:

(a+^2

= a^2 + 2ab + b^2 (gekürtzt... vollständige Version siehe unten: )

= 1*a^2*b^0 + 2*a^1*b^1+ 1*a^0*b^2

Was fällt auf?

1. Die Zahl der Summanten ist (immer) n+1.

2. Jeder Summant hat die Form: x*a^y*b^z , wobei x der Koeffizient ist.

3. Die Koeffizienten lassen sich aus dem Pascalschen Dreieck ablesen.

In unserem Fall sind die Koeffizienten 1,2,1

Dazu das Pascalsche Dreieck bis zur Stelle 2 (n)

0: 1

1: 11

2: 121

4. noch einige andere besondere Merkmale, auf die es hier nicht ankommt...

Wenn ich das Ergebniss als ausmultiplizierten Term ausgeben will muss ich wohl oder übel die Koeffizienten in einem dynamischen Array zwischenspeichern... oder?

Danke für den Tipp mit der Fakultät-Funktion... werde mich mal dran ausprobieren...

mfg

Jonsc1

EDIT:

Mein bisheriger (sehr umständlicher, und kaum verständlicher) Lösungsansatz der leider nicht funktioniert... sry das die Kommentare fehlen, ich editier sie später rein...

int reihe[10];

int letze_reihe[10];



void pascal_reihe(int n)

{

	letze_reihe[0] = 1;

	letze_reihe[1] = 1;


	for(int i=1; i<=n; i++)

	{

		reihe[0] = 1;

		for(int j=1; j<n; j++)

		{

			reihe[j] = letze_reihe[j-1] + letze_reihe[j];

		};

		reihe[n] = 1;

		for(int k=0; k<i; k++)

		{

			reihe[k] = letze_reihe[k];

		};

	};

};

[Klotzkopp]

Das Array brauche ich um die Koeffizienten zwischenzuspeichern...

Äh, nein.

Der Kleine hat doch erklärt, wie du jeden einzelnen Wert im Dreieck allein aus seiner Position berechnen kannst.

[Jonsc1]

Aso... verstanden...

Trotzdem nochmal zum verdeutlichen:

n!/[m!*(n-m)!]

also:

fac(n) / [fac(m)*fac(m-n)]

stimmt das?

[Klotzkopp]

Ja. Allerdings musst du aufpassen, weil die Zwischenergebnisse schnell die Wertebereiche der üblichen Ganzzahltypen überschreiten. Schon die Fakultät von 13 passt in einen 32Bit-Integer nicht mehr hinein.

[Jonsc1]

Dieses Programm ist nach der oben genannten Metode geschrieben.

Es wird aber einfach <nichts> ausgegeben...

... wo liegt der Fehler?

#include <iostream>

using namespace std;



int fact(int n); // Fakultät Funktion

int pascDreieck(int n, int m);



int main()

{

	cout<<pascDreieck(4,2);	

	return 0;

};






int fact(int n) // Fakultät Funktion

{

   if(n==0)

      return 1;

   else

      return n*fact(n-1);

};	


int pascDreieck(int n, int m)

{

	int tmp_factN = fact(n);

	int tmp_factM = fact(m);

	int tmp_factMn = fact(m-n);


	return tmp_factN / (tmp_factM * tmp_factMn);

};

[Klotzkopp]

int tmp_factMn = fact(m-n);

Hier liegt der Fehler. Es heißt n-m, nicht n-m. Dadurch rufst du fact mit einer negativen Zahl auf. Das hast du bei der Rekursion nicht abgefangen, der Stack läuft über und dein Programm stürzt ab.

[Guybrush Threepwood]

du hast die Formel verdreht, guck dir das nochmal genau an:

n te Zeile, m te Spalte:

n!/[m!*(n-m)!]

[Jonsc1]

wow... funktioniert... hätte ich gar nicht mehr zu hoffen gewagt...

Danke euch!

[Jonsc1]

-.-

Tut mir leid, aber ein letzes mal muss ich euch noch zu diesem Thema belästigen...

Ich will mal wieder den Fehler einfach nicht finden.

Das Programm läuft bis zum aufruf von "ergebnis_ausgeben(...);" bricht nach dem ausgegebenen Ergebnis aber ab.

Die Zeile "cout<<"fertig"; wird nicht mehr ausgeführt....

Ich kann beim besten Willen keinen Fehler finden...

EDIT:

So weit bin ich schonmal, der Fehler MUSS in der Funktion ergebnis_ausgeben liegen...

Da arbeitet das Programm wohl doch nicht so korrekt....

#include <iostream>

using namespace std;


//

// Vorwärtsdeklarationen


void ueberschrift_ausgeben();	// Ausgabe der Überschrift

int n_eingeben();				// Eingabe von n

int koeffizient(int n, int m);	// Pascalsches Dreieck, nte Spalte, mte Reihe

int fact(int n);				// Fakultät Funktion

void ergebnis_ausgeben(int n, int anzahl_summanten); //Gibt Ergebnis aus





//------------- H A U P T P R O G R A M M --------------------------------------

int main()

{

	ueberschrift_ausgeben();

	int n = n_eingeben();


	//Bestimmen der Summanten (n+1) (Summanten = Zahl der benötigten Koeffizienten)

	int anzahl_summanten = n + 1;	//Zahl der Summanten ist immer n+1

	cout<<"Zahl der Summanten: "<<anzahl_summanten<<endl;;

	cout<<endl;



	ergebnis_ausgeben(n, anzahl_summanten);

	cout<<"fertig";

	return 0;



};






//########################################################################################

//------------- F U N K T I O N E N --------------------------------------------


void ueberschrift_ausgeben()

{

	cout<<"###############################"<<endl;

	cout<<"# Programm zum zur Berechnung #"<<endl;

	cout<<"#  von Funktionen der Form    #"<<endl;

	cout<<"#          (a+^n            #"<<endl;

	cout<<"###############################"<<endl;

	cout<<endl;

};



int n_eingeben()

{

	cout<<"Geben sie n ein: "; int n; cin>>n;

	if(n<0)

	{

		cout<<"Nur positive Zahlen!"<<endl;

		n = n_eingeben();

	};

	return n;

};



int fact(int n) // Fakultät Funktion

{

   if(n==0)

      return 1;

   else

      return n*fact(n-1);

};	



int koeffizient(int n, int m) // Pascalsches Dreieck, nte Spalte, mte Reihe

{

	int tmp_factN = fact(n);

	int tmp_factM = fact(m);

	int tmp_factMn = fact(n-m);


	return tmp_factN / (tmp_factM * tmp_factMn);

};


void ergebnis_ausgeben(int n, int anzahl_summanten)

{

	//Ergebniss ausgeben

	cout<<"(a+^"<<n<<" = "<<endl;

	cout<<"   ";   //Formatierung der Ausgabe

	for(int y=0; y<=anzahl_summanten; y++)

	{

		cout<<"    "<<koeffizient(n, y);

		cout<<" * ";

		cout<< "a^"<<n-y<<" * "<<"b^"<<n-(n-y); 

		cout<<endl;

		if(y<anzahl_summanten-1)

		{	

		cout<<" + ";

		};

	};

};

[/code]

[Klotzkopp]

Du rufst schon wieder fact mit einem negativem Wert auf, diesmal, weil deine Schleife in ergebnis_ausgeben um 1 zu weit läuft. Und weil du das in der Rekursion immer noch nicht abgefangen hast, läuft dir wieder der Stack über.

Übrigens: n-(n-y) ist das gleiche wie y.