Introdução

Um número pentagonal ( A000326 ) é gerado pela fórmula P _n = 0,5 × (3n ² -n) . Ou você pode apenas contar a quantidade de pontos usados:

Você pode usar a fórmula ou o gif acima para encontrar os primeiros números pentagonais:

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

Em seguida, precisamos calcular a soma de x números consecutivos.

Por exemplo, se x = 4 , precisamos olhar para P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (que consiste em 4 termos). Se a soma dos números pentagonais também for um número pentagonal, chamaremos isso de número pentagonal pentagonal .

Para x = 4 , o menor número de pentágono pentagonal é 330, composto de 4 números pentagonais consecutivos: 51, 70, 92, 117. Portanto, quando a entrada é 4, seu programa de função deve ser exibido 330.

Tarefa

• Quando é fornecido um número inteiro maior que 1, imprima o menor número de pentágono pentagonal.
• Você pode fornecer uma função ou um programa.
• Nota: Não há soluções para, por exemplo, x = 3 . Isso significa que, se não for possível criar um número a partir dos primeiros 10000 números pentagonais, você deverá parar de calcular e enviar o que for melhor para você.
• Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Casos de teste:

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: ?

Também números maiores podem ser dados:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 bytes

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

Experimente online.

Demora alguns segundos para executar.

Explicação

Primeiro, precisamos verificar quantos números pentagonais precisamos considerar como somas potenciais. A soma dos primeiros 10.000 números pentagonais é 500050000000. O primeiro número pentagonal maior que esse é o 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.

Usei um programa ligeiramente modificado para encontrar as maiores entradas que produzem uma solução não vazia. Estas são todas as soluções para insumos superiores 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

Ungolfed

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 inverter tabelas!

Atualização 142 bytes: salvou 10 bytes removendo a chamada de função supérflua 'tonumber'.

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)

Retorna 0se não houver um número pentagonal do pentágono.

Exemplo de uso (leva algum tempo para terminar): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0].

É mais ou menos uma implementação direta da definição: se a soma dos primeiros xelementos estiver na lista, produza-a; tente novamente com o final da lista. Comece com os primeiros 10.000 números pentagonais, pare e retorne 0se a lista tiver menos de xelementos.

PARI / GP, 71 bytes

Eu gosto da ispolygonalfunção no 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

Isso inverte a definição de um número pentagonal; se P (n) = (3n ^ 2-n) / 2, então um dado P será um número pentagonal iff (1 + sqrt (24 * P + 1)) / 6 é um número inteiro. (Tecnicamente, ele também deve considerar (1 sqrt (24 * P + 1)) / 6, mas isso sempre deve ser negativo.) Também usa espaços e tabulações como dois níveis diferentes de indentação, conforme sugerido aqui . Isso não produz nada se não conseguir encontrar um número pentagonal pentagonal; Eu acredito que tudo bem?

Acredito firmemente que alguém mais esperto do que eu possa encontrar uma maneira de encurtar ainda mais isso, provavelmente em torno do loop for.

LabVIEW, 39 Primitivas do LabVIEW

Nenhum gif dele sendo executado desta vez.

O nó matemático no loop cria uma matriz de todos os números. Pegue Sub-array, adicione elementos, pesquise esse número, se encontrado, pegue index e stop loop.

Uma entrada inválida coloca o maior número pentagonal.

R, 114 100 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])

ungolfed (meio)

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

Gelatina , 30 bytes

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

Este código funciona com esta versão do Jelly e é equivalente ao seguinte código binário:

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..

É de longe a abrandar e memória com fome para o intérprete on-line, uma vez que verifica a primeira 150.000.000 para pentagonality (149995000 passa a ser a 10.000 ^th número pentagonal).

Ao encurtar o alcance para algo mais sensato, você pode experimentar on-line! para entradas pequenas o suficiente.

Idéia

Um resultado conhecido sobre números pentagonais é que x é pentagonal se e somente se sqrt (24x + 1) - 1 é divisível por 6 .

Em vez de calcular os primeiros 10.000 números pentagonais, definimos um link auxiliar que remove números não pentagonais de uma determinada matriz. Por quê? Como a versão mais recente do Jelly que antecede esse desafio não tem uma maneira 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 (não concorrente)

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

A versão mais recente do Jelly possui dois novos recursos (sobreposição de fatias e filtro / interseção de lista) e uma correção de bug, que permite uma contagem de bytes muito menor.

Esse código funciona bem no meu computador desktop, mas é um pouco lento o tempo limite do TIO. Para experimentá-lo online! (para entradas suficientemente pequenas), precisamos reduzir o intervalo inicial mais uma vez.

Como 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 uma pesquisa rápida até 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)

ungolfed e 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

explicação: Podemos encontrar n usando o resultado "a", veja abaixo

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]

Isso acima significa que se existe um n0 tal que

p(n0)=a 

do que

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

Depois disso, temos que provar que p (n0) = a para ter certeza (porque nem sempre é assim)

Mas o principal truque seria fazer a soma

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

apenas no início e encontre a próxima soma de x elementos simplesmente usando

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

e assim por diante para as outras somas (usando acima na instrução a: = a + p (j + x) -p (j)). Isso significa que não é necessário somar um número x elemento dentro do loop ... ..

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

Experimente online!

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))