15
\$\begingroup\$

Challenge

Given an integer, n, as input where 0 <= n <= 2^10, output the nth even perfect number.

Perfect Numbers

A perfect number is a number, x where the sum of its factors (excluding itself) equals x. For example, 6:

6: 1, 2, 3, 6

And, of course, 1 + 2 + 3 = 6, so 6 is perfect.

If a perfect number, x, is even, x mod 2 = 0.

Examples

The following are the first 10 even perfect numbers:

6
28
496
8128
33550336
8589869056
137438691328
2305843008139952128
2658455991569831744654692615953842176
191561942608236107294793378084303638130997321548169216

Note that you may index this however you wish: 6 may be the 1st or the 0th even perfect number.

Winning

Shortest code in bytes wins.

Improve this question
\$\endgroup\$
18
  • 2
    \$\begingroup\$ @LeakyNun I think, that is an open question. If this question was output the nth odd perfect number... You would need a billion rep bounty to get it solved. blogs.ams.org/mathgradblog/2013/07/25/odd-perfect-numbers-exist (none exist below 10^300) \$\endgroup\$
    – Rohan Jhunjhunwala
    Jun 3, 2017 at 16:23
  • 1
    \$\begingroup\$ What is the smallest odd perfect number? \$\endgroup\$
    – Leaky Nun
    Jun 3, 2017 at 16:23
  • 5
    \$\begingroup\$ An even number n is perfect iff there is a Mersenne prime p such that n = p(p+1)/2. There is no such formula for odd perfect numbers; moreover, it is unknown if odd perfect numbers even exist. \$\endgroup\$
    – Dennis
    Jun 3, 2017 at 16:57
  • 2
    \$\begingroup\$ Not quite. There are only 49 known Mersenne primes. \$\endgroup\$
    – Dennis
    Jun 3, 2017 at 17:01
  • 1
    \$\begingroup\$ @BetaDecay: it is greater than $49$, so the 60th perfect number is not known. \$\endgroup\$
    – Ross Millikan
    Jun 4, 2017 at 17:55

15 Answers 15

Reset to default
7
\$\begingroup\$

Jelly, 7 bytes

6Æṣ=$#Ṫ

Try it online!

How it works

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.
Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ So many builtins regarding divisors... \$\endgroup\$
    – Erik the Outgolfer
    Jun 3, 2017 at 18:24
6
\$\begingroup\$

Mathematica, 13 bytes

Not surprisingly, there is a built-in.

PerfectNumber

Example:

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
Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ I think there is a standard loophole for that? \$\endgroup\$
    – Paŭlo Ebermann
    Jun 4, 2017 at 12:42
  • 1
    \$\begingroup\$ @PaŭloEbermann correct, with 19 downvotes and a comment with 94 upvotes approving of it: codegolf.meta.stackexchange.com/a/1078/32933 \$\endgroup\$
    – Tim
    Jun 4, 2017 at 18:39
4
\$\begingroup\$

MATL, 15 bytes

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

Very slow. It keeps trying increasing numbers one by one until the n-th perfect number is found.

Try it online!

Explanation

`        % 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)
Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Pyth, 13 bytes

e.fqsf!%ZTStZ

Try it online!

Please do not try any higher number. It just tests the even numbers one by one.

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

05AB1E, 8 bytes

µNNѨOQ½

Try it online!

Explanation

µ          # 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
Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Python 2, 198 153 83 78 77 75 74 bytes

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

Try it online!

Now it just reads like psuedocode.

  • Saved 45 Countless Bytes because @Leaky Nun taught me about the sum function and list comprehension.

  • Saved 2 bytes thanks to @shooqie's suggestion to remove the uncessary brackets.

We just iterate through every even number until we have found n perfect numbers.

Improve this answer
\$\endgroup\$
13
2
\$\begingroup\$

PHP, 111 Bytes

0-Indexing

Works with the concept that a perfect number is a number where n=x*y x=2^i and y=2^(i+1)-1 and y must be prime

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

Try it online!

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Python 3, 69 bytes

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

Try it online!

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Scala, 103 bytes

n=>Stream.from(1).filter(_%2==0).filter(x=>Stream.from(1).take(x-1).filter(x%_==0).sum==x).drop(n).head
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Haskell, 61 Bytes

(!!)(filter(\x->x==sum[n|n<-[1..x-1],x`mod`n==0]||x==1)[1..])
Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Since the index can start at 0, you don't need the ||x==1. You can also save bytes by moving the !! just before the closing parenthesis to make an operator section, and by replacing the filter with another list comprehension. \$\endgroup\$
    – faubi
    Jun 4, 2017 at 8:50
1
\$\begingroup\$

Haskell, 52 bytes

([n|n<-[1..],n==sum[d|d<-[1..div n 2],mod n d<1]]!!)

Try it online!

Starts at n = 0. Not particularly fast

Improve this answer
\$\endgroup\$
1
  • 1
    \$\begingroup\$ By our consensus, it's valid to omit the f= from the byte count. \$\endgroup\$
    – naffetS
    Aug 10, 2022 at 17:19
0
\$\begingroup\$

JavaScript (ES6), 68 bytes

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

Improve this answer
\$\endgroup\$
0
\$\begingroup\$

Perl 6, 42 bytes

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

The input index is 1-based.

Improve this answer
\$\endgroup\$
0
\$\begingroup\$

Clojure, 79 bytes

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

Following the spec, heavy usage of for's :when condition.

Improve this answer
\$\endgroup\$
0
\$\begingroup\$

PowerShell, 152 bytes

$ErrorActionPreference='SilentlyContinue'
function p{param($x)(1..($x-1)|?{!($x%$_)})|%{$s+=$_};$s}
1..$args[0]|%{if(((p -x $_)-eq$_)-and(!($_%2))){$_}}

Try it online!

Improve this answer
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.