पेंटागनल संख्याएँ पंचकोणीय संख्याओं से बनी होती हैं

Question

परिचय

एक पंचकोणीय संख्या ( A000326 ) सूत्र P _n = 0.5 × (3n ² -n) से उत्पन्न होती है । या आप केवल उपयोग किए गए डॉट्स की मात्रा की गणना कर सकते हैं:

आप पहले कुछ पंचकोणीय संख्याओं को खोजने के लिए सूत्र या ऊपर दिए गए gif का उपयोग कर सकते हैं:

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

अगला, हमें x के योग की गणना करने की आवश्यकता है लगातार संख्याओं ।

उदाहरण के लिए, यदि x = 4 , हमें P _n + P _{n + 1} + P _{n + 2} + P _{n + 3} (जिसमें 4 पद होते हैं ) को देखने की आवश्यकता है। यदि पंचकोणीय संख्याओं का योग भी एक पंचकोणीय संख्या है, तो हम इसे a कहेंगे पंचकोणीय पंचकोणीय संख्या ।

के लिए एक्स = 4 , छोटी से छोटी पंचकोणीय पंचकोण संख्या है 330जो से बना है, 4 लगातार पंचकोणीय संख्या: 51, 70, 92, 117। इसलिए, जब इनपुट होता है 4, तो आपके कार्य का कार्यक्रम आउटपुट होना चाहिए 330।

---

कार्य

• जब 1 से अधिक पूर्णांक दिया जाता है, तो सबसे छोटा पंचकोणीय पंचकोणीय संख्या का उत्पादन होता है।
• आप एक समारोह या एक कार्यक्रम प्रदान कर सकते हैं।
• नोट: उदाहरण के लिए कोई समाधान नहीं हैं x = 3 । इसका मतलब है कि यदि कोई संख्या नहीं बनाई जा सकती है पहले 10000 पंचकोणीय संख्याओं से , तो आपको कंप्यूटिंग और आउटपुट को रोकना होगा जो आपके लिए सबसे उपयुक्त है।
• यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ सबमिशन!

---

परीक्षण के मामलों:

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

साथ ही बड़ी संख्या दी जा सकती है:

Input: 37
Output: 32782

Input: 55
Output: 71349465

Input: 71
Output: 24565290

Comments

IMO यह पागल है कि कोई भी व्यक्ति जो एक विश्लेषणात्मक समाधान के साथ आता है, जो कठिन मामलों को हल कर सकता है या नहीं, यह जांचने के लिए कि क्या समाधान उससे कम है10001-x

— पीटर टेलर

@PeterTaylor कठिन मामलों से आपका मतलब है x = 3, जिनका कोई हल नहीं है?

— अदनान

परिणाम का सबसे बड़ा परीक्षण मामला है: 9919->496458299155

— मार्टिन एंडर

नहीं, मेरा मतलब उन मामलों से है जिनके समाधान हैं लेकिन जो राशि में बड़े पंचकोणीय संख्याओं का उपयोग करते हैं।

— पीटर टेलर

मुझे 10,000 सीमा के बारे में निश्चित नहीं है: क्या जो संख्याएँ योग का निर्माण करती हैं, उन्हें पहले 10,000 पंचकोणीय संख्याओं से आना है, लेकिन स्वयं योग नहीं है, या योग भी पहले 10,000 के भीतर है?

— नीमी

Answer 1

सीजेएम, 29 बाइट्स

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

इसे ऑनलाइन आज़माएं।

चलाने के लिए सेकंड के एक जोड़े लेता है।

व्याख्या

सबसे पहले, हमें यह जांचने की आवश्यकता है कि संभावित पंचों के रूप में हमें कितने पंचकोणीय संख्याओं पर विचार करने की आवश्यकता है। पहले 10,000 पंचकोणीय संख्याओं का योग है 500050000000। उससे अधिक पहले पंचकोणीय संख्या 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.

मैंने सबसे बड़े इनपुट का पता लगाने के लिए थोड़ा संशोधित कार्यक्रम का उपयोग किया, जो एक गैर-खाली समाधान देता है। ये 9,000 से अधिक इनपुट के लिए सभी समाधान हैं:

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

Answer 2

लुआ, 142 बाइट्स

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

Inverting तालिकाओं के लिए याय!

142 बाइट्स को अपडेट करें: सुपरफ़्लस 'टनम्बर' फंक्शन कॉल को हटाकर 10 बाइट्स बचाए।

Answer 3

हास्केल, 109 बाइट्स

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)

रिटर्न 0यदि कोई पंचकोणीय पंचकोणीय संख्या नहीं है, तो ।

उपयोग उदाहरण (समाप्त होने में कुछ समय लगता है): map (#take(10^4)p) [1..10]-> [1,1926,0,330,44290,651,287,0,12105,0]।

यह परिभाषा का अधिक या कम सीधा कार्यान्वयन है: यदि पहले xतत्वों का योग सूची में है, तो इसे आउटपुट करें, अन्यथा सूची की पूंछ के साथ फिर से प्रयास करें। पहले 10,000 पंचकोणीय संख्याओं के साथ शुरू करें, रोकें और 0सूची में xतत्वों से कम होने पर वापस लौटें ।

Answer 4

PARI / GP, 71 बाइट्स

मुझे ispolygonalPARI / GP में फ़ंक्शन पसंद है ।

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

Answer 5

पायथन 3, 144 बाइट्स

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

यह एक पंचकोणीय संख्या की परिभाषा को उलट देता है; यदि P (n) = (3n ^ 2-n) / 2, तो एक दिया P एक पंचकोणीय संख्या iff (1 + sqrt (24 * P + 1)) / 6 एक पूर्णांक है। (तकनीकी रूप से, इसे (1-sqrt (24 * P + 1)) / 6 पर भी देखना चाहिए, लेकिन यह हमेशा नकारात्मक होता है।) दो अलग-अलग इंडेंटेशन स्तरों के रूप में रिक्त स्थान और टैब का भी उपयोग करता है, जैसा कि यहां बताया गया है । यह कुछ भी आउटपुट नहीं करता है अगर यह एक पेंटागोनल पेंटागोनल नंबर नहीं पा सकता है; मुझे भरोसा है कि यह ठीक है?

मैं दृढ़ता से मानता हूं कि मैं जितना चालाक हूं, उससे कहीं अधिक चतुर इसे और भी छोटा करने का एक तरीका मिल सकता है, शायद लूप के लिए।

Answer 6

LabVIEW, 39 LabVIEW आदिम

इस समय इसका कोई जिफ नहीं चल रहा है।

लूप में गणित नोड सभी संख्याओं की एक सरणी बनाता है। सब-ऐरे को लें, एलिमेंट्स जोड़ें, उस नंबर को खोजें, अगर इंडेक्स और स्टॉप लूप मिले।

एक अमान्य इनपुट उच्चतम पंचकोणीय संख्या डालता है।

Answer 7

आर, 114 100 बाइट्स

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

अनगढ़ (थोड़े)

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

Answer 8

जेली , 30 बाइट्स

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

इस कोड के साथ काम करता है जेली के इस संस्करण के और निम्नलिखित बाइनरी कोड के बराबर है:

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

यह ऑनलाइन दुभाषिया के लिए भूख को धीमा करने और स्मृति से दूर है, क्योंकि यह पेंटागनिटी के लिए पहले 150,000 की जांच करता है (149,995,000 10,000 ^वें पंचकोणीय संख्या में होता है)।

सीमा को कुछ और समझदार बनाने के लिए, आप कर सकते हैं इसे ऑनलाइन आज़मा ! छोटे पर्याप्त इनपुट के लिए।

विचार

पंचकोणीय संख्याओं के बारे में एक ज्ञात परिणाम यह है कि x पंचकोणीय है अगर और केवल अगर sqrt (24x + 1) - 1 विभाज्य है 6 ।

पहले 10,000 पंचकोणीय संख्याओं की गणना करने के बजाय, हम एक सहायक लिंक को परिभाषित करते हैं जो किसी दिए गए सरणी से गैर-पंचकोणीय संख्याओं को हटा देता है। क्यों? क्योंकि इस चुनौती से पहले वाले जेली के नवीनतम संस्करण में सूचियों को अंतर करने का कोई समझदार तरीका नहीं है ...

कोड

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

---

जेली, 21 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

जेली के नवीनतम संस्करण में दो नई विशेषताएं (ओवरलैपिंग स्लाइस और सूची फ़िल्टरिंग / चौराहे) और एक बग फिक्स है, जो बहुत कम बाइट गिनती की अनुमति देता है।

यह कोड मेरे डेस्कटॉप कंप्यूटर पर ठीक काम करता है, लेकिन यह TIO की समय सीमा को धीमा करने के लिए एक बालक है। इसे ऑनलाइन करने का प्रयास करें!(पर्याप्त रूप से छोटे इनपुट के लिए), हमें प्रारंभिक सीमा को एक बार फिर से कम करना होगा।

यह काम किस प्रकार करता है

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

Answer 9

गणितज्ञ 85 बाइट्स

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

पी _{10 ⁴} तक एक त्वरित खोज को पूर्ण करता है ।

Answer 10

Axiom, 157 बाइट्स

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)

अपुष्ट और परिणाम

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

उत्थान: हम परिणाम "a" का उपयोग करके n पा सकते हैं, नीचे देखें

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

[उपयोग 1 + sqrt (...) क्योंकि n> 0]

यह ऊपर का मतलब है कि अगर एक n0 ऐसा मौजूद है

p(n0)=a 

से

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

अफेर कि हमें यह साबित करना है कि p (n0) = a a to be sure (क्योंकि यह हमेशा ऐसा नहीं है)

लेकिन मुख्य चाल योग कर रही होगी

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

केवल शुरुआत में, और अगले x तत्वों को योग का उपयोग करके खोजें

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

और इसी तरह अन्य राशि के लिए (बयान में ऊपर का उपयोग: a = = a + p (j + x) -p (j))। इसका मतलब यह आवश्यक नहीं है कि लूप के अंदर एक नंबर x तत्व योग हो… ..

Answer 11

पायथन 2 , 128 124 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 12

जावास्क्रिप्ट 93 बाइट्स

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