Su tarea es, con un número de entrada p, encontrar el número de orden de bala de cañón positivo más pequeño pque NO sea 1.

Definición

Un número de bala de cañón (de orden p) es un número que es ambos:

• Un pnúmero-gonal ( Ver esta página ).

• y un pnúmero de pirámide gonal.

  • El nnúmero de la ppirámide th- gonal es la suma de los números 1 ° a nth- pgonal.
    • (por ejemplo 4th square pyramid number = 1 + 4 + 9 + 16 = 30)

  • La siguiente imagen representa el número de la 4ta pirámide cuadrada, como una pirámide cuadrada.

  • Para más información, visite este enlace .

El número de bala de cañón de orden 3, por ejemplo, es 10, porque es:

• El cuarto número de triángulo ( 1 + 2 + 3 + 4 = 10)
• y el tercer número de pirámide triangular. ( 1 + 3 + 6 = 10)

Fórmulas

NOTA: Si puede encontrar (o hacer) fórmulas más útiles que las mías aquí, publíquelas aquí (o envíeme un mensaje sobre el tema de chat de preguntas).

• Si está interesado, la fórmula para el nnúmero pgonal es:

• Y el nnúmero de la ppirámide th- gonal es:

Especificaciones

• p se garantiza que sea mayor que 2.
• El programa debe verificar los valores para una solución de phasta (e incluyendo) 2^16. Su programa puede hacer cualquier cosa si no se encuentran soluciones para p.
• Solo índices positivos para n.

Casos de prueba

• 3salidas 10(4 ° número de triángulo, 3 ° número de pirámide de triángulo)
• 4salidas 4900(número cuadrado 70, número piramidal cuadrado 24)

Este es el código de golf, por lo que la respuesta más corta en bytes gana.

Nota: Si publica una solución, incluya una descripción de cómo funciona el código.

¿Debo comenzar una recompensa por una solución que sea mejor y no use mis fórmulas?

Python 3, 129127 bytes

def f(p):
 x=2
 while 1:
  for i in range(x*x):
   if i//x*((p-2)*i//x+4-p)/2==i%x*(i%x+1)*((p-2)*i%x+5-p)/6==x:return x
  x+=1

Una función que toma la entrada a través del argumento y devuelve la salida.

Esta es una fuerza bruta extremadamente ingenua, y lleva mucho tiempo incluso para moderadamente grande p; el tiempo de ejecución será ridículo para cualquier cosa que se acerque al máximo dado pde 2^16, pero no hay ninguna razón por la cual el programa no funcionaría, dado el tiempo suficiente.

Probablemente hay formas mucho más cortas y rápidas de hacer esto, pero pensé que sería bueno publicar algo para comenzar esto.

Cómo funciona

El valor de retorno xse inicializa en 2, y luego el programa simplemente recorre todos los números piramidales pgonales y pgonales hasta el orden x. Si los números piramidales actuales p-gonales y p-gonales, calculados usando las fórmulas, son iguales entre sí y x, entonces, xdebe ser el número de bala de cañón relevante y se devuelve. De lo contrario, xse incrementa y el programa intenta nuevamente el nuevo valor de x.

En términos de golf, se utiliza un producto cartesiano para colapsar los dos bucles for para los números piramidales pgonal y pgonal en un solo bucle, y las fórmulas se factorizaron aún más para ahorrar unos pocos bytes.

JavaScript, 111 98 bytes

f=n=>{for(b=c=g=1;b++;)for(p=b*(b*3+b*b*(n-2)-n+5)/6;g<p;c++)if(p==(g=c*(c*n-c-c-n+4)/2))return p}

sin golf

f=n=>{
for(b=2,c=g=1;b<1e6;b++)    // run index b from 2 (to 100k)
    for(
        p=(b*b*3+b*b*b*(n-2)-b*(n-5))/6 // p=the b-th n-pyramidal number
        ;g<p&&c<1e6;c++)   // run while n-gonal is lower than n-pyramidal (and c below 100k)
        if(p==(
            g=(c*c*(n-2)-c*(n-4))/2     // g=the c-th n-gonal number
        )) return p                     // if they are equal, return
}

c no se reinicializa en el bucle interno porque la siguiente p [b] es definitivamente más grande que la actual g [c] (por lo que tenemos que seguir adelante de todos modos)

ejemplos

samples=[3,4,6,8,10,11,14,17,23,26,30,32,35,41,43,50,88]
for(i in samples) document.write('n='+(n=samples[i])+': '+f(n)+'<br>');

C, 107 bytes

#define X(x)(1+p/2.0*x)*++x
c(p,m,n,a,b){m=n=a=b=1;p-=2;do if(a>b)b+=X(n);else a=X(m);while(a^b);return a;}

Sin golfista con parámetros de prueba:

#include <stdio.h>

#define X(x)(1+p/2.0*x)*++x
int c(int p)
{
    int m = 1, n = 1, a = 1, b = 1;
    p -= 2;
    do
        if(b < X(m))
            b += X(n);
        else
            a = X(m);
    while(a != b);
    return a;
}

int main()
{
    printf("%d\n", c(3));
    printf("%d\n", c(4));
}

Esto utiliza el hecho de que el número n-ésimo p-gonal se puede definir como n(1+(p-2)(n-1)/2)y el número de la pirámide es la suma de los números antes mencionados.

Creo que se puede jugar más, dado que no es realmente necesario aguardar la variable .

antiguo programa PHP, 115106 bytes

^{+16 para PHP actual, ver abajo}

<?for($b=2;1;$b++)for($p=$b*($b*3+$b*$b*($n-2)-$n+5)/6;$g<$p;++$c)if($p==$g=$c*($c*$n-2*$c-$n+4)/2)echo$p;

• bucles para siempre
• uso: con PHP <4.2: ejecutar desde el navegador <scriptpath>?n=<number>
  con PHP <5.4, agregar register_globals=1a php.ini(+18?)
• ver mi respuesta de JavaScript para la descripción
• +10 para PHP> = 5.4: reemplazar 1con $n=$_GET[n]. O reemplazar 1con $n=$argv[1], correr php -f <filename> <number>.
• +6 para bucle finito en caso de éxito: reemplazar echo$pcondie(print$p)

• +/- 0 para la función:

  function f($n){for($b=2;1;$b++)for($p=$b*($b*3+$b*$b*($n-2)-$n+5)/6;$g<$p;++$c)if($p==$g=$c*($c*$n-2*$c-$n+4)/2)return$p;}
  

  bucles para siempre si no encuentra nada. Reemplace 1con $p<1e6para romper a 100k o con $p<$p+1un bucle hasta que el entero se desborde. (probado con PHP 5.6)

ejemplos (en función)

$samples=[3,4,6,8,10,11,14,17,23,26,30,32,35,41,43,50,88];
foreach($samples as $n)echo "<br>n=$n: ", f($n);

ejemplos de salida

n=3: 10
n=4: 4900
n=6: 946
n=8: 1045
n=10: 175
n=11: 23725
n=14: 441
n=17: 975061
n=23: 10680265
n=26: 27453385
n=30: 23001
n=32: 132361021
n=35: 258815701
n=41: 55202400
n=43: 245905
n=50: 314755
n=88: 48280