El teorema del número poligonal de Fermat establece que cada entero positivo se puede expresar como la suma de, como máximo, números gonales. Esto significa que cada entero positivo puede expresarse como la suma de hasta tres números de triángulo, cuatro números cuadrados, cinco números pentagonales, etc. Su tarea es tomar un entero positivo , y un entero , y generar el enteros gonales que suman .$n$ $n$$x$$s \ge 3$$s$$x$

El entero -ésimo - gonal, donde y , se puede definir de dos maneras. La forma no matemáticas-y es que el º número -gonal puede ser construido como un polígono regular con lados, cada uno de longitud . Por ejemplo, para (números triangulares):$n$$s$$n \ge 1$$s \ge 3$$n$$s$$s$$n$$s = 3$

Ver aquí para ejemplos con una más grande .$s$

La definición matemática-y es mediante el uso de la fórmula para , que produce la -ésima número -gonal:$P(n, s)$$n$$s$

que se da en la página de Wikipedia aquí .

Entrada

Dos números enteros positivos, y , con la condición de . Puede ingresar estos enteros en la representación más natural en su idioma (decimal, unario, números de iglesia, números de coma flotante con valor entero, etc.).$s$$x$$s \ge 3$

Salida

Una lista de los números enteros, , con una longitud máxima de , donde la suma de es igual a y todos los números enteros en son números enteros -gonal. Una vez más, los números enteros se pueden generar en la representación natural en su idioma, con cualquier separador distinto y consistente (de modo que los caracteres no decimales para la salida decimal, un carácter diferente del utilizado para la salida unaria, etc.)$L$$s$$L$$x$$L$$s$

Reglas

• Las entradas o salidas nunca excederán el límite entero para su idioma
• $L$ no tiene que ser ordenado
• En caso de múltiples salidas posibles, cualquiera o todas son aceptables
• Este es el código de golf, por lo que gana el código más corto en bytes

Casos de prueba

   x,  s => L
   1,  s => 1
   2,  s => 1, 1
   5,  6 => 1, 1, 1, 1, 1
  17,  3 => 1, 6, 10
  17,  4 => 1, 16
  17,  5 => 5, 12
  36,  3 => 36
  43,  6 => 15, 28
 879, 17 => 17, 48, 155, 231, 428
4856, 23 => 130, 448, 955, 1398, 1925

Haskell , 78 80 77 bytes

Calculamos el producto cartesiano de los primeros $n$ números s-gonales, y luego encontramos la primera entrada que suma $n$ .

s#n=[x|x<-mapM(map(\n->s*(n^2-n)`div`2+n*(2-n)))([0..n]<$[1..s]),sum x==n]!!0

Pruébalo en línea!

JavaScript (ES6),  83  80 bytes

Una búsqueda recursiva rápida que maximiza el término más pequeño de la salida.

Toma entrada como (s)(x).

s=>g=(x,n=0,a=[],y=~n*(~-n-n*s/2))=>x<y?x|a[s]?0:a:g(x,n+1,a)||g(x-y,n,[...a,y])

Pruébalo en línea!

Fórmula

Resulta más corto usar una fórmula basada en 0 para calcular los números $s$ gonales en JS, es decir, comenzar con $n=0$ y calcular $P(n+1,s)$ :

que se puede escribir en 14 bytes:

~n*(~-n-n*s/2)

Comentado

s =>                         // main function taking s
  g = (                      // recursive function g
    x,                       // taking x
    n = 0,                   // start with n = 0
    a = [],                  // a[] = list of s-gonal numbers
    y =                      // y = P(n + 1, s)
      ~n * (~-n - n * s / 2) //   = -(n + 1) * ((n - 1) - n * s / 2)
  ) =>                       //
    x < y ?                  // if x is less than P(n + 1, s):
      x | a[s] ?             //   if x is not equal to 0 or a[] is too long:
        0                    //     failed: return 0
      :                      //   else:
        a                    //     success: return a[]
    :                        // else:
                             //   process recursive calls:
      g(x, n + 1, a) ||      //   preferred: try to increment n
      g(x - y, n, [...a, y]) //   fallback : try to use the current s-gonal number

05AB1E , 14 13 bytes

Port of Jonathan Allan's Jelly respuesta .

ÍIÝ*>.¥¹ã.ΔOQ

Pruébalo en línea!

Haskell , 55 bytes

n%s=[l|l<-mapM(\_->scanl(+)0[1,s-1..n])[1..s],sum l==n]

Pruébalo en línea!

Produce todas las soluciones posibles. Define los números s-gonales como la suma acumulativa de la progresión aritmética.

1, s-2, 2*s-3, 3*s-4, ...

Jalea , 17 bytes

x’2;’ÄÄx⁸ŒPS⁼¥Ƈ⁹Ḣ

Un enlace diádico (muy, muy ineficiente) que acepta sa la izquierda y xa la derecha, lo que produce la respuesta más corta posible como una lista de enteros (ordenados de forma ascendente).

Pruébalo en línea! ¡No tiene mucho sentido intentarlo con valores mucho más altos!

¿Cómo?

x’2;’ÄÄx⁸ŒPS⁼¥Ƈ⁹Ḣ - Link: s, x                    e.g.  5, 17
x                 - repeat (s) (x) times                [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
 ’                - decrement (vectorises)              [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
  2;              - prepend a two                       [2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]
    ’             - decrement (vectorises)              [1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
     Ä            - cumulative sums                     [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52]
      Ä           - cumulative sums                     [1, 5, 12, 22, 35, 51, 70, 92, 117, 145, 176, 210, 247, 287, 330, 376, 425, 477]
       x⁸         - repeat (each of those) (s) times    [1, 1, 1, 5, ..., 425, 477, 477, 477]
         ŒP       - power-set                           [[], [1], [1], ..., [1, 1], ..., [5, 22, 70], ... etc]
                      (this has 2^(x(s+1)) entries ...this example would have 2^(17(5+1)) = 2^102 = 5070602400912917605986812821504 entries!)
                      (Note: the lengths increase left to right)
              Ƈ   - filter keep if:
             ¥    -   last two links as a dyad:
           S      -     sum
            ⁼  ⁹  -     equals (x)?                     [[5,12], ... , [5,12], [1, 1, 5, 5, 5], ... , [1, 1, 5, 5, 5], [1, 1, 1, 1, 1, 12], ...]
                Ḣ - head                                [5,12]

Ruby , 79 bytes

$n$ $s$$s$

$\frac{n^2(s-2)-n(s-4)}{2}$$\frac{n(ns-2n-s+4)}{2}$

->n,s{a=(0..n).map{|i|i*(i*s-2*i-s+4)/2};a.product(*[a]*~-s).find{|a|a.sum==n}}

Pruébalo en línea!

Python 3 , 105 bytes

def f(s,x,n=0,a=[]):y=~n*(~-n-n*s/2);return(x<1)*a*(len(a)<=s)if x<y else f(s,x,n+1,a)or f(s,x-y,n,a+[y])

Pruébalo en línea!

La respuesta de JavaScript del Puerto de Arnauld , ¡así que asegúrate de votarlo!

Retina , 111 bytes

\d+
*
~(`$
$"
0%["^_+ "|""]'$L$`\G_(?<=(?=___(_*))_+)
((_(?($.(2*$>`))$1\$.(2*$>`)))$*)
1%|' L$`\G_
$$.$.($`$>`

Pruébalo en línea! El enlace incluye casos de prueba. Toma entrada en el orden s n. Explicación:

\d+
*

Convierte a unario.

~(`

Después de procesar las etapas restantes, trátelas como un programa Retina y ejecútelas en la misma entrada.

$
$"

Duplicar la línea.

0%["^_+ "|""]'$L$`\G_(?<=(?=___(_*))_+)
((_(?($.(2*$>`))$1\$.(2*$>`)))$*)

Reemplace la primera copia con una expresión regular que omita el primer número y luego coincida s scon los números gonales. Los números mismos se capturan en grupos de captura impares y los grupos de captura pares se utilizan para garantizar que todos los números sean sgonales.

1%|' L$`\G_
$$.$.($`$>`

Reemplace la segunda copia con una lista separada por espacios de los grupos de captura impares.

Como ejemplo, el código generado para una entrada de 5 17es el siguiente:

^_+ ((_(?(2)__\2))*)((_(?(4)__\4))*)((_(?(6)__\6))*)((_(?(8)__\8))*)((_(?(10)__\10))*)$
$.1 $.3 $.5 $.7 $.9

APL (NARS), 149 caracteres, 298 bytes

r←f w;n;s;i;k
(n s)←w⋄r←⍬⋄→0×⍳s<3⋄i←1
→0×⍳n<k←2÷⍨(i×i×s-2)-i×s-4⋄r←r,k⋄i+←1⋄→2

h←{0=≢b←((v←↑⍵)=+/¨a)/a←{0=≢⍵:⊂⍬⋄m,(⊂1⌷⍵),¨m←∇1↓⍵}f⍵:v⍴1⋄k←↑⍋≢¨b⋄k⊃b}

si no encuentra soluciones "0 = ≢b" que el retorno para la entrada (ns), n veces 1; de lo contrario, devolvería la suma de números s que tiene menos suma ...

prueba:

  h 1 3
1 
  h 2 8
1 1 
  h 5 6
1 1 1 1 1 
  h 17 3
1 6 10 
  h 17 4
1 16 
  h 17 5
5 12 
  h 36 3
36 
  h 43 6
15 28 
  h 879 17
17 48 155 231 428 
  h 4856 23
321 448 596 955 2536 
  +/h 4856 23
4856

El problema de esto: no encuentra alguna solución, tiene algún número repetido en la suma ...

C ++ (clang) , 198 bytes

#import<vector>
using V=std::vector<int>;V f(int n,int s){V _{0};int z=1,a=0,b=1,i,t;for(;a<n;b+=s-2)_.push_back(a+=b),++z;V o;for(t=a=0;t-n;b=++a)for(o=V(s),t=i=0;b;b/=z)t+=o[i++]=_[b%z];return o;}

Pruébalo en línea!

V=vector<int> 
V _{0}; // initialized with one element =0 
int z=1, // vector size 
a=0,b=1,i,t;for(;a<n;b+=s-2)_.push_back(a+=b),++z;
// pushes polygons in V
V o; // vector to be returned 
for(t=a=0;t-n;b=++a) // ends when t=n
// loop to generate multi-dimension indexes
// for example a=1234 z=10
// a%z->4 , a/=z , a%z-> 3 , ... 2 , 1
for(o=V(s),t=i=0;b;b/=z)// loop to extract indexes
t+=o[i++]=_[b%z]; // put the sum in t and values in o
return o