Fibonacci-Code-Golf

Question

Generieren Sie die Fibonacci-Sequenz in den wenigsten Menge von Zeichen.Jede Sprache ist OK, mit einer Ausnahme, dass Sie definieren, mit einem Bediener, f, die druckt die Fibonacci-zahlen.

Ausgangspunkt: 25 14 Zeichen in Haskell:

f=0:1:zipWith(+)f(tail f)

f=0:scanl(+)1f

Answer 1

Umkehren, 9, 8 Zeichen

1↓[2?+1]

Oder 10 chars mit Druck:

1↓[2?+↓£1]

Ausführen mit:

RePeNt "1↓[2?+1]"

Umkehren ist eine stack-basierte Spielzeug Sprache, die ich schrieb, und bin immer noch verbessern), in dem alle Operatoren/Funktionen/blocks/loops verwenden Sie die Umgekehrte polnische Notation (RPN).

Command      Explanation                                              Stack
-------      -----------                                              -----

1            Push a 1 onto the stack                                  1
↓            Push last stack value                                    1 1
[            Start a do-while loop                                    1 1
2?           Push a two, then pop the 2 and copy the last 2 stack     1 1 1 1
             items onto the stack
+            Add on the stack                                         1 1 2
↓£           Push last stack value then print it                      1 1 2
1            Push a 1 onto the stack                                  1 1 2 1
]            Pop value (1 in this case), if it is a 0 exit the loop   1 1 2
             otherwise go back to the loop start.

Die Antwort ist auf dem Stapel, die baut sich auf wie:

1 1
1 1 2
1 1 2 3
1 1 2 3 5

Es ist nie beendet (es hat die eqivilent von einem C#/JAVA do { } while(true) Schleife), weil die Sequenz wird nie beendet, aber eine abschließende Lösung kann so geschrieben werden:

N_1↓nI{2?+}

die 12 chars.

Ich Frage mich, ob jemand jemals Lesen :(

Answer 2

18 Zeichen der englischen Sprache ..

"Fibonacci-Folge"

ok, ich versage. :)

Answer 3

13 Zeichen von Golfscript :

2,~{..p@+.}do

---

Aktualisieren, um die Operation des Skripts zu erklären:

1. 2, macht eine Reihe von [0 1]
2. ~ legt das Array auf dem Stack
3. Also, an der Zeit, dass wir die do laufen, beginnen wir den Stapel aus mit 0 1 (1 oben auf dem Stack)

Die do Schleife:

1. Jeder . dupliziert das oberste Element des Stapels; hier, wir tun dies zweimal (uns mit 0 1 1 1 auf Vorlauf verlassen)
2. p druckt den obersten Wert (us mit 0 1 1 verlassen)
3. @ dreht die Top-3 Artikel im Stapel, so dass die dritte oberste an der Spitze (1 1 0)
ist
4. + fügt die Top 2 Artikel in dem Stapel (Abfahrt 1 1)
5. . dupliziert den Top-Wert, so dass die do Schleife ihre Iness überprüfen (um festzustellen, ob sie weiterhin)

Tracing diese mental ein paar Schleifen genug sein wird, um Ihnen zu sagen, dass dies nicht die erforderlichen zusätzlich die Fibonacci-Folge Werte zu erzeugen.

Da GolfScript bignums hat, wird es nie ein Integer-Überlauf, und so der Top-of-Stack-Wert am Ende der do Schleife 0 nie So sein, wird das Skript für immer ausgeführt werden.

Answer 4

Sprache: C ++ Compiler-Fehler
Zeichen: 205

#define t template <int n> struct 
#define u template <> struct f
t g { int v[0]; };
t f { enum { v = f<n-1>::v + f<n-2>::v }; g<v> x;};
u<1> { enum { v = 1 }; };
u<0> { enum { v = 0 }; };
int main() { f<10> x; }

Answer 5

Perl 6-22 Zeichen:

sub f{1,1...{$^a+$^b}}

Answer 6

x86 (C-aufrufbar) Realmode, 14 Bytes.
Eingabe ist n auf Stapel, kehrt F _n in AX.

59 31 C0 E3 08 89 C3 40 93 01 D8 E2 FB C3

Answer 7

Brainfuck, 33 Zeichen:

+.>+.[<[>+>+<<-]>.[<+>-]>[<+>-]<]

Answer 8

22 Zeichen mit dc:

1[pdd5**v1++2/lxx]dsxx

Rufen Sie mit entweder:

dc -e'1[pdd5**v1++2/lxx]dsxx'

Oder:

echo '1[pdd5**v1++2/lxx]dsxx' | dc

. Hinweis: nicht meine Arbeit, pochierte von PerlMonks

Answer 9

J , 27 Zeichen für eine nicht-rekursive Funktion:

f=:3 :'{:}.@(,+/)^:y(0 1x)'

+/ Summen über eine Liste.
(,+/) hängt die Summe aus einer Liste mit dem Schwanz.
}.@(,+/) fasst eine Liste, fügt ein Element an den Schwanz und fällt das erste Element.
}.@(,+/)^:y iteriert die oben genannte Funktion y mal.
}.@(,+/)^:y(0 1x) gilt die obige Funktion auf der Liste (0,1) (die x macht es eine ganze Zahl).
{:}.@(,+/)^:y(0 1x) nimmt das letzte Element der Ausgabeliste der oben genannten.
f=:3 :'{:}.@(,+/)^:y(0 1x)' definiert f eine Funktion auf eine Variable y sein.

Answer 10

Für das Protokoll:

• Lua (66 Zeichen): function f(n)if n<2 then return n else return f(n-1)+f(n-2)end end
• JavaScript (41 Zeichen): function f(n){return n<2?n:f(n-1)+f(n-2)}
• Java (41 Zeichen): int f(int n){return n<2?n:f(n-1)+f(n-2);}

Ich bin nicht viel versiert super knapper Sprachen ... :-P

Chris ist richtig, ich habe gerade den einfachen, rekursiven Algorithmus. Eigentlich ist der linear man noch kürzer in Lua (dank Mehrfachzuordnung)! JavaScript ist nicht so viel Glück und Java ist noch schlimmer, mit Vars zu erklären ...

• Lua (60 Zeichen): function f(n)a=1;b=0;for i=1,n do a,b=b,a+b end return b end
• JavaScript (60 Zeichen): function f(n){a=1;b=i=0;for(;i++<n;){x=a+b;a=b;b=x}return b}
• Java (71 Zeichen): int f(int n){int a=1,b=0,i=0;for(;i++<n;){int x=a+b;a=b;b=x;}return b;}

würde ich Lua Code mit local a,b=1,0 schreiben, aber es ist mehr, also lassen Sie uns _G verschmutzen! ;-) Idem für JS.

Für Vollständigkeit, hier sind die Terminal rekursive Versionen. Lua ein, Endrekursion verwendet wird, ist so schnell wie die linearen eine (aber 69 Zeichen, es ist die längste!) -. Notwendigkeit, sie mit drei params zu nennen, n, 1,0

• Lua (69 Zeichen, mehr!): function f(n,a,b)if n<1 then return b else return f(n-1,b,a+b)end end
• JavaScript (44 Zeichen): function f(n,a,b){return n<1?b:f(n-1,b,a+b)}
• Java (52 Zeichen): int f(int n,int a,int b){return n<1?b:f(n-1,b,a+b);}

Answer 11

Korrigiert nach Kommentaren (dank Sebastian), war es nicht eine Folge Lösung, so hier gehen wir mit 42 Zeichen (enthält die \ n):

def f(a=0,b=1):
 while 1:yield a;a,b=b,a+b

---

OLD Beitrag unten

Python, 38 Zeichen.

f=lambda n:n if n<2 else f(n-1)+f(n-2)

Nicht so kurz, aber die meisten lesbar meiner Meinung nach: P

EDIT: Hier ist die analytische Art und Weise (wenn jemand braucht es in Python zu sehen: -)

f=lambda n:int(.5+(.5+5**.5/2)**n/5**.5)

Answer 12

Windows XP (und spätere Versionen) Batch-Skript. Diese Batch-Funktion, wenn ein einziges Argument gegeben - Menge erzeugt Menge + 1 Fibonacci-Zahlen und gibt sie als String (BATCH haben Sätze nicht wirklich) in Variable% r% (369 Zeichen oder 347 Zeichen - wenn wir entfernen Vertiefung) :

:f
    set i=0
    set r=1
    set n=1
    set f=0
    :l
        if %n% GTR %~1 goto e
        set f=%f% %r%
        set /A s=%i%+%r%
        set i=%r%
        set r=%s%
        set /A n+=1
        goto l
    :e
    set r=%f%
    exit /B 0

Und hier ist das komplette Skript, es in Aktion zu sehen (nur copy-Vergangenheit in eine CMD oder BAT-Datei und führen Sie es):

@echo off
call :ff 0
call :ff 1
call :ff 2
call :ff 3
call :ff 5
call :ff 10
call :ff 15
call :ff 20
exit /B 0

:ff
    call :f "%~1"
    echo %~1: %r%
    exit /B 0

:f
    set i=0
    set r=1
    set n=1
    set f=0
    :l
        if %n% GTR %~1 goto e
        set f=%f% %r%
        set /A s=%i%+%r%
        set i=%r%
        set r=%s%
        set /A n+=1
        goto l
    :e
    set r=%f%
    exit /B 0

Answer 13

Microsoft Batch - 15 Zeichen

Alte Herausforderung, aber die Welt muss wissen, dass es möglich ist:

%1
%0 %1%2 %1 #

Die Ausgabe ist in einstellige nach stderr, nur die # Zeichen zu zählen. Je nach Platzbeschränkungen des Host-Systems, kann es nur die ersten 14 Nummern erzeugen oder so.

Answer 14

Sprache: dc, Char zählen: 20

Kürzere dc Lösung.

dc -e'1df[dsa+plarlbx]dsbx'

Answer 15

F #:

(0,1)|>Seq.unfold(fun(a,b)->Some(a,(b,a+b)))

44 Chars

Answer 16

Hier ist meine beste Verwendung Schema, in 45 Zeichen:

(let f((a 0)(b 1))(printf"~a,"b)(f b(+ a b)))

Answer 17

MS Excel: 11 Zeichen:

=SUM(A1:A2)

Typ 1 in den oberen 2-Zellen, dann legen Sie die obige Formel in Zelle A3. Kopieren Sie die Formel auf der Tabelle.

Startet Genauigkeit zu verlieren aufgrund Gleitkomma Rundung auf Reihe 74
Übersteigt 10 ^ 307 und Überläufe zu einem #NUM! Fehler auf Zeile 1477.

Answer 18

Generieren Sie die Fibonacci-Folge. Reihenfolge SEQUENCE!

Answer 19

C #

Ich bin eine Menge Antworten zu sehen, die eigentlich nicht die Sequenz erzeugen, sondern geben Sie die Fibonacci-Zahl an Position * n Rekursion, die, wenn sie geschlungen die Sequenz erzeugen wird zunehmend langsamer bei höheren Werten von < em> n .

using System;
static void Main()
{
  var x = Math.Sqrt(5);
  for (int n = 0; n < 10; n++)
    Console.WriteLine((Math.Pow((1 + x) / 2, n) - Math.Pow((1 - x) / 2, n)) / p) ;
}

Answer 20

let rec f l a b =function 0->a::l|1->b::l|n->f (a::l) b (a+b) (n-1) in f [] 1 1;;

80 Zeichen, erzeugt aber wirklich die Reihenfolge, in linearer Zeit.

Answer 21

Rubin (30 Zeichen):

def f(n)n<2?n:f(n-1)+f(n-2)end

Answer 22

@Andrea Ambu

Eine iterative pythonic fibonacci() Version so ähnlich aussehen:

def fibonacci(a=0, b=1):
    while True:
        yield b
        a, b = b, a+b

Answer 23

Lua - 49 Zeichen

function f(n)return n<2 and n or f(n-1)+f(n-2)end

Answer 24

Befunge-93

31 Zeichen

ausgegeben eine unendliche Liste der Fibonacci-Zahlen, von 0 nach oben, durch Tabulatoren getrennt (könnte zwischen den Zahlen auf Kosten keine Leerzeichen durch Löschen 9, in der ersten Reihe, bis 29 Zeichen verringert werden).

Leider all Befunge-93 Dolmetscher habe ich versucht, scheinen nach 65k überlaufen, so dass der Ausgang ist nur dann korrekt, bis und einschließlich 46368 (die F ₂₄ ).

#v::1p1>01g:.\:01p+9,#
 >     ^

bestätigt (mit Vorbehalt oben) arbeitet mit den Befunge-93-Interpreter in Javascript und von Visual Befunge Applet Voll .

Ich bin stolz zu sagen, dass dies ein ganz originelles Werk (dh ich diesen Code nicht von jedermann kopiert habe), und es ist viel kürzer als die Befunge Lösung, die derzeit auf Rosetta-Code .

Answer 25

Brainf ** k:

>+++++>+>+<[[>]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[>+>+<<-]>>[<<+>>-]<[<]>-]

Das wird erzeugt der erste 5. Um mehr zu erzeugen, ersetzen Sie die 5 + am Anfang mit mehr: zB:

>++++++++++++++++++++++>+>+<[[>]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[>+>+<<-]>>[<<+>>-]<[<]>-]

Answer 26

Nicht die kürzeste, aber zum Zeitpunkt der Buchung am schnellsten. : -)

float f(float n) {
    return (pow(1+sqrt(5.0))/2.0),n) - pow(1+sqrt(5.0))/2.0),n)/sqrt(n));
}

Answer 27

33 Zeichen in C:

F(n){return n<2?n:F(n-1)+F(n-2);}

Answer 28

Delphi Prism (Delphi für .NET)

f:func<int32,int32>:=n->iif(n>1,f(n-1)+f(n-2),n)

49 Zeichen

Answer 29

Das obige Beispiel Rubin wird nicht funktionieren w / o entweder Semikolons oder Zeilenumbrüche, also ist es eigentlich 32 Zeichen. Hier ist das erste Beispiel, um tatsächlich Ausgang der Folge, nicht nur den Wert eines bestimmten Index zurück.

Rubin:
53 Zeichen inklusive Zeilenumbrüche:

def f(n);n<2?1:f(n-1)+f(n-2);end
0.upto 20 {|n|p f n}

oder wenn Sie wollen Funktion, die eine nutzbare Datenstruktur gibt, 71 Zeichen:

def f(n);n<2?1:f(n-1)+f(n-2);end
def s(n);(0..n).to_a.map {|n| f(n)};end

oder akzeptieren Befehlszeilen args, 70 Zeichen:

def f(n);n<2?1:f(n-1)+f(n-2);end
p (0..$*[0].to_i).to_a.map {|n| f(n)}

Answer 30

PDP-11 Assembler ( Quelle )

    .globl  start
    .text
start:
    mov $0,(sp)
    mov $27,-(sp)
    jsr pc, lambda
print_r1:
    mov $outbyte,r3
div_loop:
    sxt r0
    div $12,r0
    add $60,r1
    movb    r1,-(r3)
    mov r0,r1
    tst r1
    jne div_loop
    mov $1,r0
    sys 4; outtext; 37
    mov $1,r0
    sys 1
lambda:
    mov 2(sp),r1
    cmp $2,r1
    beq gottwo
    bgt gotone
    sxt r0
    div $2,r0
    tst r1
    beq even
odd:
    mov 2(sp),r1
    dec r1
    sxt r0
    div $2,r0
    mov r0,-(sp)
    jsr pc,lambda
    add $2,sp
    mov r0,r3
    mov r1,r2
    mov r3,r4
    mul r2,r4
    mov r5,r1
    mov r3,r4
    add r2,r4
    mul r2,r4
    add r5,r1
    mul r3,r3
    mov r3,r0
    mul r2,r2
    add r3,r0
    rts pc
even:
    mov 2(sp),r1
    sxt r0
    div $2,r0
    dec r0
    mov r0,-(sp)
    jsr pc,lambda
    add $2,sp
    mov r0,r3
    mov r1,r2
    mov r2,r4
    mul r2,r4
    mov r5,r1
    mov r2,r4
    add r3,r4
    mul r4,r4
    add r5,r1
    mov r2,r4
    add r3,r4
    mul r2,r4
    mov r5,r0
    mul r2,r3
    add r3,r0
    rts pc
gotone:
    mov $1,r0
    mov $1,r1
    rts pc
gottwo:
    mov $1,r0
    mov $2,r1
    rts pc

    .data
outtext:
    .byte 62,63,162,144,40,106,151,142,157,156
    .byte 141,143,143,151,40,156,165,155
    .byte 142,145,162,40,151,163,40
    .byte 60,60,60,60,60
outbyte:
    .byte 12