Générez le n ème nombre Narayana-Zidek-Capell avec une entrée n . Le moins d'octets gagne.

f (1) = 1, f (n) est la somme des termes Narayana-Zidek-Capell du plancher précédent (n / 2).

Cas de test:

f(1)=1

f(9)=42

f(14)=1308

f(15)=2605

f(23)=664299

Gelée, 11 10 octets

HĊrµṖ߀Sȯ1

Essayez-le en ligne!

Prend ncomme argument et imprime le résultat.

Explication

H              divide input by 2
 Ċ             round up to get first n to recurse
  r            inclusive range from that to n
   µ           (chain separator)
    Ṗ          remove n itself from the range
     ߀        call self recursively on each value in the range
       S       sum results
        ȯ1     if sum was zero, return one

Rubis, 34 32 octets

Celui-ci utilise une formule de la page OEIS pour les nombres Narayana-Zidek-Cappell .

Edit: débarrassé des parenthèses en utilisant la priorité de l'opérateur grâce à feersum et Neil.

f=->x{x<4?1:2*f[x-1]-x%2*f[x/2]}

Python 2, 48 42 38 36 octets

Algorithme tiré de la page OEIS. n<3peut être remplacé n<4par sans effet. Renvoie le nnuméro e, où nest un entier positif.

a=lambda n:n<3or 2*a(n-1)-n%2*a(n/2)

Essayez-le en ligne

05AB1E, 16 octets

Une solution itérative comme 05AB1E n'a pas de fonctions.

X¸sGDN>;ï£Os‚˜}¬

X¸               # initialize a list with 1
  sG          }  # input-1 number of times do
    D            # duplicate current list
     N>;ï£       # take n/2 elements from the list
          O      # sum those elements
           s‚˜   # add at the start of the list
               ¬ # get the first element and implicitly print

Essayez-le en ligne

C, 38

Une traduction de l'algorithme OEIS. Il n'y a tout simplement pas assez de code C ici!

f(n){return n<3?:2*f(n-1)-n%2*f(n/2);}

Python 3, 67 octets

def f(n):
 x=1,
 for i in range(n):x+=sum(x[-i//2:]),
 print(x[-1])

Une fonction qui prend l'entrée via un argument et imprime dans STDOUT. Il s'agit d'une mise en œuvre directe de la définition.

Comment ça fonctionne

def f(n):               Function with input target term index n
 x=1,                   Initialise term list x as tuple (1)
 for i in range(n):...  For all term indices in [0,n-1]...
 x[-i//2:]              ..yield the previous floor(i/2) terms...
 x+=sum(...)            ...and append their sum to x
 print(x[-1])           Print the last term in x, which is the nth term

Essayez-le sur Ideone

Pyth, 12 octets

L|syM>/b2Ub1

Essayez-le en ligne. Suite de tests.

Définit une fonction y(n)qui renvoie le nnuméro Narayana-Zidek-Capell.

Mathematica, 38 octets

If[#<4,1,2#0[#-1]-#~Mod~2#0[(#-1)/2]]&

Fonction anonyme. Prend 𝑛 en entrée et renvoie 𝑓 (𝑛) en sortie. Basé sur la solution Ruby.

Haskell, 34 octets

f 1=1
f n=sum$f<$>[n-div n 2..n-1]

Exemple d'utilisation: f 14-> 1308.

Une mise en œuvre directe de la définition.

Java, 63 octets

int z(int n){return n<3?1:n%2>0?(2*z(n-1)-z(n/2)):(2*z(n-1));}

Aller, 63 octets

func f(i int) int{if(i<4){return 1};return 2*f(i-1)-i%2*f(i/2)}

À peu près un port direct de la réponse C

PHP, 81 octets

Il s'agit d'un programme complet sans récursivité. Une fonction récursive peut être définie en 52 octets (il pourrait être possible de battre cela), mais ce n'est qu'un port assez ennuyeux de la réponse de sherlock9 (et cela génère des erreurs si vous demandez f (100) ou plus), donc je mets en place cette version plus longue et plus intéressante

<?php for($i=$argv[1];$j=$i;$i--)for(;--$j*2>=$i;)$a[$j]+=$a[$i]?:1;echo$a[1]?:1;

Provoque de nombreuses notifications (O [n]) mais c'est très bien.

R, 55 octets

x[1]=1;for(i in 2:10){x[i]=sum(x[i-1:floor(i/2)])};x[9]

Changez 10dans la forboucle et x[9]obtenez l'index souhaité par l'utilisateur.

JavaScript, 54 52

f=n=>Math.round(n<3?1:2*f(n-1)-n%2*f(parseInt(n/2)))

Basé sur la réponse C.

• Enregistré 2 octets en utilisant parseIntau lieu deMath.floor

Érable, 46 44 octets

`if`(n<4,1,2*f(n-1)-(n mod 2)*f(floor(n/2)))

Usage:

> f:=n->`if`(n<4,1,2*f(n-1)-(n mod 2)*f(floor(n/2)));
> seq( f(i), i = 1..10 );
  1, 1, 1, 2, 3, 6, 11, 22, 42, 84

R, 63 octets

f=function(n,a=0)if(n<2)1 else{for(i in n-1:(n%/%2))a=a+f(i);a}

a=0est ajouté par défaut car il me fait économiser deux accolades. La fonction s'appelle récursivement au besoin.