Ответ 1

RePeNt, 9, 8 символов

1↓[2?+1]

Или 10 символов с печатью:

1↓[2?+↓£1]

Запуск с использованием:

RePeNt "1↓[2?+1]"

RePeNt - это игрушечный язык на основе стека, который я написал (и все еще улучшаюсь), в котором все операторы/функции/блоки/циклы используют обратную польскую нотацию (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.

Ответ на стек, который строит себя следующим образом:

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

Он никогда не заканчивается (он имеет эквивалент цикла С#/JAVA do { } while(true)), потому что последовательность никогда не завершится, но завершающее решение можно записать так:

N_1↓nI{2?+}

что составляет 12 символов.

Интересно, кто-нибудь когда-нибудь прочтет это: (

Ответ 2

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

"Последовательность Фибоначчи"

ОК, я терпеть неудачу.:)

Ответ 3

13 символов Golfscript:

2,~{[email protected]+.}do

Обновить, чтобы объяснить операцию script:

• 2, создает массив [0 1]
• ~ помещает этот массив в стек
• Итак, в то время, когда мы запускаем do, мы запускаем стек с 0 1 (1 наверху стека)

Цикл do:

• Каждый . дублирует верхний элемент стека; здесь мы делаем это дважды (оставляя нас с 0 1 1 1 при первом запуске)
• p печатает самое верхнее значение (оставляя нас с 0 1 1)
• @ вращает верхние 3 элемента в стеке, так что третий верхний находится наверху (1 1 0)
• + добавляет верхние 2 элемента в стеке (оставляя 1 1)
• . дублирует верхнее значение, так что цикл do может проверить его правдоподобие (чтобы определить, следует ли продолжать)

Прослеживая это, пара петель будет достаточно, чтобы сказать вам, что это делает необходимое дополнение для генерации значений последовательности Фибоначчи.

Поскольку у GolfScript есть bignums, никогда не будет переполнения целых чисел, поэтому значение верхнего уровня в конце цикла do никогда не будет равным 0. Таким образом, script будет работать вечно.

Ответ 4

Perl 6 - 22 символа:

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

Ответ 5

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

Ответ 6

x86 (C-callable) realmode, 14 байт.
Вход в n   в стеке, возвращает   F _n     в AX.

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

Ответ 7

Brainfuck, 33 символа:

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

Ответ 8

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.

Ответ 9

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

f=:3 :'{:}[email protected](,+/)^:y(0 1x)'

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

Ответ 10

Для записи:

• 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

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

• 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 one, используя хвостовой вызов, так же быстро, как и линейный (но 69 символов, это самый длинный!) - нужно вызвать их с тремя параметрами, n, 1,0.

• Lua (69 char, дольше!): 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);}

Ответ 11

Исправлено после комментариев (спасибо Себастьяну), это не было решением последовательности, поэтому мы переходим к 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

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

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

Ответ 12

Windows XP (и более поздние версии) пакет script. Эта пакетная функция при задании одного аргумента - суммы генерирует количество + 1 числа Фибоначчи и возвращает их как строку (BATCH на самом деле не имеет наборов) в переменной% 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

И вот полный script, чтобы увидеть его в действии (просто скопируйте его в файл CMD или 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

Ответ 13

Пакет Microsoft - 15 символов

Старый вызов, но мир должен знать, что это возможно:

%1
%0 %1%2 %1 #

Вывод выполняется для stderr в унарном режиме, считая только # символов. В зависимости от ограничений пространства хост-системы он может создавать только первые 14 чисел или около того.

Ответ 14

Язык: dc, Char count: 20

Более короткое dc-решение.

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

Ответ 15

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

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

Ответ 16

F #:

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

44 Chars

Ответ 17

MS Excel: 11 символов:

=SUM(A1:A2)

Введите 1 в верхние 2 ячейки, затем поместите вышеуказанную формулу в ячейку A3. Скопируйте формулу в таблицу.

Начинает терять точность из-за округления с плавающей запятой в строке 74.
Превышает 10 ^ 307 и переполняет ошибку #NUM! в строке 1477.

Ответ 18

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

Ответ 19

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

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

Ответ 20

@Андреа Амбу

Итеративная версия pythonic fibonacci() должна выглядеть примерно так:

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

Ответ 21

С#

Я вижу много ответов, которые на самом деле не генерируют последовательность, но вместо этого дают вам только число фибоначчи в позиции * 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

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

Ответ 23

Lua - 49 символов

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

Ответ 24

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.

Ответ 25

BrainF ** к:

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

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

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

Ответ 26

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

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

Ответ 27

33 символа в C:

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

Ответ 28

Delphi Prism (Delphi for.net)

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

49 символов

Ответ 29

Предыдущий пример Ruby не будет работать без точек с запятой или новой строки, поэтому на самом деле это 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

или принятия команд командной строки, 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)}

Ответ 30

Ассемблер 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