pengantar

Angka pentagonal ( A000326 ) dihasilkan oleh rumus P _n = 0,5 × (3n ² -n) . Atau Anda bisa menghitung jumlah titik yang digunakan:

Anda dapat menggunakan rumus, atau gif di atas untuk menemukan beberapa angka pentagonal pertama:

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

Selanjutnya, kita perlu menghitung jumlah x angka berurutan.

Sebagai contoh, jika x = 4 , kita perlu melihat P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (yang terdiri dari 4 istilah). Jika jumlah bilangan pentagonal juga merupakan bilangan pentagonal, kita akan menyebut ini a bilangan pentagon pentagonal .

Untuk x = 4 , terkecil jumlah pentagon pentagonal adalah 330, yang terbuat dari 4 nomor pentagonal berturut-turut: 51, 70, 92, 117. Jadi, kapan inputnya4 , program fungsi Anda harus keluar 330.

Tugas

• Ketika diberi bilangan bulat lebih besar dari 1, hasilkan angka pentagon pentagonal terkecil.
• Anda dapat menyediakan fungsi atau program.
• Catatan: Tidak ada solusi untuk mis x = 3 . Ini artinya kalau angka tidak dapat dibuat dari angka 10.000 pentagonal pertama, Anda harus berhenti menghitung dan menghasilkan apa pun yang paling cocok untuk Anda.
• Ini adalah kode-golf , jadi pengiriman dengan jumlah byte paling sedikit menang!

Kasus uji:

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

Juga angka yang lebih besar dapat diberikan:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 byte

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

Cobalah online.

Butuh beberapa detik untuk berlari.

Penjelasan

Pertama, kita perlu memeriksa berapa bilangan pentagonal yang perlu kita pertimbangkan sebagai jumlah potensial. Jumlah dari 10.000 angka pentagonal pertama adalah 500050000000. Angka pentagonal pertama yang lebih besar dari itu adalah 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.

Saya menggunakan program yang sedikit dimodifikasi untuk menemukan input terbesar yang menghasilkan solusi tidak kosong. Ini semua adalah solusi untuk input yang lebih besar dari 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

Tidak disatukan

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 untuk membalik tabel!

Perbarui 142 Bytes: Disimpan 10 bytes dengan menghapus panggilan fungsi 'tonumber' yang berlebihan.

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)

Kembali 0jika tidak ada nomor pentagon pentagonal.

Contoh penggunaan (membutuhkan waktu untuk menyelesaikan): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0].

Ini lebih atau kurang merupakan implementasi langsung dari definisi: jika jumlah xelemen pertama ada dalam daftar, keluarkan, atau coba lagi dengan ekor daftar. Mulailah dengan 10.000 angka pentagonal pertama, berhenti dan kembali 0jika daftar memiliki kurang dari xelemen.

PARI / GP, 71 byte

Saya suka ispolygonalfungsi di 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

Ini membalikkan definisi bilangan pentagonal; jika P (n) = (3n ^ 2-n) / 2, maka P yang diberikan akan menjadi bilangan segi lima iff (1 + sqrt (24 * P + 1)) / 6 adalah bilangan bulat. (Secara teknis, ini juga harus melihat (1-sqrt (24 * P + 1)) / 6, tetapi itu harus selalu negatif.) Juga menggunakan spasi dan tab sebagai dua tingkat indentasi yang berbeda, seperti yang disarankan di sini . Ini tidak menghasilkan apa-apa jika tidak dapat menemukan angka pentagonal pentagonal; Saya percaya tidak apa-apa?

Saya sangat percaya bahwa seseorang yang lebih pintar daripada saya dapat menemukan cara untuk mempersingkat ini lebih, mungkin di sekitar for the loop.

LabVIEW, 39 Primview LabVIEW

Tidak ada gif dari itu yang berjalan saat ini.

Node matematika dalam loop menciptakan array dari semua angka. Ambil Sub-array, tambahkan elemen, cari nomor itu, jika ditemukan ambil indeks dan hentikan loop.

Input yang tidak valid mengeluarkan angka pentagonal tertinggi.

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

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

Jelly , 30 byte

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

Kode ini berfungsi dengan versi Jelly ini dan setara dengan kode biner berikut:

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

Ini jauh melambat dan haus akan memori untuk penerjemah online, karena ia memeriksa 150.000.000 pertama untuk segi lima (149.995.000 kebetulan 10.000 ^th jumlah pentagonal).

Dengan mempersingkat rentang ke sesuatu yang lebih masuk akal, Anda bisa mencobanya secara online! untuk input yang cukup kecil.

Ide

Hasil yang diketahui tentang bilangan pentagonal adalah bahwa x adalah pentagonal jika dan hanya jika sqrt (24x + 1) - 1 dapat dibagi dengan 6 .

Daripada menghitung 10.000 angka pentagonal pertama, kami mendefinisikan tautan pembantu yang menghilangkan angka-angka non-pentagonal dari array yang diberikan. Mengapa? Karena versi terbaru Jelly yang ada sebelum tantangan ini tidak memiliki cara yang waras untuk memotong daftar ...

Kode

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

Jelly, 21 byte (tidak bersaing)

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

Versi terbaru Jelly memiliki dua fitur baru (irisan yang tumpang tindih dan dan penyaringan daftar / persimpangan) dan perbaikan bug, yang memungkinkan jumlah byte jauh lebih rendah.

Kode ini berfungsi dengan baik di komputer desktop saya, tetapi agak lambat untuk batas waktu TIO. Untuk Mencoba secara online! (untuk input yang cukup kecil), kami harus mengurangi rentang awal sekali lagi.

Bagaimana itu bekerja

ȷ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]]&

melakukan pencarian cepat hingga P _{10 ⁴} .

Aksioma, 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 dan hasilnya

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: Kita dapat menemukan dan menggunakan hasil "a", lihat di bawah

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

[gunakan 1 + sqrt (...) karena n> 0]

Ini di atas berarti bahwa jika ada satu n0 sedemikian rupa

p(n0)=a 

dari

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

Setelah itu kita harus membuktikan bahwa p (n0) = a untuk memastikan (karena tidak selalu demikian)

Tapi trik utamanya adalah melakukan penjumlahan

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

hanya di awal, dan temukan jumlah elemen x berikutnya hanya menggunakan

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

dan seterusnya untuk jumlah lainnya (menggunakan di atas dalam pernyataan a: = a + p (j + x) -p (j)). Ini berarti tidak perlu jumlah satu elemen x jumlah di dalam 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

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