introduzione

Un numero pentagonale ( A000326 ) è generato dalla formula P _n = 0,5 × (3n ² -n) . Oppure puoi semplicemente contare la quantità di punti utilizzati:

Puoi usare la formula o la gif sopra per trovare i primi numeri pentagonali:

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

Successivamente, dobbiamo calcolare la somma di x numeri consecutivi.

Ad esempio, se x = 4 , dobbiamo guardare P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (che consiste in 4 termini). Se anche la somma dei numeri pentagonali è un numero pentagonale, chiameremo questo un numero pentagonale pentagonale .

Per x = 4 , il numero più piccolo pentagono pentagonale 330, che è fatta di 4 numero pentagonale consecutivi: 51, 70, 92, 117. Quindi, quando l'ingresso è 4, il tuo programma di funzione dovrebbe essere emesso 330.

Compito

• Quando viene dato un numero intero maggiore di 1, genera il numero pentagono pentagonale più piccolo.
• È possibile fornire una funzione o un programma.
• Nota: non ci sono soluzioni per es. X = 3 . Ciò significa che se non è possibile creare un numero dai primi 10000 numeri pentagonali, è necessario interrompere il calcolo e produrre ciò che si adatta meglio a te.
• Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Casi test:

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

Anche numeri più grandi possono essere dati:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 byte

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

Provalo online.

Ci vogliono un paio di secondi per correre.

Spiegazione

Innanzitutto, dobbiamo verificare quanti numeri pentagonali dobbiamo considerare come potenziali somme. La somma dei primi 10.000 numeri pentagonali è 500050000000. Il primo numero pentagonale maggiore di quello è il 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.

Ho usato un programma leggermente modificato per trovare gli input più grandi che producono una soluzione non vuota. Queste sono tutte le soluzioni per input superiori a 9.000:

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

Lua, 142 byte

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 per invertire le tabelle!

Aggiornamento 142 byte: salvati 10 byte rimuovendo la chiamata di funzione "tonumber" superflua.

Haskell, 109 byte

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)

Restituisce 0se non c'è un numero pentagonale pentagonale.

Esempio di utilizzo (richiede del tempo per terminare): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0].

È più o meno un'implementazione diretta della definizione: se la somma dei primi xelementi è nella lista, emettila, altrimenti riprova con la coda della lista. Inizia con i primi 10.000 numeri pentagonali, fermati e torna 0se l'elenco ha meno di xelementi.

PARI / GP, 71 byte

Mi piace la ispolygonalfunzione in 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 byte

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

Ciò inverte la definizione di un numero pentagonale; se P (n) = (3n ^ 2-n) / 2, allora una data P sarà un numero pentagonale iff (1 + sqrt (24 * P + 1)) / 6 è un numero intero. (Tecnicamente, dovrebbe anche guardare (1 sqrt (24 * P + 1)) / 6, ma dovrebbe sempre essere negativo.) Utilizza anche spazi e tabulazioni come due diversi livelli di rientro, come suggerito qui . Questo non produce nulla se non riesce a trovare un numero pentagonale pentagonale; Confido che sia OK?

Credo fermamente che qualcuno più intelligente di me possa trovare un modo per accorciarlo ancora di più, probabilmente attorno al ciclo for.

LabVIEW, 39 primitivi LabVIEW

Nessuna gif di questa volta in esecuzione.

Il nodo matematico in loop crea una matrice di tutti i numeri. Prendi l'array secondario, aggiungi elementi, cerca quel numero, se trovato prendi l'indice e ferma il ciclo.

Un input non valido indica il numero pentagonale più alto.

R, 114 100 byte

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

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 byte

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

Questo codice funziona con questa versione di Jelly ed è equivalente al seguente codice 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..

È di gran lunga lento e affamato di memoria per l'interprete online, poiché controlla i primi 150.000.000 di pentagonalità (149.995.000 è il 10.000 ^° numero pentagonale).

Riducendo la portata a qualcosa di più sensato, puoi provarlo online! per input abbastanza piccoli.

Idea

Un risultato noto sui numeri pentagonali è che x è pentagonale se e solo se sqrt (24x + 1) - 1 è divisibile per 6 .

Invece di calcolare i primi 10.000 numeri pentagonali, definiamo un collegamento helper che rimuove i numeri non pentagonali da un determinato array. Perché? Perché l'ultima versione di Jelly che precede questa sfida non ha alcun modo sano di intersecare gli elenchi ...

Codice

×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 byte (non competitiva)

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

L'ultima versione di Jelly ha due nuove funzionalità (sezioni sovrapposte e filtro / intersezione elenco) e una correzione di bug, che consente un conteggio dei byte molto più basso.

Questo codice funziona bene sul mio computer desktop, ma è un po 'lento per il limite di tempo di TIO. Per provarlo online! (per input sufficientemente piccoli), dobbiamo ridurre nuovamente l'intervallo iniziale.

Come funziona

ȷ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 byte

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

esegue una ricerca rapida fino a P _{10 ⁴} .

Assioma, 157 byte

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 risultati

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: possiamo trovare n usando il risultato "a", vedi sotto

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

[usa 1 + sqrt (...) perché n> 0]

Questo sopra significa che se esiste uno n0 tale

p(n0)=a 

di

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

Dopo che dobbiamo dimostrare che p (n0) = a per essere sicuri (perché non è sempre così)

Ma il trucco principale sarebbe fare la somma

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

solo all'inizio e trova la prossima somma di x elementi semplicemente usando

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

e così via per le altre somme (usando sopra nell'istruzione a: = a + p (j + x) -p (j)). Ciò significa che non è necessario un numero x la somma degli elementi all'interno del loop ... ..

Python 2 , 128 124 byte

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

Provalo online!

Javascript 93 byte

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