Genere el enésimo número de Narayana-Zidek-Capell con una entrada n . Pocos bytes ganan.

f (1) = 1, f (n) es la suma de los términos del piso anterior (n / 2) Narayana-Zidek-Capell.

Casos de prueba:

f(1)=1

f(9)=42

f(14)=1308

f(15)=2605

f(23)=664299

Jalea, 11 10 bytes

HĊrµṖ߀Sȯ1

Pruébalo en línea!

Toma ncomo argumento e imprime el resultado.

Explicación

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

Ruby, 34 32 bytes

Utiliza una fórmula de la página OEIS para los números de Narayana-Zidek-Cappell .

Editar: Eliminé los paréntesis usando la precedencia del operador gracias a feersum y Neil.

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

Python 2, 48 42 38 36 bytes

Algoritmo tomado de la página OEIS. n<3puede cambiarse a n<4sin efecto. Devuelve el nnúmero th, donde nes un entero positivo.

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

Pruébalo en línea

05AB1E, 16 bytes

Una solución iterativa como 05AB1E no tiene funciones.

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

Pruébalo en línea

C, 38

Una traducción del algoritmo OEIS. ¡Simplemente no hay suficiente código C por aquí!

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

Python 3, 67 bytes

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

Una función que toma datos a través de argumentos e imprime en STDOUT. Esta es una implementación directa de la definición.

Cómo funciona

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

Pruébalo en Ideone

Pyth, 12 bytes

L|syM>/b2Ub1

Pruébalo en línea. Banco de pruebas.

Define una función y(n)que devuelve el nnúmero de Narayana-Zidek-Capell.

Mathematica, 38 bytes

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

Función anónima. Toma 𝑛 como entrada y devuelve 𝑓 (𝑛) como salida. Basado en la solución Ruby.

Haskell, 34 bytes

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

Ejemplo de uso: f 14-> 1308.

Una implementación directa de la definición.

Java, 63 bytes

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

Go, 63 bytes

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

Más o menos un puerto directo de la respuesta C

PHP, 81 bytes

Este es un programa completo sin recursividad. Se puede definir una función recursiva en 52 bytes (podría ser posible superar eso), pero eso es solo un puerto bastante aburrido de la respuesta de sherlock9 (y falla si pides f (100) o más), así que estoy poniendo esto versión más larga y más interesante

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

Causa muchos avisos (O [n]) pero está bien.

R, 55 bytes

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

Cambie 10el forciclo y x[9]obtenga el índice que desee el usuario.

JavaScript 54 52

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

Basado en la respuesta C.

• Se guardaron 2 bytes al usar en parseIntlugar deMath.floor

Arce, 46 44 bytes

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

Uso:

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

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

a=0se agrega por defecto porque me ahorra dos llaves. La función se llama recursivamente a sí misma según sea necesario.