ich habe Probleme bei folgendem Programm:

Ich soll eine nicht rekursive Funktion schreiben, die ein Pacalsches Dreieck für eine gewünschte Zeilenanzahl, in einem zweidimensionalen Feld der Größe 20x20 ablegt, und an das Hauptprogramm zurückgibt.

Das pascalsche Dreieck sieht so aus:

Zeile0: 1
Zeile1: 11
Zeile2: 121
Zeile3: 1331
Zeile4: 14641 ... :p

mein Vorschlag:

[code]

#define ZEILEN 20
#define SPALTEN 20

void pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN]);

int main()
{

...

system ("pause");
return 0;

}

void pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN]){

     int i;

     dreieck [0] [0] = 1;
     dreieck [1] [1] = 1;    
     dreieck [1] [2] = 1;  

     for (i = 2; i = n; i++) {
         dreieck [i] [] = 1;   ??? :o)

[/code]

Bitte, kann mir jemand helfen??

Vielen Dank!!!

#define ZEILEN 20
#define SPALTEN 20

=>

const size_t ZEILEN   = 20;
const size_t SPALTEN  = 20;

hier vll mal nen kleines stück:

for (int i = 1; i != n; ++i)
{
   for (int j = 1; j != n; ++i)
   {
      dreieck[i][j] = fak(i) / (fak(j) * fak(i-j));
   } 
}

musst jz nur noch fak (fakultät) implementieren und dann noch dafür sorgen, dass du nen "richtiges" dreieck bastelst und kein rechtwinkliges krüppelding, wie ich das hier mach ^^

die fkt würde ich btw auch so deklarieren:

void pascalschesdreieck_oderwieauchimmerdernamewar (int max, int *feld)
{
//geht immernoch:
feld[0][0];
}

bb

for(int z=1;z<20;++z)
  for(int z=1;z<20;++z)
    dreieck[s][z]=dreieck[s-1][z-1]+dreieck[s][z-1];

ist nur noch gar nicht fertig. zuerst muss oben links ne 1 rein und sonst oben 0. und links wohl auch lauter einsen. müßte ich mal auf papier durchspielen, ob's klappt.

eher gemeint ist wohl

for(int z=1;z<20;++z)
  for(int z=1;z<20;++z) //copy & paste lässt größen ;o)
    dreieck[s][z]=dreieck[s-1][z-1]+dreieck[s][z-1];

ist nur noch gar nicht fertig. zuerst muss oben links ne 1 rein und sonst oben 0. und links wohl auch lauter einsen. müßte ich mal auf papier durchspielen, ob's klappt.

Nein, das meinte ich nicht so, weil er ausdrücklich nach einer nicht rekursiven Lösung gefragt hat, wollte ich auch nicht die bereits berechneten Werte nutzen - aber es klappt: für n == k ist ne 1 und ansonsten nimmt man deine gleichung um es dann halt doch wieder rekursiv (die fkt ist zwar nicht rekursiv, die lösung aber sehr wohl) zu berechnen ^^

bb

die fkt ist zwar nicht rekursiv, die lösung aber sehr wohl

Das ist dynamische Programmierung und hat überhaupt nichts mit rekursion zu tun.

http://www.c-plusplus.net/forum/viewtopic-var-t-is-212469-and-highlight-is-array+2+dimensionales.html

unskilled schrieb:

die fkt ist zwar nicht rekursiv, die lösung aber sehr wohl

Das ist dynamische Programmierung und hat überhaupt nichts mit rekursion zu tun.

es benötigt die vorigen ergebnisse also nicht?
doch...
also ist es eine rekursive gleichung...
ist ja auch krümelkackerei - muss der kleine student selbst wissen, wie er es machen will / soll / muss - er hat jetzt beide (oder jedenfalls die 2, die ich kenn ^^) Lösungen gesehen...
die eine verwendet die rekursive formel und die andere die explizite zur berechnung der binomialkoeffizienten...

bb

ich hab jetzt doch mal mit Rekursion versucht, anders bekomme ich es sowieso nicht hin :p

Mein Ergebniss:

[code]

#include <iostream>;

using namespace std;

#define ZEILEN 20
#define SPALTEN 20

int pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN]);
unsigned long int fak (unsigned long int n);

int main()
{

int n, i;
int dreieck [ZEILEN] [SPALTEN];

cout << "Geben Sie die Anzahl der Zeilen des Dreiecks ein" << endl;
cin >> n;

for (i = 0; i <= n; i++) {
    cout << "Zeile " << i << " : " << pascalDreieck (n, dreieck ) << endl;} // 

system ("pause");
return 0;

}

int pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN]){

     int i, j;

     dreieck [0] [0] = 1;

     for (int i = 1; i != n; ++i){
         for (int j = 1; j != n; ++i){
             dreieck[i][j] = fak(i) / (fak(j) * fak(i-j)); }}}

unsigned long int fak (unsigned long int n) {
         if (n==0) return 0;
         return n*fak(n-1); }

[/code]

Leider gibts bei allen Zahlen n>1 ne Endlosschleife. Kann mir jemand helfen?
Vielen Dank! Ihr macht das echt toll!

verzweifelter student schrieb:

ich hab jetzt doch mal mit Rekursion versucht, anders bekomme ich es sowieso nicht hin :p

ich seh keine rekursion...

btw:
[ cpp][code]
ein tag von beiden reicht (cpp ^^)

#include <iostream>;

Das ; ist unnötig...

#define ZEILEN 20
#define SPALTEN 20

warum nutzt du denn für so was immer noch den präprozessor?
nein, das ist nicht schneller...

int pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN]);

vll solltest du n umbennen?
vll auch (generell) unsigned nehmen?
etc.

unsigned long int fak (unsigned long int n);
//wieso lässt du nen unsigned int zu? das wird doch nix...
unsigned long int fak (unsigned int n); //(2^32-1)! > 2^64-1 > long

ich würde hier so gar mal unsigned char verwenden (255! > 3*10^504)

btw:
In C++ werden Variablen genau dort deklariert wo sie auch gebraucht werden - und meist auch gleich definiert werden können...

gib mir mal die exakte aufgabenstellung, dann könnte man hier vll wenigstens mal genau rausbekommen, was du machen sollst... ^^

noch was:

int pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN]){

     int i, j;

     dreieck [0] [0] = 1;

     for (int i = 1; i != n; ++i){
         for (int j = 1; j != n; ++i){
             dreieck[i][j] = fak(i) / (fak(j) * fak(i-j)); }}}

findest du die position der klammern leserlich?

int pascalDreieck (int n, int dreieck [ZEILEN] [SPALTEN])
{
     int i, j; //falsch :P

     dreieck [0] [0] = 1; //unnötig

     for (int i = 0; i != n; ++i)
     {
         for (int j = 0; j != n; ++j) //hier stand ++i -> endlosschleife
         { //0 ist das erste element - und das soll die daten von 1 enthalten
             dreieck[i-1][j-1] = fak(i) / (fak(j) * fak(i-j));
         }
     }
}

jz bleibt nur noch übrig, das dreieck so zu bauen, dass es schön aussieht...
also kommt vor die innere schleife noch ne schleife die den rest der felder 0 setzt (die, die diese zeile nicht gebraucht werden)

gib jz ma bitte die genaue aufgabenstellung, dann kann ich dir vll auch ein wenig mehr helfen ^^

bb

bevor ich umsetzte was du schreibst, erst mal ne genaue Aufgabenstellung:
(orginal)

Der französische Mathematiker Blaise Pascal ist entdecker des Pascalschen Dreiecks. Dieses Dreieck wird schritt für schritt mit Zeile 0 aufgebaut.
Dazu berechnet man die n-te Zeile aus der (n-1)ten Zeile wie folgt;

Die Anzahl der Elemente der Zeile ist n+1;
Die erste und letzte Zeile jeder Spalte ist steht die 1;
Das i-te Element der Zeile n entspricht der Summe des i-ten und des (i-1)ten
Elements der Zeile (n-1);

Beispiel: Dreieck mit 5 Zeilen:

Zeile 0: 1
Zeile 1: 1 1
Zeile 2: 1 2 1
Zeile 3: 1 3 3 1
Zeile 4: 1 4 6 4 1 // Sollte ne Pyramide geben, weiß jetzt nicht wie mans darstellt

a) Schreiben Sie eine nicht-rekursive Funktion mit dem Namen pascalDreieck, das die ersten n Zeilen für ein einzugebenes n in einem zweidimensionalen Feld der 20x20 ablegt.

b) Übertragen Sie die Funktion an ein Hauptprogramm. Bei einer Bildschirmabfrage soll das gewünsche n (Zeilenanzahl eingebeben) werden.
Gewünschte ausgabe:

Zeile 0: 1
Zeile 1: 1 1
Zeile 2: 1 2 1
Zeile 3: 1 3 3 1
Zeile 4: 1 4 6 4 1

so.. das wars. DANKE!