व्यावहारिक संख्याओं की गणना करें

Question

परिभाषा

एक सकारात्मक पूर्णांक nएक व्यावहारिक संख्या है (OEIS अनुक्रम A005153 ) यदि सभी छोटे सकारात्मक पूर्णांकों को अलग-अलग विभाजकों के योग के रूप में दर्शाया जा सकता है n।

उदाहरण के लिए, 18एक व्यावहारिक संख्या है: इसके भाजक 1, 2, 3, 6, 9 और 18 हैं, और 18 से छोटे अन्य सकारात्मक पूर्णांक निम्नानुसार बनाए जा सकते हैं:

 4 = 1 + 3          5 = 2 + 3           7 = 1 + 6
 8 = 2 + 6          10 = 1 + 9         11 = 2 + 9
12 = 3 + 9 = 1 + 2 + 9 = 1 + 2 + 3 + 6
13 = 1 + 3 + 9      14 = 2 + 3 + 9      15 = 6 + 9
16 = 1 + 6 + 9      17 = 2 + 6 + 9

लेकिन 14एक व्यावहारिक संख्या नहीं है: इसके भाजक 1, 2, 7 और 14 हैं, और इनमें से कोई भी उपसमुच्चय नहीं है जो 4, 5, 6, 11, 12, या 13 में जोड़ता है।

चुनौती

एक प्रोग्राम, फ़ंक्शन, या क्रिया लिखें जो इनपुट को धनात्मक पूर्णांक के रूप में लेता है xऔर OEIS के साथ संगति के लिए 1 से अनुक्रमित x ^वें व्यावहारिक संख्या को रिटर्न या प्रिंट करता है । आपका कोड पर्याप्त रूप से कुशल होना चाहिए कि यह एक उचित डेस्कटॉप कंप्यूटर पर दो मिनट से कम समय में 250000 तक इनपुट को संभाल सके। (जावा में एनबी मेरा संदर्भ कार्यान्वयन 0.5 सेकंड से कम समय में 250000 का प्रबंधन करता है, और पायथन में मेरा संदर्भ कार्यान्वयन इसे 12 सेकंड में प्रबंधित करता है)।

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

Input        Expected output
1            1
8            18
1000         6500
250000       2764000
1000000      12214770
3000000      39258256

Comments

(IMHO) यह और भी दिलचस्प हो सकता है अगर सबसे तेज़ कोड (प्रति भाषा?) जीतता है

— प्रदर्शन नाम

@ सर्ज बोर्ड तो आपको जवाब में सभी 250K प्रविष्टियों की तालिकाएँ दिखाई देंगी

— डॉ। बिसरिज़री

@ काबिलेतारीफ अच्छी बात। लेकिन मुझे लगता है कि इस तरह की धोखाधड़ी को आसानी से प्रतिबंधित किया जा सकता है। या समस्या को किसी भी संख्या के लिए सही उत्तर की आवश्यकता हो सकती है , लेकिन तब मानक पुस्तकालय में कोई बड़े पूर्णांक के साथ भाषा में ऐसा करते समय कठिनाइयाँ होंगी ...: / /

— प्रदर्शन का नाम

मेरे मन में एक एल्गोरिथम अनुकूलन है, लेकिन वर्तमान नियमों के साथ मैं इसे लागू करने के लिए बहुत आलसी हूं: पी

— प्रदर्शन नाम

यदि आप अपने कोड को gist.github.com पर अपलोड करना चाहते हैं या यहाँ या चैट में एक लिंक को छोड़ना चाहते हैं, तो @SargeBorsch, बेझिझक। FWIW मैं दो कारणों से सबसे तेज़ कोड के लिए उदार प्रदर्शन बाधाओं के साथ कोड गोल्फ पसंद करता हूं: सबसे पहले, कोड की लंबाई अधिक उद्देश्यपूर्ण औसत दर्जे का है; दूसरे, यह ट्रेडऑफ़ के एक तत्व का परिचय देता है: प्रदर्शन को बर्बाद किए बिना कोड को छोटा करने के लिए किस गति अनुकूलन को छोड़ा जा सकता है?

— पीटर टेलर

Answer 1

जे (99 वर्ण)

f=:3 :0
'n c'=.0 1
while.c<y do.
'p e'=.__ q:n=.n+2
c=.c+*/(}.p)<:}:1+*/\(<:p^e+1)%<:p
end.
n+n=0
)

चूंकि समस्या कथन "कार्यक्रम, फ़ंक्शन या क्रिया " के लिए पूछता है , इसलिए किसी को एक जे प्रस्तुत करना था। जे लोग ध्यान देंगे कि मैं वास्तव में गोल्फ (!) नहीं था या इसे अनुकूलित करता था। अन्य प्रविष्टियों की तरह, मैंने स्टीवर्ट प्रमेय का उपयोग किया, जिसका उल्लेख OEIS लिंक पर किया गया था, यह परीक्षण करने के लिए कि प्रत्येक सम संख्या व्यावहारिक है या नहीं।

मेरे पास J के साथ एक "उचित डेस्कटॉप कंप्यूटर" के लिए तैयार नहीं है। मेरे छह साल पुराने नेटबुक की f 250000गणना 120.6 सेकंड में की जाती है, जो दो मिनट से कम नहीं है, लेकिन संभवत: किसी भी थोड़े अधिक उचित कंप्यूटर पर यह समय के साथ समाप्त हो जाता है।

Answer 2

गणितज्ञ, १२६ १२१ वर्ण

विश्वास करने के लिए धन्यवाद।

विकिपीडिया पर सूत्र का उपयोग करना।

f=(i=j=1;While[j<#,If[And@@Thread[#[[;;,1]]<2+Most@DivisorSum[FoldList[#Power@@#2&,1,#],#&]&@FactorInteger@++i],j++]];i)&

उदाहरण:

f[1]

1

f[8]

18

f[250000]

2764000

f[250000]मेरे कंप्यूटर पर गणना करने में 70 का दशक लगा ।

Comments

मुझे लगता है कि आप विषम पूर्णांक को दरकिनार करके एक चार की कीमत पर बेहतर प्रदर्शन प्राप्त कर सकते हैं

— डॉ। बेलिसरियस

OEIS सबमिशन से कोड को कम करने में, आपने निष्पादन 10-गुना धीमा कर दिया। बस सोच रहा था, "आपको क्यों लगता है कि आपका कोड OEIS उदाहरण की तुलना में इतना धीमा है?"

— डेविड सी

@belisarius आपका सुझाव आधे समय में कटौती करता है, जैसा कि अपेक्षित था।

— डेविड

119 वर्णों में वही: (i=j=1;While[j<#,If[And@@Thread[#[[;;,1]]<2+Most@DivisorSum[FoldList[#Power@@#2&,1,#],#&]&@FactorInteger@++i],j++]];i)&

— डॉ। बेलिसरियस

Answer 3

हास्केल - 329

s 1=[]
s n=p:(s$div n p)where d=dropWhile((/=0).mod n)[2..ceiling$sqrt$fromIntegral n];p=if null d then n else head d
u=foldr(\v l@((n,c):q)->if v==n then(n,c+1):q else(v,1):l)[(0,1)]
i z=(z<2)||(head w==2)&&(and$zipWith(\(n,_)p->n-1<=p)(tail n)$scanl1(*)$map(\(n,c)->(n*n^c-1)`div`(n-1))n)where w=s z;n=u w
f=((filter i[0..])!!)

उदाहरण:

> f 1
1
> f 13
32
> f 1000
6500

यहाँ एक छोटा परीक्षण सूट है (उपर्युक्त के लिए प्रस्तुत करें):

import Data.Time.Clock
import System.IO

test x = do
    start <- getCurrentTime
    putStr $ (show x) ++ " -> " ++ (show $ f x)
    finish <- getCurrentTime
    putStrLn $ " [" ++ (show $ diffUTCTime finish start) ++ "]"

main = do
    hSetBuffering stdout NoBuffering
    mapM_ test [1, 8, 1000, 250000, 1000000, 3000000]

के साथ संकलित होने के बाद परीक्षण के परिणाम ghc -O3 :

1 -> 1 [0.000071s]
8 -> 18 [0.000047s]
1000 -> 6500 [0.010045s]
250000 -> 2764000 [29.084049s]
1000000 -> 12214770 [201.374324s]
3000000 -> 39258256 [986.885397s]

Comments

जब मैं इस कोशिश ghci में यह शिकायत करता है parse error on input `='। क्या मुझे कुछ ध्वज या अन्य का उपयोग करने की आवश्यकता है?

— पीटर टेलर

@PeterTaylor आप फ़ंक्शन परिभाषाओं को उस तरह से ghci में पेस्ट नहीं कर सकते। सबसे सरल आप इसे करने के लिए इसे बचा सकते हैं asdf.hsऔर चला सकते हैं ghci asdf.hs, फिर वहां से आप एक्सेस कर पाएंगेf

— mniip

@PeterTaylor ghc --make -O3 [filename]। आप इसे ghci में भी लोड कर सकते हैं, :l [filename]लेकिन संकलित समय की कमी को देखते हुए शायद सबसे अच्छा है। :)

— जोनाथन वान मैट्रे

@JonathanVanMatre जैसा कि उपरोक्त टिप्पणी में देखा गया है, ghciअपने तर्कों में निर्दिष्ट फाइलों को लोड करता है

— mniip

आह अच्छा। इस बीच में मैं अपने परीक्षण ढांचे और के साथ चल रहा यह मिल गया है ghc। आपका कंप्यूटर मेरे से तेज़ है, लेकिन 98 सेकंड में यह अभी भी मेरे कंप्यूटर पर प्रदर्शन मानदंड के अंदर है।

— पीटर टेलर

Answer 4

जावास्क्रिप्ट, 306 307 282 बी

function y(r){for(n=r-1,k=1;n;k++)if(p=[],e=[],c=0,P=s=1,!((x=k)%2|1==x)){while(x>1){for(f=x,j=2;j<=Math.sqrt(f);j++)if(f%j==0){f=j;break}f!=p[c-1]?(p.push(f),e.push(2),c++):e[c-1]++,x/=f}for(i=0;c>i;i++){if(p[i]>P+1){s=0;break}P*=(Math.pow(p[i],e[i])-1)/(p[i]-1)}s&&n--}return k-1}

लगभग 250 कि। मेरे लैपटॉप पर 6s।

गैर-गोल्फ कोड टिप्पणी: http://jsfiddle.net/82xb9/3/ अब बेहतर सिग्मा-परीक्षण और एक बेहतर अगर हालत (धन्यवाद टिप्पणियाँ) के साथ

पूर्व-संपादित संस्करण: http://jsfiddle.net/82xb9/ http://jsfiddle.net/82xb9/1/

Comments

प्रश्न किसी फ़ंक्शन या प्रोग्राम के लिए पूछता है (जेएस में क्रियाएं नहीं हैं), इसलिए पहली पंक्ति की गणना नहीं करने के बजाय आपको एक फ़ंक्शन घोषणा में दूसरी पंक्ति लपेटनी चाहिए और अंतिम k--;को प्रतिस्थापित करना चाहिए return k-1। हालाँकि इससे आपकी बाइट की गिनती थोड़ी बढ़ जाती है, लेकिन आप कुछ चीज़ों से बचा सकते हैं जैसे p[i]>=P+2कि p[i]>P+1(और शायद आंतरिक फ़ंक्शन कॉल को हटाकर और breakइसके बजाय इसका उपयोग करके )।

— पीटर टेलर

मुझे लगता है कि "परीक्षण सिग्मा" भाग को आकार और गति दोनों के लिए फिर से लिखा जा सकता है: jsfiddle.net/3DTSa । हालांकि यह जेएस समाधान बहुत तेज है क्योंकि यह है।

— user2846289