आउटपुट एनटीटी परफेक्ट नंबर भी

Question

चुनौती

पूर्णांक, n को देखते हुए, इनपुट के रूप में 0 <= n <= 2^10, nth को सही संख्या में आउटपुट करता है।

बिल्कुल सही संख्या

एक सही संख्या एक संख्या है, x जहां उसके कारकों का योग (खुद को छोड़कर) x के बराबर है। उदाहरण के लिए, 6:

6: 1, 2, 3, 6

और, ज़ाहिर है 1 + 2 + 3 = 6, इसलिए 6 एकदम सही है।

अगर एक सही संख्या, x , तो भी x mod 2 = 0।

उदाहरण

निम्नलिखित पहले 10 सम संख्याएँ हैं:

6
28
496
8128
33550336
8589869056
137438691328
2305843008139952128
2658455991569831744654692615953842176
191561942608236107294793378084303638130997321548169216

ध्यान दें कि आप इसे अपनी इच्छा के अनुसार अनुक्रमित कर सकते हैं: 6 1 या 0 भी सही संख्या हो सकती है।

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

@LeakyNun मुझे लगता है, यह एक खुला प्रश्न है। यदि यह सवाल nth अजीब सही संख्या आउटपुट था ... इसे हल करने के लिए आपको एक अरब प्रतिनिधि इनाम की आवश्यकता होगी। blogs.ams.org/mathgradblog/2013/07/25/odd-perfect-numbers-exist (10 ^ 300 से नीचे कोई नहीं)

— रोहन झुनझुनवाला

सबसे छोटी विषम संख्या कौन सी है?

— लीक नून

एक सम संख्या n एकदम सही है अगर कोई Mersenne प्राइम पी है जैसे कि n = p (p + 1) / 2 । विषम परिपूर्ण संख्याओं के लिए ऐसा कोई सूत्र नहीं है; इसके अलावा, यह अज्ञात है अगर अजीब सही संख्या भी मौजूद है।

— डेनिस

काफी नहीं। वहाँ केवल 49 ज्ञात Mersenne primes हैं।

— डेनिस

@ बाइटडेके: यह $ 49 डॉलर से अधिक है, इसलिए 60 वें पूर्ण संख्या ज्ञात नहीं है।

— रॉस मिलिकन

Answer 1

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

6Æṣ=$#Ṫ

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

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

6Æṣ=$#Ṫ  Main link. Argument: n

6        Set the return value to 6.
     #   Execute the link to the left with argument k = 6, 7, 8, ... until n
         values of k result in a truthy value. Yield the array of matches.
    $        Combine the two links to the left into a monadic chain.
 Æṣ              Compute the sum of k's proper divisors.
   =             Compare the result with k.
      Ṫ  Tail; extract the last match.

Comments

— डिवाइडर के

Answer 2

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

आश्चर्य की बात नहीं, एक अंतर्निहित है।

PerfectNumber

उदाहरण:

In[1]:= PerfectNumber[18]                                                       

Out[1]= 33570832131986724437010877211080384841138028499879725454996241573482158\

>    45044404288204877880943769038844953577426084988557369475990617384115743842\

>    47301308070476236559422361748505091085378276585906423254824947614731965790\

>    74656099918600764404702181660294469121778737965822199901663478093006075022\

>    35922320184998563614417718592540207818507301504509772708485946474363553778\

>    15002849158802448863064617859829560720600134749556178514816801859885571366\

>    09224841817877083608951191123174885226416130683197710667392351007374503755\

>    40335253147622794359007165170269759424103195552989897121800121464177467313\

>    49444715625609571796578815564191221029354502997518133405151709561679510954\

>    53649485576150660101689160658011770193274226308280507786835049549112576654\

>    51011967045674593989019420525517538448448990932896764698816315598247156499\

>    81962616327512831278795091980742531934095804545624886643834653798850027355\

>    06153988851506645137759275553988219425439764732399824712438125054117523837\

>    43825674443705501944105100648997234160911797840456379499200487305751845574\

>    87014449512383771396204942879824895298272331406370148374088561561995154576\

>    69607964052126908149265601786094447595560440059050091763547114092255371397\

>    42580786755435211254219478481549478427620117084594927467463298521042107553\

>    17849183589266903954636497214522654057134843880439116344854323586388066453\

>    13826206591131266232422007835577345584225720310518698143376736219283021119\

>    28761789614688558486006504887631570108879621959364082631162227332803560330\

>    94756423908044994601567978553610182466961012539222545672409083153854682409\

>    31846166962495983407607141601251889544407008815874744654769507268678051757\

>    74695689121248545626112138666740771113961907153092335582317866270537439303\

>    50490226038824797423347994071302801487692985977437781930503487497407869280\

>    96033906295910199238181338557856978191860647256209708168229116156300978059\

>    19702685572687764976707268496046345276316038409383829227754491185785965832\

>    8888332628525056

Comments

मुझे लगता है कि इसके लिए एक मानक खामियाजा है?

— पाओलो एबरमन

@ Pa @loEbermann सही, 19 डाउनवोट्स के साथ और 94 अपवोट्स के

— टिम

Answer 3

MATL , 15 बाइट्स

`@Z\s@E=vtsG<}n

बहुत धीमी गति से। यह एक-एक करके बढ़ती हुई संख्याओं की कोशिश करता रहता है जब तक कि n -th सही संख्या नहीं मिलती है।

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

व्याख्या

`        % Do...while
  @      %   Push iteration index, k (starting at 1)
  Z\     %   Array of divisors
  s      %   Sum
  @E     %   Push k. Multiply by 2
  =      %   Equal? If so, k is a perfect number
  v      %   Concatenate vertically. This gradually builds an array which at the k-th
         %   iteration contains k zero/one values, where ones indicate perfect numbers
  ts     %   Duplicate. Sum of array
  G<     %   Push input. Less than? This is the loop condition: if true, proceed with
         %   next iteration
}        % Finally (execute right before exiting loop)
  n      %   Number of elements of the array
         % End (implicit). Display (implicit)

Answer 4

पायथ , 13 बाइट्स

e.fqsf!%ZTStZ

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

कृपया किसी भी उच्च संख्या की कोशिश न करें। यह सिर्फ एक-एक करके संख्याओं का परीक्षण करता है।

Comments

@BetaDecay धन्यवाद, अद्यतन।

— लीक नून

Answer 5

05AB1E , 8 बाइट्स

µNNѨOQ½

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

व्याख्या

µ          # loop over increasing N until counter equals input
 N         # push N
  NÑ       # push factors of N
    ¨      # remove last factor (itself)
     O     # sum factors
      Q    # compare the sum to N for equality
       ½   # if true, increase counter

Answer 6

पायथन 2 , 198 153 83 78 77 75 74 बाइट्स

i=input()
j=0
while i:j+=1;i-=sum(x*(j%x<1)for x in range(1,j))==j
print j

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

अब यह बस pededocode की तरह पढ़ता है।

• सहेजा 45 अनगिनत बाइट्स क्योंकि @Leaky नून मुझे योग कार्य और सूची समझ के बारे में पढ़ाया जाता है।

• असमान कोष्ठक को हटाने के लिए @ शौकी के सुझाव के लिए 2 बाइट्स का धन्यवाद।

हम सिर्फ हर सम संख्या के माध्यम से पुनरावृति करते हैं जब तक कि हमें n पूर्ण संख्या नहीं मिल जाती है।

Comments

ध्यान दें कि gवास्तव में आपका बस है sum।

— लीक से हटकर

पायथन पुस्तकालयों को न जानने के लिए @LeakyNun मुझे सही सेवा देता है। मुझे वास्तव में सिर्फ जावा और एसआईओएस से अधिक सीखना चाहिए।

— रोहन झुनझुनवाला

इसके अलावा, मैंने आपका स्थान fएक सूची समझ के साथ बदल दिया है

— लीक नु

अधिक गोल्फ

— लीक

कोई जरूरत नहीं है k, बस क्षयi ।

— लीक नून

Answer 7

PHP, 111 बाइट्स

0-अनुक्रमण

अवधारणा है कि एक आदर्श नंबर एक नंबर है, जहां के साथ काम करता n=x*y x=2^iहै और y=2^(i+1)-1और y प्रधानमंत्री होना चाहिए

for(;!$r[$argn];$u?:$r[]=$z)for($z=2**++$n*($y=2**($n+1)-1),$u=0,$j=1;$j++<sqrt($y);)$y%$j?:$u++;echo$r[$argn];

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

Answer 8

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

f=lambda n,k=1:n and-~f(n-(sum(j>>k%j*j for j in range(1,k))==k),k+1)

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

Answer 9

स्काला, 103 बाइट्स

n=>Stream.from(1).filter(_%2==0).filter(x=>Stream.from(1).take(x-1).filter(x%_==0).sum==x).drop(n).head

Answer 10

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

(!!)(filter(\x->x==sum[n|n<-[1..x-1],x`mod`n==0]||x==1)[1..])

Comments

चूंकि सूचकांक 0 पर शुरू हो सकता है, आपको इसकी आवश्यकता नहीं है ||x==1। आप !!संचालक अनुभाग बनाने के लिए समापन कोष्ठक के ठीक पहले ले जाकर बाइट्स भी बचा सकते हैं , और filterदूसरी सूची के साथ बदलकर ।

— फ़ूबी

Answer 11

जावास्क्रिप्ट (ईएस 6), 68 बाइट्स

n=>eval(`for(x=5;n;s||n--)for(f=s=++x;f--;)(x/f-(x/f|0))||(s-=f);x`)

F=n=>eval('for(x=5;n;s||n--)for(f=s=++x;f--;)(x/f-(x/f|0))||(s-=f);x')

console.log(
  F(1),
  F(2),
  F(3),
  //F(4),
  //F(5),
)

Answer 12

पर्ल 6 , 42 बाइट्स

{(grep {$_==[+] grep $_%%*,^$_},^∞)[$_]}

इनपुट इंडेक्स 1-आधारित है।

Answer 13

क्लोजर, 79 बाइट्स

#(nth(for[i(range):when(=(apply +(for[j(range 1 i):when(=(mod i j)0)]j))i)]i)%)

कल्पना के बाद, :whenस्थिति के लिए भारी उपयोग ।