Introducción

La fórmula P _n = 0.5 × (3n ² -n) genera un número pentagonal ( A000326 ) . O simplemente puede contar la cantidad de puntos utilizados:

Puedes usar la fórmula o el gif de arriba para encontrar los primeros números pentagonales:

1, 5, 12, 22, 35, 51, 70, 92, 117, 145, 176, 210, 247, 287, 330, 376, 425, 477, etc...

A continuación, tenemos que calcular la suma de x números consecutivos.

Por ejemplo, si x = 4 , debemos mirar P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (que consta de 4 términos). Si la suma de los números pentagonales también es un número pentagonal, llamaremos a esto un número pentágono pentagonal .

Para x = 4 , el número pentágono pentagonal más pequeño es 330, que está hecho de 4 números pentagonales consecutivos: 51, 70, 92, 117. Entonces, cuando la entrada es 4, su programa de función debería salir 330.

Tarea

• Cuando se le da un número entero mayor que 1, genera el número pentágono pentagonal más pequeño.
• Puede proporcionar una función o un programa.
• Nota: No hay soluciones para, por ejemplo, x = 3 . Esto significa que si no se puede hacer un número a partir de los primeros 10000 números pentagonales, debe dejar de calcular y generar lo que mejor le convenga.
• Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes.

Casos de prueba:

Input: 2
Output: 1926 (which comes from 925, 1001)

Input: 3
Output: ?

Input: 4
Output: 330 (which comes from 51, 70, 92, 117)

Input: 5
Output: 44290 (which comes from 8400, 8626, 8855, 9087, 9322)

Input: 6
Output: 651 (which comes from 51, 70, 92, 117, 145, 176)

Input: 7
Output: 287 (which comes from 5, 12, 22, 35, 51, 70, 92)

Input: 8
Output: ?

Input: 9
Output: 12105 (which comes from 1001, 1080, 1162, 1247, 1335, 1426, 1520, 1617, 1717)

Input: 10
Output: ?

También se pueden dar números más grandes:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 bytes

6e5{)_3*(*2/}%_A4#<riew::+&1<

Pruébalo en línea.

Tarda un par de segundos en correr.

Explicación

Primero, debemos verificar cuántos números pentagonales debemos considerar como sumas potenciales. La suma de los primeros 10,000 números pentagonales es 500050000000. El primer número pentagonal mayor que ese es el 577,380º.

6e5       e# 600,000 (a short number that's a bit bigger than we need).
{         e# Map this block onto every number from 0 to 599,999...
  )       e#   Increment.
  _3*(*2/ e#   Apply the pentagonal number formula given in the challenge.
}%
_         e# Make a copy.
A4#<      e# Truncate to the first 10,000 elements.
ri        e# Read input and convert to integer.
ew        e# Get sublists of that length.
::+       e# Sum each sublist.
&         e# Set intersection with all 600k pentagonal numbers computed earlier.
1<        e# Truncate to the first result.

Utilicé un programa ligeramente modificado para encontrar las entradas más grandes que producen una solución no vacía. Estas son todas las soluciones para entradas mayores a 9,000:

9919 -> 496458299155
9577 -> 446991927537
9499 -> 455533474060
9241 -> 401702906276
9017 -> 429351677617

Lua, 142 bytes

p={}o={}n=...for i=1,10^4 do p[i]=(3*i^2-i)/2o[p[i]]=1 end for i=0,10^4-n do s=0 for j=1,n do s=s+p[i+j]end if(o[s])then print(s)break end end

Sin golf

p={}o={}n=tonumber(...)
for i=1,10^4 do 
    p[i]=(3*i^2-i)/2o[p[i]]=1 
end
for i=0,10^4-n do 
    s=0 
    for j=1,n do 
        s=s+p[i+j]
    end 
    if(o[s])then 
        print(s)
        break 
    end 
end

Yay para invertir mesas!

Actualización de 142 bytes: se guardaron 10 bytes al eliminar la llamada de función 'tonumber' superflua.

Haskell, 109 bytes

p=map(\n->div(3*n^2-n)2)[1..10^7]
(%)=(sum.).take
x#l|length l<x=0|elem(x%l)p=x%l|1<2=x#tail l
(#take(10^4)p)

Devuelve 0si no hay un número de pentágono pentagonal.

Ejemplo de uso (tarda un poco en terminar): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0].

Es más o menos una implementación directa de la definición: si la suma de los primeros xelementos está en la lista, envíela, de lo contrario, vuelva a intentarlo con la cola de la lista. Comience con los primeros 10,000 números pentagonales, pare y regrese 0si la lista tiene menos de xelementos.

PARI / GP, 71 bytes

Me gusta la ispolygonalfunción en PARI / GP.

x->[p|p<-vector(10^4,i,sum(n=i,i+x-1,(3*n^2-n)/2)),ispolygonal(p,5)][1]

Python 3, 144 bytes

R,P=range,list(map(lambda n:(3*n*n-n)/2,R(1,10001)))
def F(X):
 for a in R(0,len(P)-X):
    S=sum(P[a:a+X])
    if(1+(1+24*S)**.5)%6==0:print(S);break

Esto invierte la definición de un número pentagonal; si P (n) = (3n ^ 2-n) / 2, entonces una P dada será un número pentagonal iff (1 + sqrt (24 * P + 1)) / 6 es un número entero. (Técnicamente, también debe mirar (1-sqrt (24 * P + 1)) / 6, pero eso siempre debe ser negativo.) También usa espacios y pestañas como dos niveles de sangría diferentes, como se sugiere aquí . Esto no genera nada si no puede encontrar un número pentagonal pentagonal; ¿Confío en que está bien?

Creo firmemente que alguien más inteligente que yo podría encontrar una manera de acortar esto aún más, probablemente alrededor del ciclo for.

LabVIEW, 39 primitivas de LabVIEW

No hay gif que se ejecute esta vez.

El nodo matemático en bucle crea una matriz de todos los números. Tome Sub-array, agregue elementos, busque ese número, si se encuentra, tome el índice y pare el ciclo.

Una entrada inválida saca el número pentagonal más alto.

R, 114100 bytes

k=.5*(3*(t=1:1e6)^2-t);z=1;for(i in 1:(1e4-(n=scan()-1)))z[i]=sum(k[i:(i+n)]);cat(intersect(k,z)[1])

sin golf (un poco)

k=.5*(3*(t=1:1e6)^2-t)                 # map all pentagon numbers up to 1e6
z=1                                    # create a vector
for(i in 1:(1e4-(n=scan()-1))){        # from 1 to 10.000 - n loop
  z[i]=sum(k[i:(i+n)])}                # get the sum of all pentagon numbers i:(i+n)
cat(intersect(k,z)[1])                 # see which sums is a pentagon number itself, plot the first

Jalea , 30 bytes

×24‘½‘%6¬Oị
15ȷ7RÇṫ³R$zȷ.5ZSÇḢ

Este código funciona con esta versión de Jelly y es equivalente al siguiente código binario:

0000000: 94 32 34 b2 90 b2 25 36 87 4f b1 0a 31 35 a0  .24...%6.O..15.
000000f: 37 52 92 ad 8b 52 24 7a a0 2e 35 5a 53 92 a6  7R...R$z..5ZS..

Es mucho más lento y necesita mucha memoria para el intérprete en línea, ya que verifica los primeros 150,000,000 de pentagonalidad (149,995,000 es el ^número pentagonal número 10,000 ).

Al acortar el rango a algo más sensato, ¡puede probarlo en línea! para entradas lo suficientemente pequeñas.

Idea

Un resultado conocido sobre los números pentagonales es que x es pentagonal si y solo si sqrt (24x + 1) - 1 es divisible por 6 .

En lugar de calcular los primeros 10,000 números pentagonales, definimos un enlace auxiliar que elimina los números no pentagonales de una matriz dada. ¿Por qué? Debido a que la última versión de Jelly que es anterior a este desafío no tiene una forma sensata de cruzar listas ...

Código

×24‘½‘%6¬Oị  Define the aforementioned helper link. Left argument: a (list)

×24          Multiply each list item by 24.
   ‘         Increment each product.
    ½        Apply square root to each result.
     ’       Decrement each square root.
      %6     Compute all remainders of division by 6.
        ¬    Apply logical NOT.
         O   Get the indices of ones.
          ị  Hook; get the elements of a at those indices.

15ȷ7RÇṫ³R$zȷ.5ZSÇḢ  Define the main link. Input: x

15ȷ7R               Yields [1, ..., 1.5e8].
     Ç              Apply the helper link; keep only pentagonal numbers.
       ³R$          Yield r = [1, ..., x].
      ṫ             Remove the first y-1 pentagonal numbers for each y in r.
          zȷ.5      Transpose the resulting array, padding with sqrt(10).
              Z     Transpose once more. The shifted lists have now been padded.
                    This makes sure incomplete sums (i.e., of less than x
                    pentagonal numbers) will not be integers.
               S    Compute all sums.
                Ç   Apply the helper link once more.
                 Ḣ  Select the first match, if any.

Gelatina, 21 bytes (no competitiva)

ȷ6Rµ²×3_¹Hµḣȷ4ṡ³ZSf¹Ḣ

La última versión de Jelly tiene dos características nuevas (cortes superpuestos y filtrado / intersección de listas) y una corrección de errores, que permite un recuento de bytes mucho menor.

Este código funciona bien en mi computadora de escritorio, pero es un poco lento para el límite de tiempo de TIO. Para probarlo en línea! (para entradas suficientemente pequeñas), tenemos que reducir el rango inicial una vez más.

Cómo funciona

ȷ6Rµ²×3_¹Hµḣȷ4ṡ³ZSf¹Ḣ  Input: x

ȷ6R                    Yield [1, ..., 1,000,000].
   µ                   Begin a new, monadic chain.
    ²                  Square each number in the range.
     ×3                Multiply the squares by 3.
       _¹              Subtract the numbers from the range.
         H             Halve each difference.
                       This yields the first 1,000,000 pentagonal numbers.
          µ            Begin a new, monadic chain.
           ḣȷ4         Keep only the first 10,000 pentagonal numbers.
              ṡ³       Yield all overlapping slices of length x.
                ZS     Transpose and sum. This computes the sum of each slice.
                  f¹   Filter; intersect with the long list of pentagonal numbers.
                    Ḣ  Select the first match, if any.

Mathematica 85 bytes

n=577380;Intersection[#(3#-1)/2&/@Range@n,Table[#((#-1)^2+x(3#-4+3x))/2,{x,n}]][[1]]&

realiza una búsqueda rápida hasta P _{10 ⁴} .

Axioma, 157 bytes

p(n)==(3*n*n-n)quo 2;f(x)==(a:=0;for i in 1..x repeat a:=a+p(i);for j in 1..10000 repeat(p(floor((1+sqrt(1.+24*a))/6)::INT)=a=>return a;a:=a+p(j+x)-p(j));-1)

sin golf y resultados

h(x:PI):INT==
   a:=0;for i in 1..x repeat a:=a+p(i) -- sum(p(i),i=1..x)
   for j in 1..10000 repeat
      p(floor((1+sqrt(1.+24*a))/6)::INT)=a=>return a
      a:=a+p(j+x)-p(j)
   -1

(5) -> [[i,f(i)] for i in 1..10]
   (5)
   [[1,1], [2,1926], [3,- 1], [4,330], [5,44290], [6,651], [7,287], [8,- 1],
    [9,12105], [10,- 1]]
                                                  Type: List List Integer

esplenation: podemos encontrar n usando el resultado "a", ver abajo

a=(3*n^2-n)/2 => 3*n^2-n-2*a=0 => n=floor((1+sqrt(1.+24*a))/6)::INT

[use 1 + sqrt (...) porque n> 0]

Esto significa que si existe uno n0 tal que

p(n0)=a 

que

n0=floor((1+sqrt(1.+24*a))/6)::INT

Después de eso tenemos que demostrar que p (n0) = a para estar seguros (porque no siempre es así)

Pero el truco principal sería hacer la suma

a:=sum(p(i),i=1..x) [x elements sum] 

solo al comienzo, y encuentre la siguiente suma de elementos x simplemente usando

a=a+p(x+1)-p(1)=sum(p(i), i=2..x+1)

y así sucesivamente para las otras sumas (usando arriba en la declaración a: = a + p (j + x) -p (j)). Esto significa que no es necesario una suma de elementos número x dentro del bucle ...

Python 2 , 128 124 bytes

X=input();N=S=0
while all(S-(3*n*n-n)/2for n in range(S)):N+=1;S=sum(3*(n+N)**2-n-N>>1for n in range(X));N<1e4or 0/0
print S

Pruébalo en línea!

Javascript 93 bytes

p=i=>i>0&&3*i*i-i>>1
f=(x,i=1,t=0)=>i<1e4?(24*(t+=p(i)-p(i-x))+1)**.5%6==5&i>x?t:f(x,i+1,t):0

console.log(f(4))
console.log(f(5))
console.log(f(6))
console.log(f(7))
console.log(f(8))
console.log(f(9919)==496458299155)
console.log(f(9577)==446991927537)
console.log(f(9499)==455533474060)
console.log(f(9241)==401702906276)
console.log(f(9017)==429351677617)
console.log(f(9))
console.log(f(10))