Sortie du nième nombre parfait pair

16

Défi

Étant donné un entier, n, en tant qu'entrée où 0 <= n <= 2^10, affiche le nième nombre pair parfait.

Des nombres parfaits

Un nombre parfait est un nombre, x où la somme de ses facteurs (à l'exclusion de lui-même) est égale à x. Par exemple, 6:

6: 1, 2, 3, 6

Et, bien sûr 1 + 2 + 3 = 6, donc 6 est parfait.

Si un nombre parfait x, est pair,x mod 2 = 0 .

Exemples

Voici les 10 premiers nombres même parfaits:

6
28
496
8128
33550336
8589869056
137438691328
2305843008139952128
2658455991569831744654692615953842176
191561942608236107294793378084303638130997321548169216

Notez que vous pouvez l'indexer comme vous le souhaitez: 6 peut être le 1er ou le 0ème nombre parfait même.

Gagnant

Le code le plus court en octets gagne.

Beta Decay
la source
2
@LeakyNun Je pense que c'est une question ouverte. Si cette question était sortie, le nième nombre parfait impair ... Vous auriez besoin d'une prime d'un milliard de répétitions pour le résoudre. blogs.ams.org/mathgradblog/2013/07/25/odd-perfect-numbers-exist (aucun n'existe en dessous de 10 ^ 300)
Rohan Jhunjhunwala
1
Quel est le plus petit nombre parfait impair?
Leaky Nun
5
Un nombre pair n est parfait s'il existe un nombre premier de Mersenne p tel que n = p (p + 1) / 2 . Il n'existe pas une telle formule pour les nombres impairs parfaits; de plus, on ignore s'il existe même des nombres impairs parfaits.
Dennis
2
Pas assez. Il n'y a que 49 nombres premiers de Mersenne connus.
Dennis
1
@BetaDecay: il est supérieur à 49 $, donc le 60e nombre parfait n'est pas connu.
Ross Millikan

Réponses:

7

Gelée , 7 octets

6Æṣ=$#Ṫ

Essayez-le en ligne!

Comment ça fonctionne

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.
Dennis
la source
Autant de fonctionnalités concernant les diviseurs ...
Erik the Outgolfer
6

Mathematica, 13 octets

Sans surprise, il y a un intégré.

PerfectNumber

Exemple:

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
alephalpha
la source
Je pense qu'il y a une faille standard pour cela?
Paŭlo Ebermann
1
@ PaŭloEbermann correct, avec 19 votes descendants et un commentaire avec 94 votes positifs l'approuvant: codegolf.meta.stackexchange.com/a/1078/32933
Tim
4

MATL , 15 octets

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

Très lent. Il continue d'essayer d'augmenter les nombres un par un jusqu'à ce que le n- ème nombre parfait soit trouvé.

Essayez-le en ligne!

Explication

`        % 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)
Luis Mendo
la source
3

Pyth , 13 octets

e.fqsf!%ZTStZ

Essayez-le en ligne!

Veuillez ne pas essayer de numéro plus élevé. Il teste juste les nombres pairs un par un.

Leaky Nun
la source
Merci @BetaDecay, mis à jour.
Leaky Nun
2

05AB1E , 8 octets

µNNѨOQ½

Essayez-le en ligne!

Explication

µ          # 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
Emigna
la source
2

Python 2 , 198153 83 78 77 75 74 octets

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

Essayez-le en ligne!

Maintenant, il se lit comme un pseudo-code.

  • Enregistré 45 innombrables octets parce que @Leaky Nun m'a appris la fonction de somme et la compréhension de la liste.

  • Enregistrement de 2 octets grâce à la suggestion de @ shooqie de supprimer les crochets inutiles.

Nous parcourons simplement chaque nombre pair jusqu'à ce que nous ayons trouvé n nombres parfaits.

Rohan Jhunjhunwala
la source
remarquez que votre gest en fait juste sum.
Leaky Nun
@LeakyNun me sert bien, car je ne connais pas les bibliothèques python. Je devrais vraiment apprendre plus que juste java et SILOS.
Rohan Jhunjhunwala
plus de golfs
Leaky Nun
2

PHP, 111 octets

0-Indexation

Fonctionne avec le concept qu'un nombre parfait est un nombre où n=x*y x=2^iet y=2^(i+1)-1et y doivent être premiers

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

Essayez-le en ligne!

Jörg Hülsermann
la source
1

Scala, 103 octets

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

Haskell, 61 octets

(!!)(filter(\x->x==sum[n|n<-[1..x-1],x`mod`n==0]||x==1)[1..])
Enderperson1010
la source
Comme l'index peut commencer à 0, vous n'avez pas besoin de ||x==1. Vous pouvez également enregistrer des octets en déplaçant le !!juste avant la parenthèse fermante pour créer une section opérateur et en remplaçant le filterpar une autre liste de compréhension.
faubi
0

JavaScript (ES6), 68 octets

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

darrylyeo
la source
0

Perl 6 , 42 octets

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

L'index d'entrée est basé sur 1.

Sean
la source
0

Clojure, 79 octets

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

Suite à la spécification, utilisation intensive de l' :whenétat de for .

NikoNyrh
la source