@Andrea Ambu

повторяющаяся версия pythonic fibonacci() должен посмотреть что-то как этот:

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

Не самое короткое, но самое быстрое во время регистрации.:-)

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

33 символа в C:

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

Призма Дельфи (Дельфи для .net)

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

49 символов

Предыдущий пример Ruby не будет работать w/o или точки с запятой или новые строки, таким образом, это будут на самом деле 32 символа. Вот первый пример, который на самом деле произведет последовательность, не только возвращают значение указанного индекса.

Ruby:
53 символа, включая новые строки:

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

или если Вы хотите функцию, которая производит применимую структуру данных, 71 символ:

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

или принимающий командную строку args, 70 символов:

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

Ruby (30 символов):

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

C#

я вижу много ответов, которые на самом деле не генерируют последовательность, но вместо этого дают Вам только число Фибоначчи в положении *n использование рекурсии, которая, когда циклично выполнено можно генерировать последовательность, становится все больше медленнее в более высоких значениях 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) ;
}

22 символа с dc:

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

Вызывают с также:

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

Или:

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

Примечание: не моя работа, на которую незаконно охотятся от perlmonks.

13 символов [1 118] Golfscript:

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

Язык: ошибки компилятора C++
символы: 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; }

Символы Perl 6 - 22:

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

Генерируйте последовательность Fibonacci. ПОСЛЕДОВАТЕЛЬНОСТЬ последовательности!

J, 27 символов для нерекурсивной функции:

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

+/ суммы по списку.
(,+/) добавляет сумму списка к его хвосту.
}.@(,+/) суммы список, добавляет элемент к своему хвосту и отбрасывает первый элемент.
}.@(,+/)^:y выполняет итерации вышеупомянутой функции y времена.
}.@(,+/)^:y(0 1x) применяется, вышеупомянутая функция к списку (0,1) (эти x делает его целым числом).
{:}.@(,+/)^:y(0 1x) берет последний элемент выходного списка вышеупомянутого.
f=:3 :'{:}.@(,+/)^:y(0 1x)' определяет f, чтобы быть функцией на одной переменной y.

Для записи:

• Lua (66 символов): function f(n)if n<2 then return n else return f(n-1)+f(n-2)end end
• JavaScript (41 символ): function f(n){return n<2?n:f(n-1)+f(n-2)}
• Java (41 символ): int f(int n){return n<2?n:f(n-1)+f(n-2);}

я не много знатока супер кратких языков...:-P

Chris является правильным, я просто взял простой, рекурсивный алгоритм. На самом деле линейный еще короче в Lua (благодаря нескольким присвоение)! JavaScript не так удачен, и Java хуже, имея необходимость объявить Вар...

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

я записал бы код Lua с local a,b=1,0, но это более длинно, поэтому давайте загрязним _G!;-) То же самое для JS.

Для полноты, вот терминальные рекурсивные версии. Один Lua, с помощью последнего вызова, с такой скоростью, как линейный (но 69 символов, это является самым длинным!) - должен назвать их с тремя параметрическими усилителями, n, 1,0.

• Lua (69 символов, дольше!): function f(n,a,b)if n<1 then return b else return f(n-1,b,a+b)end end
• JavaScript (44 символа): function f(n,a,b){return n<1?b:f(n-1,b,a+b)}
• Java (52 символа): int f(int n,int a,int b){return n<1?b:f(n-1,b,a+b);}

Исправленный после комментариев (благодарит Sebastian), это не было решение для последовательности, таким образом, здесь мы идем с 42 символами (включает \n):

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

СТАРОЕ сообщение ниже

Python, 38 символов.

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

Не настолько короткий, но самое читаемое, по-моему: РЕДАКТИРОВАНИЕ P

: Вот аналитический путь (если кто-то должен видеть его в Python:-)

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

Язык: dc, Символьное количество: 20

Короче dc решение.

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

Windows XP (и более поздние версии) сценарий пакетной обработки. Эта пакетная функция, когда дали отдельный аргумент - сумма, генерирует amount+1 Числа Фибоначчи и возвращает их как строку (ПАКЕТ действительно не имеет наборов) в переменной %r % (369 символов или 347 символов - если мы удаляем добавление отступа):

: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

И вот полный сценарий, чтобы видеть его в действии (просто копия - мимо него в Командный файл или Bat-файл и выполнить его):

@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

F#:

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

44 Символа

Вот моя лучшая схема использования в 45 символах:

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

18 символов английского языка..

"Последовательность Fibonacci"

хорошо, я перестал работать.:)

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 символов, но действительно генерирует последовательность за линейное время.

Lua - 49 символов

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

Существует класс OrderedDictionary , который является словарем, но может индексироваться в порядке вставки, но не является универсальным. В настоящее время в среде .Net нет обобщенной версии.

Я читал где-то комментарий от кого-то из команды .Net, в котором говорилось, что они могут реализовать обобщенную версию в будущем, но в таком случае он, скорее всего, будет называться IndexableDictionary вместо OrderedDictionary , чтобы сделать его поведение более очевидным.

EDIT: нашел цитату. Он был на странице MSDN для OrderedDictionary , приписываемой Дэвиду М. Кину из Microsoft:

Этот тип на самом деле неправильно назван; это не «упорядоченный» словарь как таковой, а скорее «индексированный» словарь. Хотя, Ввод n в стеке, возвращает F _n в AX.

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

Befunge-93

31 символ

Выводит бесконечный список чисел Фибоначчи, начиная с 0, разделенных табуляцией (можно уменьшить до 29 символов, удалив 9, в первой строке, за счет отсутствия пробелов между числами).

К сожалению, все интерпретаторы Befunge-93, которые я пробовал, кажутся переполненными после 65k, поэтому результат верен только до 46368 включительно (что составляет F ₂₄ ).

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

Подтверждена работа (с оговоркой выше) с интерпретатором Befunge-93 в Javascript и Visual Befunge Applet Full .

Я с гордостью могу сказать, что это полностью оригинальная работа (т.е. я ни у кого не копировал этот код), и он намного короче, чем решение Befunge, которое в настоящее время находится на Rosetta Code .

Brainfuck , 33 символа:

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

Ассемблер PDP-11 ( исходный код )

    .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

BrainF ** k:

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

Это сгенерирует первые 5. Чтобы сгенерировать больше, замените 5 + в начале на большее: например:

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

Lucid

f = 1 fby 1 fby f + prev f;

27 символов, включая пробелы.

Euphoria: 44 символа

object f=1&1 loop do f&=f[$]+f[$-1]until 0

Генерация продолжается до тех пор, пока не закончатся ОЗУ или двойники.