staging.inyokaproject.org

BadBoy hat geschrieben:

[...]
und auch die schleife könnt man anders lösen:

(1..100).each { ...

*ggg*

oh...ne....schande über mich 😀

man kann die schleife ja noch viel einfacher machen:

100.times { ...

audax hat geschrieben:

Oft wird auch f0 = 0 ausgelassen und die Fibonacci-Folge mit f1 = 1 und f2 = 1 beginnend definiert, insbesondere bei der Anwendung auf Situationen, in denen ein Anfangswert Null keinen Sinn hat.

@unknown: Man möchte nicht durch 0 teilen, wirklich nicht. Das ist doof.

Für jedes Problem gibt es eine Lösung die kurz, schnell, einfach und falsch ist.

Hello World hat geschrieben:

Die Fibonacci-Zahlen beginnen mit 0, 1

...wayne, in diesem Kontext?

Ich denke jeden, der sich für die Fibonacci-Folge interessiert. ☺

user unknown hat geschrieben:

Als Unterhaltung finde ich ist der Platz dafür aber eher das Forum als das Wiki.

Ja natürlich, also ich hatte nur gedacht, dass man dann alle Lösungen nachdem sie hier gepostet wurden im Wiki sammeln könnte.

Also mal die Frage besteht Interesse an so was? Vielleicht 1 mal pro Woche? Wenn ja wie sollen wir die Themen aussuchen?

greets

@user unknown: Ob die Folge mit 0 und 1 beginnt, oder mit 1 und 1 scheint Definitionssache zu sein. Wikipedia sagt mit 0 und 1 aber oft wird die 0 weggelassen wenn der Anfangswert 0 keinen Sinn macht. Wolfram Mathworld sagt f_1 = f_2 = 1 und per Konvention ist f_0 = 0, also als wenn das Element noch zusätzlich vor die Folge gesetzt wird. Und der Mathe-Duden sagt F_0 = F_1 = 1, also ohne 0.

Da die Fibunacci-Folge aus der Populationsforschung kommt, kann sie auch rein logisch nicht mit 0,1 beginnen, weil 1 einziges Tier sich nicht reproduzieren kann:)

Adna rim hat geschrieben:

Da die Fibunacci-Folge aus der Populationsforschung kommt, kann sie auch rein logisch nicht mit 0,1 beginnen, weil 1 einziges Tier sich nicht reproduzieren kann:)

Ein einzelnes Tier kann sich aber auch nicht repoduzieren. 😉 Auser wir haben Bakterien / Viren aber das definieren wir ja nicht als Tier.
Man geht hier eher von Paaren aus.

1 Paar Haasen brauchen 1 Monat um Erwachsen zu werden. Nach einem Monat produzieren Sie wieder ein paar Haasen. Diese reifen wieder in einem Monat an zu einem paar Erwachsene Haasen an, und erzeugen wieder ein paar Haasen. Und wenn du die Erwachsenen Paaren zählst hast du am anfang 0. 😉 Weil du am anfang nur 1 paar baby haasen hast.

e1bart0 hat geschrieben:

Mit Perl ohne Rekursion 😉
http://paste.pocoo.org/show/30317

Meine Lösung ist durch memoize aber gar nicht so extrem Rekursiv wie man es meinen würde. 😉

Ich korrigiere mich ja nur ungern, aber da auch mein Schülerduden Mathe die Reihe mit F(0)=F(1)=1 starten läßt gebe ich ich zu: Ich habe mich geirrt.

Ich muß aber Herrn Fibonacci rügen, denn die Reihe würde mit 0, 1 als Startwerten auch funktionieren - es ist eine unnötige Verkürzung - was hat sich dieser Italiener gedacht?
Konnte er sich nicht denken, daß logisch und systematisch denkende Internetuser wie ich kommen würden, um festzustellen, daß es mit 0, 1 beginnen könnte?
Wieso nicht mit 5, 8 beginnen.
Welch Willkür!
Ich bin entsetzt.
Und enttäuscht von der Mathematik insgesamt.
Vielleicht sollte ich mich doch der Schafszucht auf Irischen Eiländern zuwenden.

Moose.
Flechten.

1, 1 - man faßt es nicht...

Wieso fängt er nicht mit 8944394323791464 und 14472334024676221 an?
Das ist doch Willkür!

Fibonacci - den Namen muß ich mir merken...

Nochmal Haskell:

module Main where

fib  = 0 : 1 : (zipWith (+) fib (tail fib))
main = putStrLn(show( [ ([fp,f], f/fp) | n <- [2..101], let fp =  fib !! (n-1), let f = fib !! n] ))

Schlampig, aber tut 😉

SML:

fun fib 0 = 0 
|    fib 1 = 1 
|    fib n = fib(n-1) + fib(n-2);

fun fiblist [] = []             
|    fiblist (x::xl) = fib(x)::fiblist(xl);

fun makelist 0 = [0]
|    makelist x = makelist(x-1)@[x];

fun golden [] = []
|    golden (x::[]) = []
|    golden (x::y::xl) = real(y)/real(x)::golden(xl);

fiblist(makelist(100));
golden(fiblist(makelist(100)));

Umständlich und langsam weil die Rekursionen etwa 100mio mal zuviel aufgerufen werden... aber egal, hauptsache es geht ☺

Dann gebe ich nochmal ne vernünftige Lösung ab 😉

import java.math.*;

public class Fib2 {
	public static void main(String[] args) {
		if (args.length != 2)
			System.exit(-1);
		try {
			int max = Integer.parseInt(args[0]);
			int precission = Integer.parseInt(args[1]);
			int mlen = Integer.toString(max - 1).length();
			int flen = fibIter(max).toString().length();
			BigDecimal n1 = new BigDecimal(Integer.toString(0));
			BigDecimal n2 = new BigDecimal(Integer.toString(0));
			for (int i = 1; i < max; ++i) {
				n1 = n2;
				n2 = fibIter(i);
				String ratio = n1.intValue() == 0 ? "infinity" : n2.divide(n1,
						precission, RoundingMode.HALF_UP).toString();
				System.out.format("f(%" + mlen + "d) = %" + flen + "s, f(%"
						+ mlen + "d)/f(%" + mlen + "d) ~= %s%n", i, n2, i,
						i - 1, ratio);
			}
		} catch (NumberFormatException e) {
			System.err.format("Invalid command line parameter: %s or %s",
					args[0], args[1]);
			System.exit(-1);
		} catch (IllegalArgumentException e) {
			System.err.format("Invalid command line parameter: %s or %s",
					args[0], args[1]);
			System.exit(-1);
		}
	}

	public static BigDecimal fibIter(int i) {
		if (i < 0)
			throw new IllegalArgumentException();
		if (i < 2)
			return new BigDecimal(Integer.toString(i));
		BigDecimal a = new BigDecimal(Integer.toString(0));
		BigDecimal b = new BigDecimal(Integer.toString(1));
		BigDecimal c = a.add(b);
		for (; i > 2; --i) {
			a = b;
			b = c;
			c = a.add(b);
		}
		return c;
	}
}

Ausgabe

f( 1) =                     1, f( 1)/f( 0) ~= infinity
f( 2) =                     1, f( 2)/f( 1) ~= 1.000000000000000000
f( 3) =                     2, f( 3)/f( 2) ~= 2.000000000000000000
f( 4) =                     3, f( 4)/f( 3) ~= 1.500000000000000000
f( 5) =                     5, f( 5)/f( 4) ~= 1.666666666666666667
[...]
f(97) =  83621143489848422977, f(97)/f(96) ~= 1.618033988749894848
f(98) = 135301852344706746049, f(98)/f(97) ~= 1.618033988749894848
f(99) = 218922995834555169026, f(99)/f(98) ~= 1.618033988749894848

 time java Fib2 100 18 > /home/greebo/fibonacci.txt 

real    0m0.333s
user    0m0.244s
sys     0m0.032s

P.S.

f(9999) = 
20793608237133498072112648988642836825087036094015
90311968294586652850142345568664892745603430522651
55917573432971901580106247942672509731761338101799
02738038231789748346235556483191431591924532394420
02806781032040872441469346284906266838708330804825
09206544933408787332263775808474463248737976037347
94648258113858631550404081017260381202919943892370
94285260164739821355447908182359371542956694514931
29936648467790904377992847736753792842706601751346
64833266377698642012106891355791141872776934080803
50495679409464829288056605636471818766266897075853
73833526774208355741559456585420036347653245410061
21012446785689171494803262408602693091211601973938
22944663604990153196328615969907788042772028923553
93296718771829156434190791865251186788568216008975
20171070499437657067342400871083908811800976259727
43182053955425686946081535591845825339823438236043
57627598231798961167484242695459246332046141379928
50814352018738480923581553988990897151469406131695
61449778372074346137375621868510685682609069633981
54909212537145372418669116042505973537478237332681
78182198509240226955826416016690084749816072843582
48861318482990538315018004784435375155420157383310
55219809981238332532612286898240517778465884610797
90807828367132384798451794011076569057522158680378
96153216085838722388297438048393192954122210080031
35806885850025988795664632214278204484925650731065
95808837401648996423563386109782045634122467872921
84560640917436063561821688381256232166444282295253
75774927153653211342045306867424354545051032697681
44370118494906390254934942358904031509877369722437
05338316536038859511698024592793522590153763492565
48723808771830083010745694440024264364147569050945
35072804764684492105680024739914490555904391369218
69638709291818924615710345038705022930060324161141
07074539600801709282779518347632167052424858208014
23866526633816082921442883095463259080471819329201
71014782802522138565634020748979631766327887220760
77910344317001127535588134788887275038253890668230
98683355695718137867882982111710796422706778536913
19234273336455672792801895398915310604737974128079
4091639429908796650294603536651238230626, 
f(9999)/f(9998) ~= 1.618033988749894848

😈 😈 😈 😈 Wer will das rekursiv ausrechnen? 😀

Greebo hat geschrieben:

P.S.

f(9999) = 
20793608237133498072112648988642836825087036094015
90311968294586652850142345568664892745603430522651
55917573432971901580106247942672509731761338101799
02738038231789748346235556483191431591924532394420
02806781032040872441469346284906266838708330804825
09206544933408787332263775808474463248737976037347
94648258113858631550404081017260381202919943892370
94285260164739821355447908182359371542956694514931
29936648467790904377992847736753792842706601751346
64833266377698642012106891355791141872776934080803
50495679409464829288056605636471818766266897075853
73833526774208355741559456585420036347653245410061
21012446785689171494803262408602693091211601973938
22944663604990153196328615969907788042772028923553
93296718771829156434190791865251186788568216008975
20171070499437657067342400871083908811800976259727
43182053955425686946081535591845825339823438236043
57627598231798961167484242695459246332046141379928
50814352018738480923581553988990897151469406131695
61449778372074346137375621868510685682609069633981
54909212537145372418669116042505973537478237332681
78182198509240226955826416016690084749816072843582
48861318482990538315018004784435375155420157383310
55219809981238332532612286898240517778465884610797
90807828367132384798451794011076569057522158680378
96153216085838722388297438048393192954122210080031
35806885850025988795664632214278204484925650731065
95808837401648996423563386109782045634122467872921
84560640917436063561821688381256232166444282295253
75774927153653211342045306867424354545051032697681
44370118494906390254934942358904031509877369722437
05338316536038859511698024592793522590153763492565
48723808771830083010745694440024264364147569050945
35072804764684492105680024739914490555904391369218
69638709291818924615710345038705022930060324161141
07074539600801709282779518347632167052424858208014
23866526633816082921442883095463259080471819329201
71014782802522138565634020748979631766327887220760
77910344317001127535588134788887275038253890668230
98683355695718137867882982111710796422706778536913
19234273336455672792801895398915310604737974128079
4091639429908796650294603536651238230626, 
f(9999)/f(9998) ~= 1.618033988749894848

😈 😈 😈 😈 Wer will das rekursiv ausrechnen? 😀

Ich Ich!!!

#!/usr/bin/perl
# Core Module
use strict;
use warnings;
use utf8;
use open ':utf8';
use open ':std';
use Memoize;
use bignum;
# Bei einer zu tiefen rekursion gibt es warnings. Die will ich nicht.
no warnings 'recursion';

sub fib {
    my ( $number ) = @_;
    return 1 if $number <= 1;
    return 1 if $number == 2;
    return fib($number-1) + fib($number-2);
}

memoize('fib');

my $fib1 = fib(9999);
my $fib2 = fib(9998);

print "fib(9999): $fib1\n\n";
print "fib(9998): $fib2\n\n";
print $fib1 / $fib2, "\n";

sidburn@sid ~/perl $ time ./goldener_schnitt.pl
fib(9999): 2079360823713349807211264898864283682508703609401590
3119682945866528501423455686648927456034305226515591757343297
1901580106247942672509731761338101799027380382317897483462355
5648319143159192453239442002806781032040872441469346284906266
8387083308048250920654493340878733226377580847446324873797603
7347946482581138586315504040810172603812029199438923709428526
0164739821355447908182359371542956694514931299366484677909043
7799284773675379284270660175134664833266377698642012106891355
7911418727769340808035049567940946482928805660563647181876626
6897075853738335267742083557415594565854200363476532454100612
1012446785689171494803262408602693091211601973938229446636049
9015319632861596990778804277202892355393296718771829156434190
7918652511867885682160089752017107049943765706734240087108390
8811800976259727431820539554256869460815355918458253398234382
3604357627598231798961167484242695459246332046141379928508143
5201873848092358155398899089715146940613169561449778372074346
1373756218685106856826090696339815490921253714537241866911604
2505973537478237332681781821985092402269558264160166900847498
1607284358248861318482990538315018004784435375155420157383310
5521980998123833253261228689824051777846588461079790807828367
1323847984517940110765690575221586803789615321608583872238829
7438048393192954122210080031358068858500259887956646322142782
0448492565073106595808837401648996423563386109782045634122467
8729218456064091743606356182168838125623216644428229525375774
9271536532113420453068674243545450510326976814437011849490639
0254934942358904031509877369722437053383165360388595116980245
9279352259015376349256548723808771830083010745694440024264364
1475690509453507280476468449210568002473991449055590439136921
8696387092918189246157103450387050229300603241611410707453960
0801709282779518347632167052424858208014238665266338160829214
4288309546325908047181932920171014782802522138565634020748979
6317663278872207607791034431700112753558813478888727503825389
0668230986833556957181378678829821117107964227067785369131923
4273336455672792801895398915310604737974128079409163942990879
6650294603536651238230626

fib(9998): 
1285115663929828519450896301646470648521511236666416078688182
4108151580018710975719228139479328507509990307989383646001363
1099962166142950869070822831536938491227546212135919351234106
6829225940147023270323227850986051125891967226851662905077110
5703879599849854360723531531941325680444530280568555848192631
4248736519996501713477661928343121839269259280269390114804580
5147871640531662057210313124281273394243303312126052450300625
2692752208924615455093172795175162661942390465222979170038150
3142742062425839671682341871686252105269065343584309221574453
8790204075720006867109298374535970259912366654483494417072657
4748299243105290223161632642782110897999358300261430024773873
7795831310837569812488891908392945409580751971770972911115642
1342104888631916684725513189034545440271167412737534154883258
4674156400102847228799266974536536214821479509899350282216871
2299407428272911345039084076559377890769111826199945798223176
6539875666347664642409675697696040768320386433398278246861864
3726346236986115868574217260165389679980270294614941110735757
5662187035866269245673342532968811332374113816840255122753907
6306875353490148736312344906036632552923051646149602565479792
6535256685374230638070471999827817731160546830845636888945544
8457028909517590884112601464387223609111452475717401427226173
6002362857250683242400856494576995349637732521307624726706321
3983343847207802717813584548653343648832981334320679079112769
3258819316100406250516321802723882268418837883244310944196509
3917786737248534365862679321831130913770623469171822102331059
4849628333795898586707635464361149691151005788188357292413937
3211032503231975607771743518413213602788553784786340687255442
3291865981980307138698350716606374756745369035178083370614561
6828806072613620926438857190639029024372736790739649205053016
7617553306799397160856718681066349166567711013516348276371281
0158741472429313106660382314704416126305027305701786875694823
3805315140830564210830598544882369143772329659689680193206763
0215897293293535102321720282307542485494926602200604208985750
5017496763133427945525619370230928163661015554626232458277146
9773408709136249

1.61803398874989484820458683436563811772

real    0m4.805s
user    0m4.504s
sys     0m0.128s

Dauert zwar etwas. Aber knapp 5 sekunden ist noch okay für einen Rekursiven Ansatz. 😀

Die Frage ist, wer will das iterativ ausrechnen, wenn's doch auch so geht:

Io> (1 + 5 sqrt) / 2
==> 1.6180339887498949

Edit: @sid burn: Memoize ist Betrug! Dann ist's ja gar keine rekursive Lösung, sondern dynamische Programmierung.

Edit: @sid burn: Memoize ist Betrug! Dann ist's ja gar keine rekursive Lösung, sondern dynamische Programmierung.

pff. Das caching gehört für mich zum Algorithmus dazu. Ich sehe da kein Betrug. 😀

Hmm ich versuche mich schon die ganze zeit daran es in C zu schreiben ,aber ich habe nnoch zu wenig kenntnisse von C .
Naja eher habe ich die Fibonaaci zahlen nciht ganz einbauen können ☹

#include <stdio.h>
#include <math.h>


long long int f1;
long long int f2;
long long int erg1;
long long int counter;

int main( int argc, char *argv[] )

{
	f1=0;
	f2=1;

	for(counter=0; counter<100;counter++)
		{
			erg1=f1+f2;
			f2=erg1+f2;
			printf("%i\n",f2);
		}
	return 0;
}

Könnte mir jemand helfen 😳

oder nen Pseudo Code posten

long long int für nen Counter der bis 100 geht? Oo

Und Code gibts hier ja wohl genug 😉