Pergunta

Gerar a seqüência de Fibonacci, no valor mínimo de caracteres possíveis. Qualquer língua é OK, com exceção de um que você define com um operador, f, que imprime os números de Fibonacci.

Ponto de partida: 25 14 caracteres na Haskell :

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

f=0:scanl(+)1f
Foi útil?

Solução

Arrependei-vos, 9 , 8 caracteres 

1↓[2?+1]

ou 10 caracteres com impressão: 

1↓[2?+↓£1]

Executar usando: 

RePeNt "1↓[2?+1]"

Arrependei-vos é uma linguagem de brinquedo baseado em pilha que eu escrevi (e ainda estou melhorando) em que todos os operadores / funções / blocos / loops de usar Reverse Polish 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.

A resposta está na pilha que se acumula como: 

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

Ela nunca termina (que tem o eqivilent de um loop do { } while(true) C # / JAVA) porque a sequência nunca terminará, mas uma solução de terminação pode ser escrita da seguinte maneira: 

N_1↓nI{2?+}

que é de 12 caracteres.

Gostaria de saber se alguém nunca vai ler isto: (

Outras dicas

18 caracteres de Inglês ..

"seqüência de Fibonacci"

ok, eu falhar. :)

13 caracteres de Golfscript : 

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

Atualização para explicar o funcionamento do script:

  1. 2, faz uma série de [0 1]
  2. puts ~ essa matriz na pilha
  3. Assim, no momento em que corremos o do, começamos a pilha fora com 0 1 (1 no topo da pilha)

O loop do:

  1. Cada . duplica o item do topo da pilha; aqui, nós fazer isso duas vezes (deixando-nos com 0 1 1 1 na corrida inicial)
  2. p imprime o valor mais alto (deixando-nos com 0 1 1)
  3. @ gira o topo 3 itens na pilha, de modo que o terceiro é superior na parte superior (1 1 0)
  4. + adiciona o top 2 itens na pilha (deixando 1 1)
  5. . duplica o valor superior, de modo que o loop do pode verificar a sua truthiness (para determinar se deve continuar)

Seguindo esta mentalmente um par de loops será suficiente para dizer-lhe que isso não a adição necessária para gerar os valores da sequência de Fibonacci.

Desde GolfScript tem bignums, nunca haverá um excesso de número inteiro, e assim o valor top-of-stack no final do loop do nunca será 0. Assim, o script será executado para sempre.

Idioma: C ++ Compiler Errors
Personagens: 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 caracteres: 

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

x 86 realmode (C-exigível), 14 bytes.
Entrada é n na pilha, retorna F n em AX. 

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

Brainfuck , 33 caracteres: 

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

22 caracteres com dc: 

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

Invoke com: 

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

Ou: 

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

Nota:. Não meu trabalho, cozido de PerlMonks

J , 27 caracteres para uma função não-recursiva: 

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

somas +/ mais de uma lista.
(,+/) acrescenta a soma de uma lista para sua cauda.
}.@(,+/) resume uma lista, acrescenta um elemento à sua cauda, ??e descarta o primeiro elemento.
}.@(,+/)^:y repete os tempos função y acima.
}.@(,+/)^:y(0 1x) aplica a função acima para o (0,1) lista (a x torna um inteiro).
{:}.@(,+/)^:y(0 1x) leva o último elemento da lista do acima saída.
define f=:3 :'{:}.@(,+/)^:y(0 1x)' f ser uma função em um y variável.

Para o registro:

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

Eu não sou muito adepto de línguas super-concisas ... :-P

Chris está certo, eu só teve o simples algoritmo recursivo. Na verdade, a linear é ainda menor em Lua (graças a atribuição múltipla)! JavaScript não é tanta sorte e Java é pior, ter de declarar vars ...

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

Gostaria de escrever código de Lua com local a,b=1,0 mas é mais longa, então vamos _G poluir! ;-) Idem para JS.

Para completar, aqui estão as versões recursiva terminais. um de Lua, usando a chamada de cauda, ??é tão rápido como a linear (mas 69 caracteres, é a mais longa!) -. necessidade de chamá-los com três parâmetros, n, 1,0

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

corrigido após comentários (graças Sebastião), não foi uma solução seqüência, então vamos lá com 42 caracteres (inclui o \ n): 

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

Post antigo abaixo

Python, 38 caracteres. 

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

Não é tão curta, mas o mais legível na minha opinião: P

EDIT: Aqui é a maneira analítica (se alguém precisa de vê-lo em python: -) 

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

Windows XP (e versões posteriores) script em lotes. Esta função lote quando recebe um único argumento - quantidade, gera + 1 números quantidade de Fibonacci e retorna como uma string (lote não tem realmente sets) na variável% r% (369 caracteres ou 347 caracteres - se removermos recuo) : 

: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

E aqui está o script completo, para vê-lo em ação (basta copiar-past-lo em um arquivo CMD ou BAT e executá-lo): 

@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

Microsoft Batch - 15 caracteres

desafio Velho, mas o mundo deve saber que é possível: 

%1
%0 %1%2 %1 #

A saída é para stderr em unário, contando apenas os caracteres #. Dependendo restrições de espaço do sistema host, que pode produzir apenas os primeiros 14 números ou assim.

Idioma: dc, contagem de Char: 20

solução dc Shorter. 

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

F #: 

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

44 Chars

Aqui está a minha melhor esquema usando, em 45 caracteres: 

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

MS Excel: 11 caracteres: 

=SUM(A1:A2)

Tipo 1 nas células topo 2, em seguida, colocar a fórmula acima na célula A3. Copie a fórmula para baixo a planilha.

começa a perder precisão devido ao arredondamento de ponto flutuante no corredor 74.
Excede 10 ^ 307 e transborda a um erro #NUM! na linha 1477.

Gerar a seqüência de Fibonacci. seqüência SEQÜÊNCIA!

C #

Eu estou vendo um monte de respostas que realmente não gerar a sequência, mas em vez disso dar-lhe apenas o número de Fibonacci na posição * n usando recursão, que quando em loop para gerar a sequência fica cada vez mais lento em valores mais elevados de < 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) ;
}

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 caracteres, mas realmente gera a seqüência, em tempo linear.

Ruby (30 caracteres): 

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

@Andrea Ambu

A versão de Um fibonacci() pythônico iterativo deve ser algo como isso: 

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

Lua - 49 caracteres 

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

Befunge-93

31 caracteres

Will saída uma lista infinita dos números de Fibonacci, a partir de 0 para cima, separadas por abas (poderia ser reduzida para 29 caracteres por exclusão 9, na primeira fileira, à custa de nenhum espaço entre os números).

Infelizmente, todos os Befunge-93 intérpretes que eu tentei parecem estouro após 65k, para que a saída só é correta até e incluindo 46368 (que é F 24 ). 

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

Confirmado para o trabalho (com ressalva acima) com o intérprete Befunge-93 em Javascript eo Visual Befunge Applet completa.

Tenho orgulho de dizer que este é um trabalho completamente original (ou seja, eu não copiar este código de ninguém), e é muito menor do que a solução Befunge atualmente no Código Rosetta .

BrainF ** k: 

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

Isso vai gerar a primeira 5. Para gerar mais, substitua o 5 + no início com mais: por exemplo: 

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

Não é o mais curto, mas o mais rápido no momento da postagem. : -) 

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

33 caracteres em C: 

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

Delphi Prism (Delphi para .NET) 

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

49 caracteres

O exemplo anterior Ruby vai não trabalho w / o qualquer ponto e vírgula ou novas linhas, por isso é realmente 32 caracteres. Aqui está o primeiro exemplo de realmente saída da sequência, não apenas retornar o valor de um índice especificado.

Ruby:
53 caracteres, incluindo novas linhas: 

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

ou se você quiser função que gera uma estrutura de dados utilizável, 71 caracteres: 

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

ou aceitar de linha de comando args, 70 caracteres: 

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

PDP-11 Assembler ( fonte ) 

    .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
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top