Tutti conoscono la sequenza di Fibonacci:
si prende un quadrato, si attacca un quadrato uguale ad esso, quindi si attacca ripetutamente un quadrato la cui lunghezza laterale è uguale alla lunghezza laterale più grande del rettangolo risultante.
Il risultato è una bellissima spirale di quadrati la cui sequenza di numeri è la sequenza di Fibonacci :

E se non volessimo usare i quadrati?

Se usiamo triangoli equilateri - anziché quadrati - in modo simile, otteniamo una spirale di triangoli altrettanto bella e una nuova sequenza: la sequenza padovana , nota anche come A000931 :

Compito:

Dato un intero positivo, $N$ , uscita $a_N$ , il $N$ ° termine nella sequenza Padovan OR primi $N$ termini.

Supponiamo che i primi tre termini della sequenza siano tutti $1$ . Così, la sequenza inizierà come segue:

Ingresso:

• Qualsiasi numero intero positivo $N\ge0$

• L'input non valido non deve essere preso in considerazione

Produzione:

• Il $N$ ° nella sequenza Padovan OR primi $N$ termini della successione Padovan.

• Se vengono stampati i primi $N$ termini, l'output può essere quello che è conveniente (elenco / array, stringa multilinea, ecc.)

• Può essere $0$ -indexed o $1$ -indexed

Casi di test:
(indicizzato 0, $N$ ° termine)

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

(1 indicizzato, primi $N$ termini)

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

Regole:

• Questo è code-golf : meno byte, meglio è!

• Sono vietate le scappatoie standard .

Gelatina , 10 byte

9s3’Ẓæ*³FṀ

Provalo online!

1-indicizzati. Calcola l'elemento più grande di:

(questa è una coincidenza totale.)

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

Oasi , 5 byte

ennesimo termine indicizzato 0

cd+1V

Provalo online!

Spiegazione

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

Gelatina ,  10 9  8 byte

ŻṚm2Jc$S

Un collegamento monadico che accetta n(indicizzato 0) che produce P(n).

Provalo online!

Come?

implementa $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

Ed ecco un "twofer"
... un metodo totalmente diverso anche per 8 byte (questo è 1-indicizzato, ma molto più 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 byte

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

Provalo online! Emette l'ennesimo termine indicizzato zero.

Ho pensato che la "ovvia" soluzione ricorsiva di seguito sarebbe stata imbattibile, ma poi ho trovato questo. È simile alla classica espressione da golfl=1:scanl(+)1l per la lista infinita di Fibonacci, ma qui la differenza tra elementi adiacenti è il termine 4 posizioni indietro. Possiamo scrivere più direttamente l=1:1:zipWith(+)l(0:l), ma è più lungo.

Se questa sfida consentisse un output infinito dell'elenco, potremmo tagliare la prima riga e avere 20 byte.

27 byte

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

Provalo online!

Python 2 , 30 byte

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

Provalo online!

Restituisce l'ennesimo termine zero indicizzato. Uscite Trueper 1.

Wolfram Language (Mathematica) , 33 byte

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

1 indicizzato, restituisce l'ennesimo termine

Provalo online!

Octave / MATLAB, 35 33 byte

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

Emette i primi n termini.

Provalo online!

Come funziona

Funzione anonima che implementa un filtro ricorsivo .

'cbaa'-98è una forma più breve da produrre [1 0 -1 -1].

2:n<5è una forma più breve da produrre [1 1 1 0 0 ··· 0]( n −1 termini).

filter(1,[1 0 -1 -1],[1 1 1 0 0 ··· 0])passa l'ingresso [1 1 1 0 0 ··· 0]attraverso un filtro a tempo discreto definito da una funzione di trasferimento con coefficiente numeratore 1e coefficienti denominatore [1 0 -1 -1].

J , 22 byte

-2 byte grazie a ngn e Galen

modulo chiuso, 26 byte

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

Provalo online!

iterativo, 22 byte

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

Provalo online!

Retina , 47 42 byte

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

Provalo online! Emette i primi ntermini su righe separate. Spiegazione:

K`0¶1¶0

Sostituire l'input con i termini per -2, -1e 0.

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

Genera i ntermini successivi usando la relazione di ricorrenza. *_qui è l'abbreviazione per $&*_cui converte il (primo) numero nella partita in unario, mentre $1*è l'abbreviazione per $1*_cui converte il numero medio in unario. Gli $.(restituisce la somma decimale dei suoi argomenti unari, cioè la somma dei primi numeri e medie.

6,G`

Scarta i primi sei caratteri, ovvero le prime tre righe.

Cubix , 20 byte

Questo è 0 indicizzato ed emette il N ° termine

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

Provalo online!

Si avvolge su un cubo con lunghezza laterale 2

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

Guarda correre

• I010 - Avvia lo stack
• +p? - Aggiunge la parte superiore dello stack, estrae il contatore dalla parte inferiore dello stack e verifica
• /;UO@ - Se il contatore è 0, rifletti sulla faccia superiore, rimuovi TOS, inversione a U, uscita e arresto
• \(sqq;W - Se il contatore è positivo, rifletti, diminuisci il contatore, scambia TOS, spingi due volte dall'alto verso il basso, rimuovi TOS e sposta la corsia nel circuito principale.

Python 2 , 56 48 byte

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

Provalo online!

Restituisce l'ennesimo valore, indicizzato 0.

Perl 6 , 24 byte

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

Provalo online!

Una sequenza generata piuttosto standard, con ogni nuovo elemento generato dall'espressione * + * + !*. Ciò aggiunge il terzo elemento precedente, il secondo elemento precedente e la negazione logica dell'elemento precedente, che è sempre False, che è numericamente zero.

05AB1E , 8 byte

1Ð)λ£₂₃+

Provalo online!

Abbi pazienza, non gioco a golf da un po '. Mi chiedo se c'è un sostituto più breve per 1Ð)cui funziona in questo caso (ho provato 1D),3Å1$n$£

Come?

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 byte ^SBCS

Questo codice è 1 indicizzato. È lo stesso numero di byte per ottenere nelementi della sequenza padovana, in quanto è necessario eliminare gli ultimi membri extra. È anche lo stesso numero di byte per ottenere l'indicizzazione 0.

Modifica: -2 byte grazie a ngn. -1 byte grazie a ngn

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

Provalo online!

Spiegazione

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 byte

-4 byte grazie a ngn!

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

Provalo online!

0 indicizzati, primi N termini

x86 codice macchina a 32 bit, 17 byte

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

Smontaggio:

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

È indicizzato 0. L'inizializzazione si ottiene convenientemente calcolando eax * 0. Il risultato a 128 bit è 0 e va in edx: eax.

All'inizio di ogni iterazione, l'ordine dei registri è ebx, eax, edx. Ho dovuto scegliere il giusto ordine per sfruttare la codifica per ilxchg eax istruzione - 1 byte.

Ho dovuto aggiungere 4 al contatore di loop per consentire all'uscita di raggiungere eax, che contiene il valore di ritorno della funzione nella fastcallconvenzione.

Potrei usare qualche altra convenzione di chiamata, che non richiede salvataggio e ripristino ebx, ma fastcallè comunque divertente :)

Gelatina , 11 byte

5B+Ɲ2ị;Ʋ⁸¡Ḣ

Provalo online!

0-indicizzati.

Lua 5.3,49 48 byte

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

Provalo online!

Vanilla Lua non ha coercizione di booleani su stringhe (persino tonumber(true)ritorni nil), quindi devi usare un operatore pseudo-ternario. Questa versione è 1 indicizzata, come tutta Lua. La 1orparte deve essere cambiata 1 orin Lua 5.1, che ha un modo diverso di creare numeri.

Rubino , 26 byte

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

Provalo online!

JavaScript (ES6), 23 byte

$a(0)=a(1)=a(2)=1$ , come specificato nella sfida.

$N$

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

Provalo online!

Japt -N , 12 byte

<3ªßUµ2 +ß´U

Provalo

TI-BASIC (TI-84), 34 byte

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

$N$

L'ingresso è in Ans.
L'output è attivo Anse viene stampato automaticamente.

Immaginai che fosse passato abbastanza tempo e che fossero state pubblicate più risposte, di cui ce n'erano molte che superavano quella risposta.

Esempio:

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

Spiegazione:

[[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

Pyth, 16 byte

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

Questo definisce la funzione y . Provalo qui!

Ecco una soluzione più divertente, sebbene sia più lunga di 9 byte; i byte potrebbero essere rasati però.

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

Questo utilizza la definizione data da David Callan nella pagina OEIS: "a (n) = numero di composizioni di n in parti che sono dispari e> = 3." Provalo qui! Prende direttamente input invece di definire una funzione.

Java, 41 byte

Impossibile utilizzare un lambda (errore di runtime). Porta di questa risposta Javascript

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

TIO

R + pryr , 38 36 byte

Funzione ricorsiva a indice zero.

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

Provalo online!

Grazie a @Giuseppe per aver segnalato due byte ovviamente inutili.

C (clang) , 41 33 byte

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

Provalo online!

C # (compilatore interattivo Visual C #) , 34 byte

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

Provalo online!

Perl 5 , 34 byte

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

Provalo online!

Wolfram Language (Mathematica) , 26 byte

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

Provalo online!

Pari / GP , 28 byte

0-indicizzati.

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

Provalo online!

Pari / GP , 35 byte

1-indicizzati.

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

Provalo online!

La funzione generatrice della sequenza è $\frac{1+x}{1-x^2-x^3}$.