ich habe eine kleines Programm zur Berechnung des Binomialkoeffizienten geschrieben ( n!/k!*((n-k)!) )-

Natürlich kommte es mit k! und n! zu hohen Werten, ich habe den Datentyp double verwendet, der mit aber eben bei höheren Werten nichts mehr vernünftiges Ausgibt... das Gleiche bei long.

Kann mir wer sagen was ich da falsch mache?

Danke & Lg

20/1*19/2*18/3*17/4*16/5

dann haste nur recht kleine zwischenergebnisse.

außerdem berechne nicht aus versehen 20 über 15, sondern if(k>n-k) k=n-k

int BionomCoeff(int iN, 
                int iK)
{
    return (fac(iN) / (fac(iK) * fac(iN - iK)));
}

Das is naheliegend, aber ein klassisches Beispiel, wo man eben nicht direkt aus der mathematischen Formel in Code uebersetzen soll. Eine bessere Herangehensweise hier (wenn auch in Pascal):

http://www.csc.liv.ac.uk/~ped/teachadmin/algor/dyprog.html

(Es geht bei der Seite eigentlich um etwas anderes, aber man hat den Binomialkoeffizienten als Beispiel gewaehlt.

Eine bessere Herangehensweise hier (wenn auch in Pascal):

ähm. hast du meine schleife gesehen?
ich weiß nicht sicher, weshalb du da jetzt so ein monster vorschlägst.

hartmut1164 schrieb:

Eine bessere Herangehensweise hier (wenn auch in Pascal):

ähm. hast du meine schleife gesehen?
ich weiß nicht sicher, weshalb du da jetzt so ein monster vorschlägst.

Ja ich habe sie gesehen - aber bei Deiner Schleife muss von einem int-Datentyp in ein real/float-Datentyp konveriert werden, d.h. das Ergebnis ist nicht notwendigerweise ein sauberer int.

Genau genommen ist auch kein so grosses Monster - die "eigentliche Arbeit" wird in einem Fuenfzeiler gemacht, der Rest ist "nur" die Aufarbeitung der Daten fuer eine recursive Abarbeitung.

Ich habe schon "Monsterhafteres" geschrieben.

Ja ich habe sie gesehen - aber bei Deiner Schleife muss von einem int-Datentyp in ein real/float-Datentyp konveriert werden, d.h. das Ergebnis ist nicht notwendigerweise ein sauberer int.

hä?

//ungetestet
unsigned result=1;
for(unsigned int i=0;i<k;++i){
   result*=n-i; // *20 *19 *18 *17 *16
   result/=k+1; // /1 /2 /3 /4 /5
}

wo versteckt sich da ein float? also ich sehe keinen.

ist offenbar falsch:

3 über 1 sind:
3! / (2!*1!) = 3*2 / 2*1 = 3

n = 3
k = 1

result=1;
//i == 0
result = 1* (3-0) = 3
result = 3/ (1+1) = 3/2 = 1
//i == 1
//i<k -> 1<1 -> false -> break

result = 1

also ersetzen wir die 1 durch nen i:

//ungetestet
unsigned result=1;
for(unsigned int i=0;i<k;++i){
   result*=n-i; // *20 *19 *18 *17 *16
   result/=k+i; // /1 /2 /3 /4 /5
}

n = 3
k = 1

result=1;
//i == 0
result = 1* (3-0) = 3
result = 3/ (1+0) = 3/1 = 3
//i == 1
//i<k -> 1<1 -> false -> break

result = 1

allerdings wäre jetzt noch zu zeigen, ob die division immer so gut klappt oder es auch passieren kann, dass der rest iwo wegfällt...

5 über 3 = 5! / ( 3!*2!) = 5*4*3*2*1 / 3*2*1*2*1 = 5*4*3*2 / 3*2*2 = 20/2 = 10

n = 5
k = 3

result=1;
//i == 0
result = 1* (5-0) = 5
result = 5/ (3+0) = 5/3 = 1
//i == 1
result = 1* (5-1) = 4
result = 4/ (3+1) = 4/4 = 1
//i == 2
result = 1* (5-2) = 3
result = 3/ (3+2) = 3/5
//i<k -> 3<3 -> false -> break

result = 0

hmm... offenbar stimmts noch immer nich... ^^
naja - vrmtl sollte es result /= i+1 heißen - aber hab jz nich so die lust, es noch mal zu testen und nen compiler hab ich gerad nich zur hand

bb

int BioCof (int i_n,
            int i_k)
{
        if ((i_k == 0) || (i_n == i_k))
                return 1;
        else
                return (BioCof (i_n - 1, i_k - 1) + BioCof (i_n - 1, i_k));
}

Wenn wir die recursive Defintion nehmen kommen wir zu dieser kl. Funktion:

int BioCof (int i_n,
            int i_k)
{
        if ((i_k == 0) || (i_n == i_k))
                return 1;
        else
                return (BioCof (i_n - 1, i_k - 1) + BioCof (i_n - 1, i_k));
}

bitte gib auch die laufzeit an oder mach ironie-tags.
und schreib rekursiv am besten mit k.

hartmut1164 schrieb:

Wenn wir die recursive Defintion nehmen kommen wir zu dieser kl. Funktion:

int BioCof (int i_n,
            int i_k)
{
        if ((i_k == 0) || (i_n == i_k))
                return 1;
        else
                return (BioCof (i_n - 1, i_k - 1) + BioCof (i_n - 1, i_k));
}

bitte gib auch die laufzeit an oder mach ironie-tags.
und schreib rekursiv am besten mit k.

Was ich in der Realitaet machen wuerde, waere z.B. das in ein Classe kapseln und z.B. einer Vektorklasse schon berechnete Ergebnisse speichern und dann wieder auf diese zurueckgreifen. Das saehe dann etwa so aus (was so etwa in im dem o.a. Link vorgeschlagen wird):

int BioCof::Calcu (int i_n,
                   int i_k)
{
    if (SearchResult (i_n, i_k) == true)
        return GetResult ();
    else if ((i_k == 0) || (i_n == i_k))
        return 1;
    else
        return (AddNewResult (i_n, i_k, BioCof (i_n - 1, i_k - 1) + BioCof (i_n - 1, i_k));
}

Dadurch braucht jedes Ergebis waerend der Lebenszeit der Klasse nur einmal berechnet zu werden. Man koennte die Klasse sogar einen Datenfile schreiben lassen, den sie beim ersten Aufruf einliesst und entsprechend ergaenzt.

unsigned int binomial_koeffizient(unsigned int n, unsigned int k)
{
	if (!k)
		return n;

	if (n == k)
		return n;

	while (n < k)
		n -= k;

	if (k > n/2)
		k = n-k;

	unsigned int R=1;
	for (unsigned int i=k+1, e(n+1); i < e; ++i)
		R *= i;

	for (unsigned int i=2, e(n-k+1); i < e; ++i)
		R /= i;

	return R;
}

am besten wäre es jetzt natürlich wieder, wenn wir das mit dem multiplizieren und dividieren abwechseln könnten - allerdings geht es eben nicht so einfach und noch dazu können wir dann nicht mehr garantieren, dass die division richtig funktioniert...

hübsch ist es noch immer nicht, aber ich seh nicht mehr viel, was man eleganter machen könnte...

gibt genau eine zeile, die man evtl noch optimieren könnte (die initialisierung von R und dafür einen schleifendurchlauf weniger) - aber das wird der compiler vrmtl scho selbst machen und außerdem bringt es ja ungefähr gar nix... ^^

bb

naja - vrmtl sollte es result /= i+1 heißen

so ist es.

unsigned int bf(unsigned int n,unsigned int k){
	unsigned result=1;
	for(unsigned int i=0;i<k;++i){
		result*=n-i; // *20 *19 *18 *17 *16
		result/=i+1; // /1 /2 /3 /4 /5
	}
	return result;
}

int main()
{
	cout<<bf(20,7)<<'\n';
    return 0;
}

gibt 77520 aus, das sagt auch der taschenrechner.

am besten wäre es jetzt natürlich wieder, wenn wir das mit dem multiplizieren und dividieren abwechseln könnten - allerdings geht es eben nicht so einfach und noch dazu können wir dann nicht mehr garantieren, dass die division richtig funktioniert...

doch, das kann man.
jede siebente zahl ist durch sieben teilbar. unter sieben aufeinanderfolgenden zahlen ist gewiß eine darunter, die durch sieben teilbar ist. das läßt sich bestimmt zu einem hübschen beweis aufblasen.

ich mach nen kleineren:
n über k ist doch immer eine ganze zahl.
nun sind aber genau die zwischenergebnisse

20/1
20/119/2
20/1*19/2*18/3
20/1*19/2*18/317/4
...
alles nur die zahlen 20ü0, 20ü1, 20ü2, 20ü3...
also ist stets in der division kein fehler passiert.

aber egal, darum ging es gar nicht. ich hab gar keine tests gemacht.

unsigned int binomial_koeffizient(unsigned int n, unsigned int k)
{
	if (!k)
		return n;//return 1

	if (n == k)//if k>=n
		return n;//retuen 1

	while (n < k)//??
		n -= k;//??

aber egal, darum ging es gar nicht. ich hab gar keine tests gemacht.

jopp - das erste beide stimmt natürlich

die schleife ist vrmtl schlicht falsch - iwie hab ich da was von wegen symmetrie in erinnerung gehabt, was es aber irgendwie nicht gibt also ich habs zumindest nicht auf die schnelle gefunden

von wegen * mit / abwechseln: hmm, ok... klingt gut

bb

int GetWideTriangle (int  i_n)
{
        if ((i_n % 2) == 0)
                return i_n / 2;
        else
                return (i_n + 1) / 2;
}

int *AllocFill (int   iHalfTriangle)
{
        int  *aReturn;

        aReturn = calloc (iHalfTriangle, sizeof (int));

        for (int iLoop = 0, iLoop < iHalfTriangle, iLoop++)
                aReturn [iLoop] = 1;

        return aReturn;
}

void RunPascal (int    *aLine,
                int     iRow)

{
        for (int iCol = 0, iCol < GetWideTriangle (iRow), iCol++)
        {
                iReminder = aLine [iCol];
                aLine [iCol] = aLine [iCol + 1] + iReminder;
        }
}

int BioCof (int  i_n
            int  i_k)
{
        int    *aLine;
                iReturn;

        aLine = AllocFill (GetWideTriangle (i_n));

        for (int iRow = 0, iRow < i_n, iRow++)
                RunPascal (aLine, iRow);

        if (i_k > i_n / 2)
                iReturn = aLine [i_n - i_k];
        else
                iReturn = aLine [i_k];

        free (aLine);

        return iReturn;
}

int GetWideTriangle (int  i_n)
{
        if ((i_n % 2) == 0)
                return i_n / 2;
        else
                return (i_n + 1) / 2;
}

int GetWideTriangle (int  i_n)
{
        return (i_n + 1) / 2;
}

bei dir ist nett, daß das ergebnis sogar immer richtig ist, wenn es in einen int paßt, also gar kein überlauf zwischendrin ist.

bei dir ist nett, daß das ergebnis sogar immer richtig ist, wenn es in einen int paßt, also gar kein überlauf zwischendrin ist.

sooo geil xD