Una fuente es una disposición de monedas en filas para que cada moneda toque dos monedas en la fila debajo de ella, o esté en la fila inferior, y la fila inferior esté conectada. Aquí hay una fuente de 21 monedas:

Su desafío es contar cuántas fuentes diferentes se pueden hacer con un número determinado de monedas.

Se le dará como entrada un número entero positivo n. Debe generar la cantidad de nfuentes de monedas diferentes que existen.

Reglas estándar de E / S, lagunas estándar prohibidas. Las soluciones deberían poder calcularse n = 10en menos de un minuto.

Salida deseada para n = 1 ... 10:

1, 1, 2, 3, 5, 9, 15, 26, 45, 78

Esta secuencia es OEIS A005169 .

Este es el código de golf. Pocos bytes ganan.

Python, 57 bytes

f=lambda n,i=0:sum(f(n-j,j)for j in range(1,i+2)[:n])or 1

Como se observa en OEIS , si desplaza cada fila medio paso en relación con la fila debajo de ella, los tamaños de columna forman una secuencia de enteros positivos con un paso ascendente máximo de 1.

La función f(n,i)cuenta las secuencias con suma ny último número i. Estos se pueden sumar recursivamente para cada elección del siguiente tamaño de columna de 1a i+1, que es range(1,i+2). Truncar para range(1,i+2)[:n]evitar que las columnas usen más monedas de las que quedan, evitando tener que decir que los negativos ndan 0. Además, evita un caso base explícito, ya que la suma vacía es 0y no es recurrente, pero f(0)debe establecerse en su 1lugar, para lo cual es or 1suficiente (como lo haría +0**n).

Mathematica, 59 bytes

SeriesCoefficient[1-Fold[1-x^#2/#&,Range[#,0,-1]],{x,0,#}]&

Basado en el programa Mathematica en OEIS de Jean-François Alcover.

Haskell 60 48 bytes

¡Gracias a @nimi por proporcionar una solución mucho más corta!

n#p|p>n=0|p<n=sum$map((n-p)#)[1..p+1]|1<2=1
(#1)

Versión antigua.

t n p|p>n=0|p==n=1|p<n=sum[t (n-q) q|q<-[1..p+1]]
s n=t n 1

La función que calcula el valor es la simplementación de la fórmula recursiva que se encuentra aquí: https://oeis.org/A005169

Haskell, 43 bytes

n%i=sum[(n-j)%j|j<-take n[1..i+1]]+0^n
(%0)

Ver la respuesta de Python para obtener una explicación.

Misma longitud con minmás que take:

n%i=sum[(n-j)%j|j<-[1..min(i+1)n]]+0^n
(%0)

Pyth, 21 20 bytes

Ms?>GHgL-GHShHqGHgQ1

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

Esta es una implementación directa de la fórmula recursiva en la página OEIS , como la respuesta de Matlab .

Matlab, 115105 bytes

function F=t(n,varargin);p=1;if nargin>1;p=varargin{1};end;F=p==n;if p<n;for q=1:p+1;F=F+t(n-p,q);end;end

Implementación de la fórmula recursiva que se encuentra aquí: https://oeis.org/A005169

function F=t(n,varargin);
p=1;
if nargin>1
    p=varargin{1};
end;
F=p==n;
if p<n;
    for q=1:p+1;
        F=F+t(n-p,q);
    end;
end;

Julia, 44 43 bytes

f(a,b=1)=a>b?sum(i->f(a-b,i),1:b+1):1(a==b)

Esto utiliza la fórmula recursiva en OEIS.

Explicación

function f(a, b=1)
    if a > b
        # Sum of recursing
        sum(i -> f(a-b, i), 1:b+1)
    else
        # Convert bool to integer
        1 * (a == b)
    end
end

¿Alguien más se ha dado cuenta de que el strike 44 es regular 44?

Python 3, 88 bytes

f=lambda n,p:sum([f(n-p,q)for q in range(1,p+2)])if p<n else int(p==n)
t=lambda n:f(n,1)

JavaScript (ES6), 63

Implementando la fórmula recursiva en la página OEIS

F=(n,p=1,t=0,q=0)=>p<n?eval("for(;q++<=p;)t+=F(n-p,q)"):p>n?0:1