Reto

Escriba una función / programa que genere el n'elemento th, o los primeros nelementos, en la secuencia numérica bien conocida:

         1, 2, 4, 8, 16 ...

Oh, espera ... olvidé los primeros números:

1, 1, 1, 1, 2, 4, 8, 16 ...

Heck, agregaré algunos más por si acaso:

1, 1, 1, 1, 2, 4, 8, 16, 33, 69, 146, 312, 673, 1463, 3202, 7050, 15605, 34705 ...

Los números son números catalanes generalizados dados por la fórmula (indexado a cero):

dónde

Este es OEIS A004149 .

Puede elegir si desea tener la secuencia de índice cero o uno indexado. La secuencia, por supuesto, debe ser la misma, por lo que debe reescribir la fórmula si la tiene un índice.

Python , 51 bytes

f=lambda n,k=2:n<3or k<n and f(k)*f(n-k-2)+f(n,k+1)

Pruébalo en línea!

Simplifica un poco la fórmula:

Perl 6 , 44 bytes

{1,1,1,1,{sum @_[2..*]Z*@_[@_-4...0,0]}...*}

Pruébalo en línea!

Bloque de código anónimo que devuelve una secuencia infinita de valores perezosa. Esto prácticamente implementa la secuencia como se describe, con el acceso directo que comprime multiplica todos los elementos hasta ahora después del segundo elemento con el reverso de la lista comenzando desde el cuarto elemento y agregando un extra 1al final.

Explicación:

{                                          }  # Anonymous code block
                                       ...*   # Create an infinite sequence
 1,1,1,1,                                     # Starting with four 1s
         {                            }       # Where each new element is:
          sum                                   # The sum of
              @_[2..*]                          # The second element onwards
                      Z*                        # Zip multiplied with
                        @_[@_-4...0  ]          # The fourth last element backwards
                                   ,0           # And 1

05AB1E , 14 13 11 bytes

$ƒˆ¯Âø¨¨¨PO

Pruébalo en línea!

Emite el enésimo elemento, indexado a 0.

$                # push 1 and the input
 ƒ               # repeat (input+1) times
  ˆ              #  add the top of the stack (initially 1) to the global array
   ¯             #  push the global array
    Â            #  and a reversed copy of it
     ø           #  zip the two together, giving a list of pairs
      ¨¨¨        #  drop the last 3 pairs
         P       #  take the product of each pair (or 1 if the list is empty)
          O      #  take the sum of those products
                 #  after the last iteration, this is implicitly output;
                 #  otherwise, it's added to the global array by the next iteration

JavaScript (ES6), 42 bytes

Un puerto de la solución de xnor .

0 indexado.

f=(n,k=2)=>n<3||k<n&&f(k)*f(n+~++k)+f(n,k)

Pruébalo en línea!

JavaScript (ES6),  83  75 bytes

Una solución más rápida, menos recursiva, pero significativamente más larga.

0 indexado.

f=(n,i,a=[p=1])=>a[n]||f(n,-~i,[...a,p+=(h=k=>k<i&&a[k]*a[i-++k]+h(k))(2)])

Pruébalo en línea!

Haskell, 49 43 39 bytes

a n=max(sum[a k*a(n-2-k)|k<-[2..n-1]])1              

Pruébalo en línea!

Para n<3el sumes 0, entonces lo max ... 1eleva a 1.

Editar: -6 bytes gracias a @Jo King.

Wolfram Language (Mathematica) , 36 bytes

Sum[#0@i#0[#-i-1],{i,3,#-1}]/. 0->1&

Pruébalo en línea!

1 indexado.

La secuencia 2-indexada es de 4 bytes más corto: Sum[#0@i#0[#-i],{i,#-4}]/. 0->1&. Pruébalo en línea!

05AB1E , 17 13 bytes

4Å1λ£₁λ¨Â¦¦s¦¦*O+

No más corto que la respuesta 05AB1E existente , pero quería probar la funcionalidad recursiva de la nueva versión 05AB1E como práctica para mí. Quizás podría jugarse unos pocos bytes. EDIT: Y de hecho puede, ver la versión recursiva de @Grimy respuesta 05AB1E 's de abajo, que es 13 bytes .

$n$

$n$£è
£

Explicación:

$a(n)= a(n-1) + \sum_{k=2}^{n-1}(a(k)\cdot a(n-1-k))$

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

   λ               # Create a recursive environment,
    £              # to output the first (implicit) input amount of results after we're done
4Å1                # Start this recursive list with [1,1,1,1], thus a(0)=a(1)=a(2)=a(3)=1
                   # Within the recursive environment, do the following:
      λ            #  Push the list of values in the range [a(0),a(n)]
       ¨           #  Remove the last one to make the range [a(0),a(n-1)]
        Â          #  Bifurcate this list (short for Duplicate & Reverse copy)
         ¦¦        #  Remove the first two items of the reversed list,
                   #  so we'll have a list with the values in the range [a(n-3),a(0)]
           s       #  Swap to get the [a(0),a(n-1)] list again
            ¦¦     #  Remove the first two items of this list as well,
                   #  so we'll have a list with the values in the range [a(2),a(n-1)]
              *    #  Multiply the values at the same indices in both lists,
                   #  so we'll have a list with the values [a(n-3)*a(2),...,a(0)*a(n-1)]
               O   #  Take the sum of this list
     ₁          +  #  And add it to the a(n-1)'th value
                   # (afterwards the resulting list is output implicitly)

Versión de 13 bytes de @Grimy (¡asegúrate de votar su respuesta si aún no lo has hecho!):

1λ£λ1šÂ¨¨¨øPO

$n$

1λèλ1šÂ¨¨¨øPO
λλ1šÂ¨¨¨øPO$a(0)=1$

Explicación:

$a(n) = \sum_{k=2}^{n-1}(a(k)\cdot a(n-2-k))$

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

 λ             # Create a recursive environment,
  £            # to output the first (implicit) input amount of results after we're done
1              # Start this recursive list with 1, thus a(0)=1
               # Within the recursive environment, do the following:
   λ           #  Push the list of values in the range [a(0),a(n)]
    1š         #  Prepend 1 in front of this list
      Â        #  Bifurcate the list (short for Duplicate & Reverse copy)
       ¨¨¨     #  Remove (up to) the last three value in this reversed list
          ø    #  Create pairs with the list we bifurcated earlier
               #  (which will automatically remove any trailing items of the longer list)
           P   #  Get the product of each pair (which will result in 1 for an empty list)
            O  #  And sum the entire list
               # (afterwards the resulting list is output implicitly)

Python 3 , 59 bytes

realmente ineficiente, a(13)no termina en TIO.

a=lambda n,k=2:n<4or(n-k<2)*a(n-1)or a(k)*a(n-k-2)+a(n,k+1)

Pruébalo en línea!

Jalea , 17 bytes

1WṪ;+¥×Uṫ3SƲ;@Ʋ⁸¡

Pruébalo en línea!

$n$$0$$n$ .

Haskell , 76 bytes

1:1:1:f[1,1,1]
f(x:z)|y<-x+sum(zipWith(*)(init$init z)$reverse z)=y:f(y:x:z)

Pruébalo en línea!

APL (Dyalog Extended) , ^{SBCS de} 34 bytes

-2 gracias a dzaima.

Prefijo anónimo lambda.

{⍵≤3:1⋄+/(∇⍵-1),⍵(-×⍥∇¯2+⊢)¨4…⍵}

Pruébalo en línea!

Japt , 19 17 16 bytes

Emite el ntérmino th, 1-indexado.

@Zí*Zz2)Ťx}g4Æ1

Intentalo

@Zí*Zz2)Ťx}g4Æ1     :Implicit input of integer U
@                    :Function taking an array as an argument via parameter Z
 Zí                  :  Interleave Z with
    Zz2              :  Z rotated clockwise by 180 degrees (simply reversing would be a bye shorter but would modify the original array)
   *                 :  Reduce each pair by multiplcation
       )             :  End interleave
        Å            :  Slice off the first element
         ¤           :  Slice off the first 2 elements
          x          :  Reduce by addition
           }         :End function
            g        :Pass the following as Z, push the result back to it and repeat until it has length U
             4Æ1     :Map the range [0,4) to 1s
                     :Implicit output of the last element

Haskell , 65 bytes

f a|a<4=1|z<-g[2..a]=sum$zipWith(*)z$reverse(1:g[0..a-4])
g=map f

Pruébalo en línea!

Puede usar fpara obtener un solo elemento de una secuencia, o pasar una lista de valores gy obtener todos los índices para esa lista.

Adelante (gforth) , 99 81 bytes

: f recursive dup 4 > if 0 over 3 do over 1- i - f i f * + loop else 1 then nip ;

Pruébalo en línea!

La salida es el enésimo término y la entrada está indexada en 1

Editar: ahorró 17 bytes cambiando a la fórmula de xnor. Se guardó otro 1 byte usando 1 indexado

Explicación del Código

: f                     \ start a new word definition
  recursive             \ mark that this word will be recursive
  dup 4 >               \ duplicate the input and check if it is greater than 4
  if                    \ if it is:
    0 over              \ create an accumulator and copy n to top of stack
    3 do                \ start counted loop from 3 to n-1
      over 1- i - f     \ recursively calculate f(n-1-i)
      i f               \ recursively calculate f(i)
      * +               \ multiply results and add to accumulator
    loop                \ end the counted loop        
  else                  \ otherwise, if n < 5
    1                   \ put 1 on the stack
  then                  \ end the if block
  nip                   \ drop n from the stack
;                       \ end the word definition

Carbón , 26 bytes

Ｆ⁵⊞υ¹ＦＮ⊞υΣ✂Ｅ⮌υ×κ§υλ³→Ｉ§υ±⁴

Pruébalo en línea! El enlace es a la versión detallada del código. Imprime el enésimo número indexado en 0, aunque calcula utilizando la indexación 1 internamente. Explicación:

Ｆ⁵⊞υ¹

Comenzar con a[0] = a[1] = a[2] = a[3] = a[4] = 1. Sí, esto está indexado en 1, pero luego con un valor cero adicional. Eso es código golf para ti.

ＦＮ

Calcular unos ntérminos adicionales . Esto es excesivo, pero hace que encontrar el término deseado sea más fácil cuando n<5.

⊞υΣ✂Ｅ⮌υ×κ§υλ³

Para cada término, calcule el siguiente término como la suma de los términos hasta el momento multiplicados por el reverso de los términos hasta el momento, excluyendo tres términos.

→

Este es un no-op utilizado para engañar a Charcoal para que analice la forma de 2 argumentos Slice, de lo contrario tendría que usar una forma menos golfosa de eliminar tres términos.

Ｉ§υ±⁴

Salida del 4to último término.

Pyth , 30 bytes

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<J

Pruébalo en línea!

$n$

J*4]1VQ=+J+eJsPP*M.t,PJ_PJ0;<JQ # Full program, last Q = input (implicitly added)
J*4]1                  # J = 4 * [1] (=[1,1,1,1])
VQ                     # for N in range(Q):
  =+J                  #  J +=
     +eJ               #   J[-1] + 
        s              #    sum(                           )
           *M          #     map(__operator_mul,          )
             .t      0 #      transpose(          , pad=0)
               ,       #       [       ,         ]
                PJ     #         J[:-1] 
                  _PJ  #                 J[1::-1]
<JQ                    # J[::Q]

<@$n$

Ruby , 42 41 bytes

f=->n{n<4?1:(4..n).sum{|i|f[i-1]*f[n-i]}}

Pruébalo en línea!

1 indexado (para guardar 1 byte)

Octava , 73 bytes

g=(1:4).^0;for(i=3:(n=input('')))g(i+2)=g(4:i+1)*g(i-(2:i-1))';end;g(end)

Pruébalo en línea!

-2 bytes gracias a Stewie Griffin. Una vez más, el enfoque imperativo gana al enfoque recursivo funcional. Ese se muestra a continuación.

Octava , 75 bytes

f(f=@(a)@(n){@()sum(arrayfun(@(k)a(a)(k)*a(a)(n-2-k),2:n-1)),1}{2-(n>3)}())

Pruébalo en línea!

Captcha quería verificar que era humano cuando publicaba esto. Para ser honesto, no estoy tan seguro .

Perl 5 -MList::Util=sum , 61 bytes

sub a{my$b=-2+pop;$b<2||sum a($b+1),map{a($_)*a($b-$_)}2..$b}

Pruébalo en línea!

C / C ++ , 70 69 67 bytes

-1 bytes gracias a Jonathan.

int a(int n){int k=2,s=0;while(++k<n)s+=a(k)*a(n+~k);return s?s:1;}

Pruébalo en línea!