Tout le monde connaît la séquence de Fibonacci:
vous prenez un carré, vous y attachez un carré égal, puis vous attachez plusieurs fois un carré dont la longueur du côté est égale à la plus grande longueur du rectangle obtenu.
Le résultat est une belle spirale de carrés dont la suite de nombres est la suite de Fibonacci :

Mais si nous ne voulions pas utiliser de carrés?

Si nous utilisons les triangles équilatéraux - au lieu de carrés - de la même manière, nous obtenons une spirale de triangles tout aussi belle et une nouvelle séquence: la séquence de Padovan , alias A000931 :

Tâche:

Étant donné un entier positif, , la sortie , le ème terme de la séquence de Padoue OU les premiers termes.$N$$a_N$$N$$N$

Supposons que les trois premiers termes de la séquence sont tous égaux à . Ainsi, la séquence commencera comme suit: $1$

Contribution:

• Tout entier positif$N\ge0$

• Une entrée invalide ne doit pas être prise en compte

Sortie:

• Le ième terme de la suite Padovan OU les premiers termes de la séquence Padovan.$N$N$N$

• Si les premiers termes sont imprimés, la sortie peut être celle qui convient (liste / tableau, chaîne multiligne, etc.)$N$

• Peut être soit indexé ou indexé$0$$1$

Cas de test:
(indexé 0, ème terme)$N$

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

(1 indexé, premiers termes)$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

Règles:

• C'est du code-golf : moins il y a d'octets, mieux c'est!

• Les failles standard sont interdites.

Gelée , 10 octets

9s3’Ẓæ*³FṀ

Essayez-le en ligne!

1 indexé. Calcule le plus grand élément de: où la matrice binaire est commodément calculée comme :

(Ceci est une coïncidence 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

Oasis , 5 octets

ième terme indexé par 0

cd+1V

Essayez-le en ligne!

Explication

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

Gelée ,  10 9  8 octets

ŻṚm2Jc$S

Un lien monadique acceptant n(indexé sur 0) qui cède P(n).

Essayez-le en ligne!

Comment?

Implémente$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

Et voici un "twofer"
... une méthode totalement différente également pour 8 octets (celui-ci est indexé sur 1, mais beaucoup plus lent):

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 octets

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

Essayez-le en ligne! Affiche le nième terme indexé à zéro.

Je pensais que la solution "évidente" récursive ci-dessous serait imbattable, mais ensuite j'ai trouvé ceci. Cela ressemble à l'expression classique de Golfy l=1:scanl(+)1lpour la liste infinie de Fibonacci, mais ici la différence entre les éléments adjacents est le terme 4 positions en arrière. Nous pouvons écrire plus directement l=1:1:zipWith(+)l(0:l), mais c'est plus long.

Si ce défi permettait la sortie d'une liste infinie, nous pourrions couper la première ligne et avoir 20 octets.

27 octets

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

Essayez-le en ligne!

Python 2 , 30 octets

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

Essayez-le en ligne!

Retourne le nième terme indexé à zéro. Sorties Truepour 1.

Wolfram Language (Mathematica) , 33 octets

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

1-indexé, retourne le nième terme

Essayez-le en ligne!

Octave / MATLAB, 35 33 octets

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

Affiche les n premiers termes.

Essayez-le en ligne!

Comment ça marche

Fonction anonyme qui implémente un filtre récursif .

'cbaa'-98est une forme plus courte à produire [1 0 -1 -1].

2:n<5est une forme plus courte à produire [1 1 1 0 0 ··· 0]( n −1 termes).

filter(1,[1 0 -1 -1],[1 1 1 0 0 ··· 0])passe l'entrée à [1 1 1 0 0 ··· 0]travers un filtre à temps discret défini par une fonction de transfert avec coefficient de numérateur 1et coefficient de dénominateur [1 0 -1 -1].

J , 22 octets

-2 octets grâce à ngn et Galen

formulaire fermé, 26 octets

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

Essayez-le en ligne!

itératif, 22 octets

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

Essayez-le en ligne!

Retina , 47 42 bytes

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

Essayez-le en ligne! Affiche les premiers ntermes sur des lignes séparées. Explication:

K`0¶1¶0

Remplacez l'entrée par les termes pour -2, -1et 0.

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

Générez les ntermes suivants à l'aide de la relation de récurrence. *_voici short pour $&*_lequel convertit le (premier) chiffre du match en unaire, alors que $1*short est utilisé pour $1*_convertir le nombre du milieu en unaire. Le $.(renvoie la somme décimale de ses arguments unaires, c'est-à-dire la somme des premier et deuxième nombres.

6,G`

Jeter les six premiers caractères, c’est-à-dire les trois premières lignes.

Cubix , 20 octets

Ceci est 0 indexé et sort le N ème terme

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

Essayez-le en ligne!

S'enroule sur un cube de côté 2

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

Regarde le courir

• I010 - Initie la pile
• +p? - Ajoute le haut de la pile, tire le compteur du bas de la pile et teste
• /;UO@ - Si le compteur est 0, réfléchissez sur la face supérieure, supprimez le TOS, faites demi-tour, sortez et arrêtez
• \(sqq;W - Si le compteur est positif, réfléchissez, décrémentez le compteur, échangez le TOS, appuyez deux fois de haut en bas, supprimez le TOS et replacez la voie dans la boucle principale.

Python 2 , 56 48 octets

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

Essayez-le en ligne!

Retourne la nième valeur, indexée à 0.

Perl 6 , 24 octets

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

Essayez-le en ligne!

Une jolie séquence standard générée, avec chaque nouvel élément généré par l'expression * + * + !*. Cela ajoute le troisième élément précédent, le deuxième élément précédent et la négation logique de l'élément précédent, qui est toujours False, numériquement nul.

05AB1E , 8 octets

1Ð)λ£₂₃+

Essayez-le en ligne!

Ours avec moi, je n'ai pas joué au golf depuis un moment. Je me demande s’il existe un substitut plus court 1Ð)qui fonctionne dans ce cas (j’ai essayé 1D), 3Å1etc., mais aucun d’entre eux ne sauvegarde des octets). Affiche les premiers termes de la séquence. Ou, sans le , cela produirait un flux infini de termes de la séquence.$n$£

Comment?

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

Ce code est indexé 1. C'est le même nombre d'octets pour obtenir les néléments de la séquence Padovan, car vous devez supprimer les derniers membres supplémentaires. C'est également le même nombre d'octets pour obtenir l'indexation 0.

Edit: -2 octets grâce à ngn. -1 octet grâce à ngn

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

Essayez-le en ligne!

Explication

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 octets

-4 octets grâce à ngn!

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

Essayez-le en ligne!

0 indexé, premiers N termes

Code machine x86 32 bits, 17 octets

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

Démontage:

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

Il est indexé par 0. L’initialisation est obtenue de manière commode en calculant eax * 0. Le résultat de 128 bits est 0 et le résultat est edx: eax.

Au début de chaque itération, l'ordre des registres est ebx, eax, edx. Je devais choisir le bon ordre pour tirer parti du codage de l' xchg eaxinstruction - 1 octet.

J'ai dû ajouter 4 au compteur de boucle afin de laisser la sortie atteindre eax, qui contient la valeur de retour de la fonction dans la fastcallconvention.

Je pourrais utiliser une autre convention d'appel, qui n'exige ni sauvegarde ni restauration ebx, mais qui fastcallest amusante quand même :)

Gelée , 11 octets

5B+Ɲ2ị;Ʋ⁸¡Ḣ

Essayez-le en ligne!

0 indexé.

Lua 5.3,49 48 octets

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

Essayez-le en ligne!

Vanilla Lua ne contraint pas les booléens aux chaînes (même les tonumber(true)retours nil), vous devez donc utiliser un opérateur pseudo-ternaire. Cette version est indexée 1, comme l’ensemble de Lua. La 1orpartie doit être changée 1 oren Lua 5.1, ce qui a une manière différente d’exprimer les nombres.

Ruby , 26 octets

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

Essayez-le en ligne!

JavaScript (ES6), 23 octets

Implémente la définition récursive de A000931 , mais avec , comme spécifié dans le challenge.$a(0)=a(1)=a(2)=1$

Retourne le ^ème terme, indexé par 0.$N$

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

Essayez-le en ligne!

Japt -N , 12 octets

<3ªßUµ2 +ß´U

L'essayer

TI-BASIC (TI-84), 34 octets

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

0-indexé ième terme de la suite.$N$

L'entrée est en Ans.
La sortie est Ansentrée et est automatiquement imprimée.

Je pensais que suffisamment de temps s'était écoulé et que plusieurs réponses avaient été postées, parmi lesquelles de nombreuses autres ont dépassé cette réponse.

Exemple:

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

Explication:

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

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

Ceci définit la fonction y. Essayez-le ici!

Voici une solution plus amusante, bien que sa longueur soit de 9 octets. les octets pourraient être rasés cependant.

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

Ceci utilise la définition donnée par David Callan à la page OEIS: "a (n) = nombre de compositions de n en parties impaires et> = 3." Essayez-le ici! Il prend directement les entrées au lieu de définir une fonction.

Java, 41 octets

Impossible d'utiliser un lambda (erreur d'exécution). Port de cette réponse Javascript

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

TIO

R + pryr , 38 36 octets

Fonction récursive à zéro index.

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

Essayez-le en ligne!

Merci à @ Giuseppe pour avoir signalé deux octets manifestement inutiles.

C (clang) , 41 33 octets

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

Essayez-le en ligne!

C # (compilateur interactif Visual C #) , 34 octets

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

Essayez-le en ligne!

Perl 5 , 34 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 26 octets

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

Essayez-le en ligne!

Pari / GP , 28 octets

0 indexé.

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

Essayez-le en ligne!

Pari / GP , 35 octets

1 indexé.

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

Essayez-le en ligne!

La fonction génératrice de la séquence est .$\frac{1+x}{1-x^2-x^3}$