Todo mundo conhece a sequência de Fibonacci:
você pega um quadrado, anexa um quadrado igual a ele e, em seguida, anexa repetidamente um quadrado cujo comprimento lateral é igual ao maior comprimento lateral do retângulo resultante.
O resultado é uma bela espiral de quadrados cuja sequência de números é a sequência de Fibonacci :

Mas, e se não quiséssemos usar quadrados?

Se usarmos triângulos equilaterais - em vez de quadrados - de maneira semelhante, obteremos uma espiral igualmente bonita de triângulos e uma nova sequência: a sequência Padovan , também conhecida como A000931 :

Tarefa:

Dado um número inteiro positivo, , saída , o ° prazo na sequência Padovan ou as primeiras termos.$N$$a_N$$N$$N$

Suponha que os três primeiros termos da sequência sejam todos . Assim, a sequência começará da seguinte forma: $1$

Entrada:

• Qualquer número inteiro positivo$N\ge0$

• Entrada inválida não precisa ser levada em consideração

Resultado:

• O ° prazo na sequência Padovan OU os primeiros termos da sequência Padovan.$N$N$N$

• Se os primeiros termos forem impressos, a saída poderá ser o que for mais conveniente (lista / matriz, sequência de linhas múltiplas, etc.)$N$

• Pode ser indexado ou indexado$0$$1$

Casos de Teste:
(0-indexados, th prazo)$N$

Input | Output
--------------
0     | 1
1     | 1
2     | 1
4     | 2
6     | 4
14    | 37
20    | 200
33    | 7739

(Indexados em 1, primeiros termos)$N$

Input | Output
--------------
1     | 1
3     | 1,1,1
4     | 1,1,1,2
7     | 1,1,1,2,2,3,4
10    | 1,1,1,2,2,3,4,5,7,9
12    | 1,1,1,2,2,3,4,5,7,9,12,16

Regras:

• Isso é código-golfe : quanto menos bytes, melhor!

• As brechas padrão são proibidas.

Gelatina , 10 bytes

9s3’Ẓæ*³FṀ

Experimente online!

1 indexado. Calcula o maior elemento de:

(isso é uma total coincidência.)

9s3         [[1,2,3],[4,5,6],[7,8,9]]    9 split 3
   ’        [[0,1,2],[3,4,5],[6,7,8]]    decrease
    Ẓ       [[0,0,1],[1,0,1],[0,1,0]]    isprime
     æ*³    [[0,0,1],[1,0,1],[0,1,0]]^n  matrix power by input
        FṀ                               flatten, maximum

Oásis , 5 bytes

nono termo indexado a 0

cd+1V

Experimente online!

Explicação

   1V   # a(0) = 1
        # a(1) = 1
        # a(2) = 1
        # a(n) =
c       #        a(n-2)
  +     #              +
 d      #               a(n-3)

Geléia ,  10 9  8 bytes

ŻṚm2Jc$S

Um link monádico que aceita n(indexado 0) que produz P(n).

Experimente online!

Quão?

Implementações$P(n) = \sum_{i=0}^{\lfloor\frac{n}2\rfloor}\binom{i+1}{n-2i}$

ŻṚm2Jc$S - Link: integer, n       e.g. 20
Ż        - zero range                  [0, 1, 2, 3, 4, ..., 19, 20]
 Ṛ       - reverse                     [20, 19, ..., 4, 3, 2, 1, 0]
  m2     - modulo-slice with 2         [20, 18, 16, 14, 12, 10,  8,  6,  4,  2,  0]  <- n-2i
      $  - last two links as a monad:
    J    -   range of length           [ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11]  <- i+1
     c   -   left-choose-right         [ 0,  0,  0,  0,  0,  0,  0, 28,126, 45,  1]
       S - sum                         200

E aqui está um "duplo"
... um método totalmente diferente também para 8 bytes (este é 1 indexado, mas muito mais lento):

3ḊṗRẎ§ċ‘ - Link: n
3Ḋ       - 3 dequeued = [2,3]
   R     - range = [1,2,3,...,n]
  ṗ      -   Cartesian power         [[[2],[3]],[[2,2],[2,3],[3,2],[3,3]],[[2,2,2],...],...]
    Ẏ    - tighten                   [[2],[3],[2,2],[2,3],[3,2],[3,3],[2,2,2],...]
     §   - sums                      [ 2,  3,   4,    5,    5,    6,     6,...]
       ‘ - increment                 n+1
      ċ  - count occurrences         P(n)

Haskell , 26 bytes

(l!!)
l=1:1:1:2:scanl(+)2l

Experimente online! Gera o nono termo indexado a zero.

Eu pensei que a solução recursiva "óbvia" abaixo seria imbatível, mas então eu achei isso. É semelhante à expressão clássica de golfe l=1:scanl(+)1lpara a lista infinita de Fibonacci, mas aqui a diferença entre elementos adjacentes é o termo 4 posições de volta. Podemos escrever mais diretamente l=1:1:zipWith(+)l(0:l), mas isso é mais longo.

Se esse desafio permitisse a saída infinita da lista, poderíamos cortar a primeira linha e ter 20 bytes.

27 bytes

f n|n<3=1|1>0=f(n-2)+f(n-3)

Experimente online!

Python 2 , 30 bytes

f=lambda n:n<3or f(n-2)+f(n-3)

Experimente online!

Retorna o nono termo zero indexado. Saídas Truepara 1.

Wolfram Language (Mathematica) , 33 bytes

a@0=a@1=a@2=1;a@n_:=a[n-2]+a[n-3]   

Indexado em 1, retorna o enésimo termo

Experimente online!

Oitava / MATLAB, 35 33 bytes

@(n)[1 filter(1,'cbaa'-98,2:n<5)]

Produz os primeiros n termos.

Experimente online!

Como funciona

Função anônima que implementa um filtro recursivo .

'cbaa'-98é uma forma mais curta de produzir [1 0 -1 -1].

2:n<5é uma forma mais curta de produzir [1 1 1 0 0 ··· 0]( n- 1 termos).

filter(1,[1 0 -1 -1],[1 1 1 0 0 ··· 0])passa a entrada [1 1 1 0 0 ··· 0]por um filtro de tempo discreto definido por uma função de transferência com coeficiente numerador 1e coeficiente denominador [1 0 -1 -1].

J , 22 bytes

-2 bytes graças a ngn e Galen

formulário fechado, 26 bytes

0.5<.@+1.04535%~1.32472^<:

Experimente online!

iterativo, 22 bytes

(],1#._2 _3{ ::1])^:[#

Experimente online!

Retina , 47 42 bytes

K`0¶1¶0
"$+"+`.+¶(.+)¶.+$
$&¶$.(*_$1*
6,G`

Experimente online! Produz os primeiros ntermos em linhas separadas. Explicação:

K`0¶1¶0

Substitua a entrada pelos termos para -2, -1e 0.

"$+"+`.+¶(.+)¶.+$
$&¶$.(*_$1*

Gere os próximos ntermos usando a relação de recorrência. *_aqui é curto para o $&*_qual converte o (primeiro) número da correspondência em unário, enquanto $1*é curto para o $1*_qual converte o número do meio em unário. O $.(retorna a soma decimal de seus argumentos unários, ou seja, a soma do primeiro e do meio números.

6,G`

Descarte os seis primeiros caracteres, ou seja, as três primeiras linhas.

Cubix , 20 bytes

Este é indexado 0 e emite o N ° termo

;@UOI010+p?/sqq;W.\(

Experimente online!

Envolve em um cubo com comprimento lateral 2

    ; @
    U O
I 0 1 0 + p ? /
s q q ; W . \ (
    . .
    . .

Assista correr

• I010 - Inicia a pilha
• +p? - Adiciona o topo da pilha, puxa o contador da parte inferior da pilha e testa
• /;UO@ - Se o contador for 0, reflita na face superior, remova os TOS, inversão de marcha, saída e pare
• \(sqq;W - Se o contador for positivo, reflita, diminua o contador, troque o TOS, empurre de cima para baixo duas vezes, remova o TOS e mude a faixa de volta para o loop principal.

Python 2 , 56 48 bytes

f=lambda n,a=1,b=1,c=1:n>2and f(n-1,b,c,a+b)or c

Experimente online!

Retorna o enésimo valor, indexado em 0.

Perl 6 , 24 bytes

{(1,1,1,*+*+!*...*)[$_]}

Experimente online!

Uma sequência gerada bastante padrão, com cada novo elemento gerado pela expressão * + * + !*. Isso adiciona o terceiro elemento anterior, o segundo elemento anterior e a negação lógica do elemento anterior, que é sempre False, que é numericamente zero.

05AB1E , 8 bytes

1Ð)λ£₂₃+

Experimente online!

1Ð)1D)3Å1$n$£

Quão?

1Ð)λ£₂₃+ | Full program.
1Ð)      | Initialize the stack with [1, 1, 1].
   λ     | Begin the recursive generation of a list: Starting from some base case,
         | this command generates an infinite list with the pattern function given.
    £    | Flag for λ. Instead of outputting an infinite stream, only print the first n.
     ₂₃+ | Add a(n-2) and a(n-3).

APL (Dyalog Unicode) , 20 18 17 bytes ^SBCS

Este código é indexado em 1. É o mesmo número de bytes para obter nitens da sequência Padovan, pois você precisa eliminar os últimos membros extras. Também é o mesmo número de bytes para obter a indexação 0.

Edit: -2 bytes graças a ngn. -1 byte graças a ngn

4⌷2(⊢,⍨2⌷+/)⍣⎕×⍳3

Experimente online!

Explicação

4⌷2(⊢,⍨2⌷+/)⍣⎕×⍳3

  ⍺(. . . .)⍣⎕⍵   This format simply takes the input ⎕ and applies the function
                   inside the brackets (...) to its operands (here marked ⍵ and ⍺).
  2(. . .+/)⍣⎕×⍳3  In this case, our ⍵, the left argument, is the array 1 1 1,
                   where we save our results as the function is repeatedly applied
                   and our ⍺, 2, is our right argument and is immediately applied to +/,
                   so that we have 2+/ which will return the pairwise sums of our array.
       2⌷          We take the second pairwise sum, f(n-2) + f(n-3)
    ⊢,⍨            And add it to the head of our array.
4⌷                 When we've finished adding Padovan numbers to the end of our list,
                   the n-th Padovan number (1-indexed) is the 4th member of that list,
                   and so, we implicitly return that.

K (ngn / k) , 24 20 bytes

-4 bytes graças a ngn!

{$[x<3;1;+/o'x-2 3]}

Experimente online!

Indexado em 0, primeiros termos N

código de máquina x86 de 32 bits, 17 bytes

53 33 db f7 e3 43 83 c1 04 03 d8 93 92 e2 fa 5b c3

Desmontagem:

00CE1250 53                   push        ebx  
00CE1251 33 DB                xor         ebx,ebx  
00CE1253 F7 E3                mul         eax,ebx  
00CE1255 43                   inc         ebx  
00CE1256 83 C1 04             add         ecx,4  
00CE1259 03 D8                add         ebx,eax  
00CE125B 93                   xchg        eax,ebx  
00CE125C 92                   xchg        eax,edx  
00CE125D E2 FA                loop        myloop (0CE1259h)  
00CE125F 5B                   pop         ebx  
00CE1260 C3                   ret

É 0 indexado. A inicialização é convenientemente alcançada calculando-se eax * 0. O resultado de 128 bits é 0 e entra em edx: eax.

No início de cada iteração, a ordem dos registros é ebx, eax, edx. Eu tive que escolher a ordem certa para tirar proveito da codificação da xchg eaxinstrução - 1 byte.

Eu tive que adicionar 4 ao contador de loop para permitir que a saída chegasse eax, o que mantém o valor de retorno da função na fastcallconvenção.

Eu poderia usar outra convenção de chamadas, que não requer salvamento e restauração ebx, mas fastcallé divertido mesmo assim :)

Gelatina , 11 bytes

5B+Ɲ2ị;Ʋ⁸¡Ḣ

Experimente online!

Indexado a 0.

Lua 5.3,49. 48 bytes

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

Experimente online!

Vanilla Lua não possui coerção de booleanos em strings ( tonumber(true)retornos pares nil), então você deve usar um operador pseudo-ternário. Esta versão é indexada em 1, como toda Lua. A 1orpeça deve ser alterada para 1 orLua 5.1, que possui uma maneira diferente de lexar números.

Ruby , 26 bytes

f=->n{n<3?1:f[n-2]+f[n-3]}

Experimente online!

JavaScript (ES6), 23 bytes

$a(0)=a(1)=a(2)=1$

$N$

f=n=>n<3||f(n-2)+f(n-3)

Experimente online!

Japonês -N , 12 bytes

<3ªßUµ2 +ß´U

Tente

TI-BASIC (TI-84), 34 bytes

[[0,1,0][0,0,1][1,1,0]]^(Ans+5:Ans(1,1

$N$

A entrada é no Ans.
A saída está dentro Anse é impressa automaticamente.

Imaginei que havia passado tempo suficiente, além de várias respostas terem sido postadas, das quais muitas foram superadas por essa resposta.

Exemplo:

0
               0
prgmCDGFD
               1
9
               9
prgmCDGFD
               9
16
              16
prgmCDGFD
              65

Explicação:

[[0,1,0][0,0,1][1,1,0]]^(Ans+5:Ans(1,1      ;full program (example input: 6)

[[0,1,0][0,0,1][1,1,0]]                     ;generate the following matrix:
                                            ; [0 1 0]
                                            ; [0 0 1]
                                            ; [1 1 0]
                       ^(Ans+5              ;then raise it to the power of: input + 5
                                            ; [4  7 5]
                                            ; [5  9 7]
                                            ; [7 12 9]
                               Ans(1,1      ;get the top-left index and leave it in "Ans"
                                            ;implicitly print Ans

Pitão, 16 bytes

L?<b3!b+y-b2y-b3

Isso define a função y. Experimente aqui!

Aqui está uma solução mais divertida, apesar de ter 9 bytes a mais; bytes podem ser raspados.

+l{sa.pMf.Am&>d2%d2T./QY!

Isso usa a definição dada por David Callan na página da OEIS: "a (n) = número de composições de n em partes ímpares e> = 3." Experimente aqui! Ele recebe entrada diretamente em vez de definir uma função.

Java, 41 bytes

Não é possível usar um lambda (erro de tempo de execução). Porta desta resposta Javascript

int f(int n){return n<3?1:f(n-2)+f(n-3);}

TIO

R + pryr , 38 36 bytes

Função recursiva indexada a zero.

f=pryr::f(`if`(n<3,1,f(n-2)+f(n-3)))

Experimente online!

Obrigado a @ Giuseppe por apontar dois bytes obviamente desnecessários.

C (clang) , 41 33 bytes

a(i){return i<3?1:a(i-2)+a(i-3);}

Experimente online!

C # (compilador interativo do Visual C #) , 34 bytes

int f(int g)=>g<3?1:f(g-2)+f(g-3);

Experimente online!

Perl 5 , 34 bytes

sub f{"@_"<3||f("@_"-2)+f("@_"-3)}

Experimente online!

Wolfram Language (Mathematica) , 26 bytes

If[#<3,1,#0[#-2]+#0[#-3]]&

Experimente online!

Pari / GP , 28 bytes

Indexado a 0.

f(n)=if(n<3,1,f(n-2)+f(n-3))

Experimente online!

Pari / GP , 35 bytes

1 indexado.

n->Vec((1+x+O(x^n))/(1-x^2-x^3))[n]

Experimente online!

$\frac{1+x}{1-x^2-x^3}$