Introducción

En matemáticas, un número poligonal es un número representado como puntos o guijarros dispuestos en la forma de un polígono regular. Los puntos se consideran alfa (unidades). Estos son un tipo de números figurados bidimensionales.

El número 10, por ejemplo, se puede organizar como un triángulo:

*
**
***
****

Pero 10 no se puede organizar como un cuadrado. El número 9, por otro lado, puede ser:

***
***
***

Algunos números, como 36, se pueden organizar como un cuadrado y un triángulo:

******  *
******  **
******  ***
******  ****
******  *****
******  ******

Por convención, 1 es el primer número poligonal para cualquier número de lados. La regla para agrandar el polígono al siguiente tamaño es extender dos brazos adyacentes en un punto y luego agregar los lados adicionales necesarios entre esos puntos. En los siguientes diagramas, cada capa adicional se muestra en rojo.

Números triangulares

Números cuadrados:

Los polígonos con mayor número de lados, como los pentágonos y los hexágonos, también se pueden construir de acuerdo con esta regla, aunque los puntos ya no formarán una red perfectamente regular como la anterior.

Números Pentagonales:

Números Hexagonales:

^{Fuente: Wikipedia}

Tu tarea

Dado un número entero positivo N (1 <= N <= 1000), imprima cada tipo de Número poligonal N está comenzando desde los números triangulares hasta los números icosagonales (20 gon).

Por ejemplo, el número 10 es un número triangular y un número decagonal, por lo que la salida debería ser algo así (puede elegir su propio formato de salida, pero debería verse más o menos así):

3 10

Casos de prueba

1 -> 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
2 -> (None)
3 -> 3
6 -> 3 6
36 -> 3 4 13

Como referencia, el nnúmero knúmero - gonal es:

^{Crédito: xnor}

Recuerde, este es el código de golf , por lo que gana el código con la menor cantidad de bytes.

Python 3, 68 bytes

lambda R:[s+2for s in range(1,19)if(s-2+(4+s*(s-4+8*R))**.5)/2%s==0]

Para cada número potencial de lados s+2, resuelve la fórmula cuadrática R=s*n*(n-1)/2 + npara nver si el resultado es un número entero.

Comparar (73 bytes):

lambda R:[s+2for s in range(1,19)if R in[n+s*n*~-n/2for n in range(R+1)]]

Un enfoque alternativo para resolver sda 62 bytes en Python 3, pero falla R=1.

lambda R:{(R-n)*2/n/~-n+2for n in range(2,R+1)}&{*range(3,21)}

JavaScript (ES6), 90 bytes

n=>[...Array(21).keys(n--)].slice(3).filter(i=>(Math.sqrt(i*i+8*i*n-16*n)+i-4)%(i+i-4)==0)

Resuelve la ecuación cuadrática. 73 bytes en versiones suficientemente nuevas de Firefox:

n=>[for(i of Array(18).keys())if(((~-i**2+8*n*-~i)**.5+~-i)/2%-~i==0)i+3]

> <>, 62 + 3 = 65 bytes

&1v
v0<;?)+8a:+1~~<
1.292:{<>+n}ao^
>:&:&=?^:&:&)?^:@:@$-{:}++

Espera la entrada en la parte superior de la pila, por lo que +3 bytes para la -vbandera.

Esta es la primera vez que programo en> <>, por lo que es posible que me falten algunos trucos obvios para acortar el código.

Explicación:

Inicialización

&1v
v0<
1

Mueve N al registro, empuja el contador a la pila (comenzando en 1, que corresponde a números triangulares), y comienza la secuencia con los valores 0y 1.

Bucle principal

 :&:&=?^:&:&)?^:@:@$-{:}++

Compara la parte superior de la pila con el registro. Si es igual, vaya a la rutina de impresión. Si es mayor, vaya a la rutina de reinicio. De lo contrario, tome la diferencia entre los dos elementos superiores de la pila, agregue el contador y agregue al elemento anterior de la pila superior. Esto calcula el siguiente número poligonal.

Impresión

 .292:{<>+n}ao^
       ^

Imprime el contador + 2, seguido de una nueva línea, luego se mueve a la rutina de reinicio.

Reiniciar

v0<;?)+8a:+1~~<
1             ^

Elimina los dos elementos superiores de la pila e incrementa el contador. Finaliza el programa si el contador es mayor que 18, de lo contrario, empuja los números iniciales 0y 1hacia la pila y vuelve al bucle principal.

Jalea , 22 bytes

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3

Pruébalo en línea!

Explicación

18pȷµḢ×’×H+µ€_³¬FT:ȷ+3
18pȷ                   - All possible (k-2,n) pairs
    µ      µ€          - to each pair compute the corresponding polygonal number:
     Ḣ                 -   retrieve k-2
      ×’               -   multiply by n-1
        ×H             -   multiply by half of n
          +            -   add n
             _³        - subtract the input. There will now be 0's at (k-2,n) pairs which produce the input
               ¬FT     - retrieve all indices of 0's. The indices are now (k-2)*1000+n
                  :ȷ   - floor division by 1000, returning k-3
                    +3 - add 3 to get all possible k.

Axioma 203 bytes

 l(x)==(local q,m,a;v:List INT:=[];for i in 3..20 repeat(q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n);if #q>1 then(m:=rhs q.1;a:=rhs q.2;if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v)));v:=sort v;v)

aquí hay menos golf y rutina que muestran números

 l(x)==
  local q,m,a
  v:List INT:=[]
  for i in 3..20 repeat 
     q:=solve((i-2)*n*(n-1)+2*n-2*x=0,n)  -- this would find only rational solutions as r/s with r,s INT
     if #q>1 then -- if exist rational solution and denominator =1=> add to list of result
        m:=rhs q.1;a:=rhs q.2;
        if(m>0 and denom(m)=1)or(a>0 and denom(a)=1)then v:=cons(i,v) 
  v:=sort v
  v

 (2) ->  [[i,l(i)]  for i in 1..45]
    Compiling function l with type PositiveInteger -> List Integer

    (2)
    [[1,[3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]], [2,[]], [3,[3]],
     [4,[4]], [5,[5]], [6,[3,6]], [7,[7]], [8,[8]], [9,[4,9]], [10,[3,10]],
     [11,[11]], [12,[5,12]], [13,[13]], [14,[14]], [15,[3,6,15]], [16,[4,16]],
     [17,[17]], [18,[7,18]], [19,[19]], [20,[20]], [21,[3,8]], [22,[5]],
     [23,[]], [24,[9]], [25,[4]], [26,[]], [27,[10]], [28,[3,6]], [29,[]],
     [30,[11]], [31,[]], [32,[]], [33,[12]], [34,[7]], [35,[5]], [36,[3,4,13]],
     [37,[]], [38,[]], [39,[14]], [40,[8]], [41,[]], [42,[15]], [43,[]],
     [44,[]], [45,[3,6,16]]]
                                                           Type: List List Any

AWK , 67 bytes

{for(k=2;++k<21;)for(n=0;++n<=$1;)if((k/2-1)*(n*n-n)+n==$1)print k}

Pruébalo en línea!

Intenté realmente resolver la cuadrática, pero verificar cada valor para ver si funciona es más corto (y menos propenso a errores para mí)

R, 68 66 bytes

N=scan();m=expand.grid(k=1:18,1:N);n=m$V;m$k[m$k*n*(n-1)/2+n==N]+2

Lecturas Nde stdin. Calcula los primeros Nnúmeros k-gonales y obtiene el lugar kdonde son iguales N, usando la fórmula de xnor; sin embargo, guarda bytes en paréntesis al usar en 1:18lugar de 3:20y agregar 2al final.

expand.gridpor nombres predeterminados de las columnas Var1, Var2, ..., si no le es dado un nombre. $índices por coincidencia parcial, por lo que m$Vcorresponde a m$Var2,la segunda columna.

versión antigua:

N=scan();m=expand.grid(k=3:20,1:N);n=m$V;m$k[(m$k-2)*n*(n-1)/2+n==N]

Pruébalo en línea!

Pari / GP , 34 bytes

Pari / GP tiene una función incorporada para probar si un número es un número poligonal.

x->[s|s<-[3..20],ispolygonal(x,s)]

Pruébalo en línea!

Jalea , 20 bytes

^{Acabo de comenzar a escribir un engaño efectivo de este desafío (aunque cubriendo todos los k> 1 no solo [1,20]) ... ¡así que en su lugar lo responderé!}

Ṫð’××H+⁸
18pÇċ¥Ðf⁸+2

Un programa completo que imprime una representación de la lista Jelly de los resultados *

Pruébalo en línea!

* Sin resultados no imprime nada;
  un solo resultado imprime solo ese número;
  resultados múltiples imprime una lista []cerrada y , separada de los números

¿Cómo?

Ṫð’××H+⁸ - Link 1, ith (x+2)-gonal number: list [x,i]   e.g. [3,4] (for 4th Pentagonal)
Ṫ        - tail & modify (i.e. yield i & make input [x])     4
 ð       - new dyadic chain, i.e. left = i, right = [x]
  ’      - decrement i                                       3
   ×     - multiply by [x]                                   [9]
     H   - halve [x]                                         [2]
    ×    - multiply                                          [18]
       ⁸ - chain's left argument, i                          4
      +  - add                                               [22]

18pÇċ¥Ðf⁸+2 - Main link: number, n                      e.g. 36
18p         - Cartesian product of range [1,18] with n       [[1,1],[1,2],...,[1,36],[2,1],...,[18,1],[18,2],[18,36]]
            -   (all pairs of [(k-2),i] which could result in the ith k-gonal number being n)
      Ðf    - filter keep if this is truthy:
        ⁸   -   chain's left argument, n                     36
     ¥      -   last two links as a dyad:
   Ç        -     call the last link as a monad (note this removes the tail of each)
    ċ       -     count (this is 1 if the result is [n] and 0 otherwise)
            -                            filter keep result: [[1],[2],[11]]
         +2 - add two                                        [[3],[4],[13]]
            - implicit print ...due to Jelly representation: [3, 4, 13]