Giriş

Bir beşgen numarası ( A000326 ) Formül tarafından oluşturulan P _{, n} = 0.5 x (3n ² -n) . Veya kullanılan nokta miktarını sayabilirsiniz:

İlk birkaç beşgen sayıyı bulmak için formülü veya yukarıdaki gif'i kullanabilirsiniz:

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

Daha sonra, art arda x sayısının toplamını hesaplamamız gerekir .

Örneğin, x = 4 ise , P _n + P _{n + 1} + P _{n + 2} + P _{n + 3'e} ( 4 terimden oluşur ) bakmamız gerekir . Beşgen sayıların toplamı da beşgen bir sayı ise, buna bir beşgen numarası beşgen .

İçin , x = 4 , küçük beşgen beşgen sayıdır 330yapılmış olan, 4 ardışık beşgen numaraları: 51, 70, 92, 117. Yani, girdi olduğunda 4, fonksiyon programınızın çıktısı330 .

Görev

• 1'den büyük bir tamsayı verildiğinde, en küçük beşgen beşgen sayısını çıkartın.
• Bir işlev veya program sağlayabilirsiniz.
• Not: Örneğin x = 3 için çözüm yoktur . Bu, bir sayı yapılamazsa , ilk 10000 beşgen sayıdan , hesaplamayı durdurmalı ve sizin için en uygun olanı çıkarmalısınız.
• Bu kod golf , yani en az bayt ile gönderme kazanır!

Test senaryoları:

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

Ayrıca daha büyük sayılar verilebilir:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

CJam, 29 bayt

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

Çevrimiçi deneyin.

Çalışması birkaç saniye alır.

açıklama

İlk olarak, potansiyel toplamlar olarak kaç tane beşgen sayı dikkate almamız gerektiğini kontrol etmeliyiz. İlk 10.000 beşgen sayının toplamı 500050000000. Bundan daha büyük olan ilk beşgen sayı 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.

Boş olmayan bir çözüm sağlayan en büyük girdileri bulmak için biraz değiştirilmiş bir program kullandım. Bunların hepsi 9.000'den büyük girdiler için çözümlerdir:

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

Lua, 142 Bayt

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

Tabloları ters çevirmek için Yay!

142 Bayt Güncelleme: Gereksiz 'ton' fonksiyon çağrısını kaldırarak 10 bayt kaydedildi.

Haskell, 109 bayt

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)

İadeler 0Beşgen beşgen numarası yoksa .

Kullanım örneği (bitmesi biraz zaman alır): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0].

Tanımın az çok doğrudan bir uygulamasıdır: ilk xöğelerin toplamı listede varsa, çıktıyı alın, aksi takdirde listenin kuyruğunu tekrar deneyin. İlk 10.000 beşgen sayıyla başlayın 0, listede xelemanlardan daha az varsa durun ve geri dönün .

PARI / GP, 71 bayt

ispolygonalPARI / GP'deki fonksiyonu seviyorum .

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 bayt

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

Bu beşgen bir sayının tanımını tersine çevirir; P (n) = (3n ^ 2-n) / 2 ise, verilen bir P beşgen sayı iff olacaktır (1 + sqrt (24 * P + 1)) / 6 bir tamsayıdır. (Teknik olarak, (1-sqrt (24 * P + 1)) / 6'ya da bakmalıdır, ancak bu her zaman negatif olmalıdır.) Ayrıca burada önerildiği gibi boşlukları ve sekmeleri iki farklı girinti düzeyi olarak kullanır . Beşgen beşgen sayı bulamazsa, hiçbir şey çıkmaz; Güveniyorum, sorun değil mi?

Ben benden daha akıllı birinin daha da kısaltmak için bir yol bulabiliriz inanıyorum, muhtemelen for döngüsü.

LabVIEW, 39 LabVIEW Temel Öğeleri

Bu sefer çalışan bir gif yok.

Döngüdeki matematik düğümü tüm sayıların bir dizisini oluşturur. Alt dizi alın, eleman ekleyin, bu numarayı arayın, eğer bulunursa indeks al ve döngüyü durdur.

Geçersiz bir giriş en yüksek beşgen sayıyı gösterir.

R, 114100 bayt

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

boyunsuz (tür)

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

Jöle , 30 bayt

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

Bu kod , Jelly'in bu sürümü ile çalışır ve aşağıdaki ikili koda eşdeğerdir:

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

Uzak yavaşlatabilir ve çevrimiçi tercüman için hafıza aç üzere tarafından o pentagonality ilk 150.000.000 (149.995.000 10.000 olur denetler, çünkü olan ^inci beşgen sayı).

Aralığı daha mantıklı bir şeye kısaltarak çevrimiçi deneyebilirsiniz! yeterince küçük girdiler için.

Fikir

Beşgen sayılarla ilgili bilinen bir sonuç, x'in yalnızca sqrt (24x + 1) - 1 6'ya bölünebiliyorsa beşgen olmasıdır .

İlk 10.000 beşgen sayıyı hesaplamak yerine, belirli bir diziden beşgen olmayan sayıları kaldıran bir yardımcı bağlantı tanımlarız. Neden? Jelly'in bu meydan okumadan önceki en son sürümünün listeleri kesişmenin aklı başında bir yolu yok ...

kod

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

Jöle, 21 bayt (rakip olmayan)

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

Jelly'in en son sürümü iki yeni özelliğe (çakışan dilimler ve ve liste filtreleme / kavşak) ve çok daha düşük bayt sayısına izin veren bir hata düzeltmesine sahiptir.

Bu kod masaüstü bilgisayarımda iyi çalışıyor, ancak TIO'nun zaman sınırı için yavaşlamak biraz. İçin çevrimiçi deneyin! (yeterince küçük girdiler için), başlangıç ​​aralığını bir kez daha azaltmamız gerekir.

Nasıl çalışır

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

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

P _{10 ^4'e} kadar hızlı bir arama yapar .

Aksiyom, 157 bayt

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 ve sonuçları

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: "a" sonucunu kullanarak n'yi bulabiliriz, aşağıya bakınız

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

[n> 0 olduğu için 1 + sqrt (...) kullanın]

Bu yukarıdaki bir n0 varsa öyle ki

p(n0)=a 

göre

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

Emin olmak için emin olmak için p (n0) = a'yı kanıtlamamız gerekir (çünkü her zaman böyle değildir)

Ama asıl püf noktası toplamı yapmak

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

sadece başlangıçta ve sonraki x öğesinin toplamını kullanarak

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

ve diğer toplamlar için (a: = a + p (j + x) -p (j) ifadesinde yukarıda belirtilenler kullanılarak). Bu, döngü içinde bir adet x eleman toplamının gerekli olmadığı anlamına gelir ... ..

Python 2 , 128 124 bayt

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

Çevrimiçi deneyin!

Javascript 93 bayt

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