Contexte:

Le défi actuel de Perfect Numbers est plutôt imparfait et compliqué, car il vous demande de produire dans un format complexe impliquant les facteurs du nombre. Il s'agit d'un repostage purement décisionnel du défi.

Défi

Étant donné un entier positif à travers n'importe quel format d'entrée standard , faites la distinction entre s'il est parfait ou non.

Un nombre parfait est un nombre égal à la somme de tous ses diviseurs stricts (ses diviseurs positifs inférieurs à lui-même). Par exemple, $6$ est un nombre parfait, puisque ses diviseurs sont $1,2,3$ , qui totalisent $6$ , tandis que $12$ n'est pas un nombre parfait puisque ses diviseurs ( $1,2,3,4,6$ ) totalisent $16$ , pas $12$ .

Cas de test:

Imperfect:
1,12,13,18,20,1000,33550335

Perfect:
6,28,496,8128,33550336,8589869056

Règles

• Votre programme n'a pas à terminer les cas de test plus volumineux, s'il y a des contraintes de mémoire ou de temps, mais il devrait théoriquement être capable de lui donner plus de mémoire / temps.
• La sortie peut être deux valeurs distinctes et cohérentes à travers format de sortie autorisé . S'il n'est pas immédiatement évident de savoir ce qui représente parfait / imparfait, veuillez vous assurer de le préciser dans votre réponse.

Brachylog , 4 octets

fk+?

Essayez-le en ligne!

Le prédicat réussit pour les entrées parfaites et échoue pour les entrées imparfaites, l'impression true.ou false.s'il est exécuté comme un programme complet (sauf sur le dernier cas de test qui prend plus d'une minute sur TIO).

        The input's
f       factors
 k      without the last element
  +     sum to
   ?    the input.

Neim , 3 octets

𝐕𝐬𝔼

Essayez-le en ligne!

(Je ne sais pas comment exécuter tous les cas de test en même temps, car j'ai commencé à apprendre Neim il y a une quinzaine de minutes, mais je les ai vérifiés individuellement.)

Imprime 0 pour imparfait, 1 pour parfait.

𝐕      Pop an int from the stack and push its proper divisors,
       implicitly reading the int from a line of input as the otherwise absent top of the stack.
 𝐬     Pop a list from the stack and push the sum of the values it contains.
  𝔼    Pop two ints from the stack and push 1 if they are equal, 0 if they are not;
       implicitly reading the same line of input that was already read as the second int, I guess?
       Implicitly print the contents of the stack, or something like that.

R , 33 29 octets

!2*(n=scan())-(x=1:n)%*%!n%%x

Essayez-le en ligne!

Retourne TRUEpour les nombres parfaits et FALSEpour les imparfaits.

Gelée , 3 octets

Æṣ=

Essayez-le en ligne!

Japt -! , 4 octets

¥â¬x
-----------------
            Implicit Input U
¥           Equal to
   x        Sum of
 â          Factors of U
  ¬         Without itself

Pour une raison quelconque, ne ¦fonctionne pas sur tio, je dois donc utiliser le -!drapeau et à la ¥place

Essayez-le en ligne!

Python 3 , 46 octets

lambda x:sum(i for i in range(1,x)if x%i<1)==x

Essayez-le en ligne!

Force brute, additionne les facteurs et vérifie l'égalité.

Python , 45 octets

lambda n:sum(d*(n%d<1)for d in range(1,n))==n

Truepour parfait; Falsepour les autres (changez ceci avec ==-> !=)

Essayez-le en ligne!

 44 42  41 octets (-2 grâce aux ovs) si nous pouvons sortir en utilisant "truey vs falsey":

f=lambda n,i=1:i/n or-~f(n,i+1)-(n%i<1)*i

(falsey ( 0)) pour parfait; véridique (un entier non nul) sinon

Octave , 25 octets

@(n)~mod(n,t=1:n)*t'==2*n

Essayez-le en ligne!

Explication

@(n)~mod(n,t=1:n)*t'==2*n

@(n)                        % Define anonymous function with input n
             1:n            % Row vector [1,2,...,n]
           t=               % Store in variable t
     mod(n,     )           % n modulo [1,2,...,n], element-wise. Gives 0 for divisors
    ~                       % Logical negate. Gives 1 for divisors
                  t'        % t transposed. Gives column vector [1;2;...;n]
                 *          % Matrix multiply
                      2*n   % Input times 2
                    ==      % Equal? This is the output value

JavaScript, 38 octets

n=>eval("for(i=s=n;i--;)n%i||!(s-=i)")

Essayez-le en ligne!

(Délai d'expiration du dernier test sur TIO.)

C # (Visual C # Interactive Compiler) , 46 octets

n=>Enumerable.Range(1,n).Sum(x=>n%x<1?x:0)^n*2

Retourne 0 si parfait, sinon retourne un nombre positif. Je ne sais pas si la sortie de différents types d'entiers est autorisée à la place de deux valeurs distinctes de vérité et de fausse, et je n'ai trouvé aucune discussion sur les méta à ce sujet. Si ce n'est pas valide, je le supprimerai.

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 49 47 octets

n=>Enumerable.Range(1,n).Sum(x=>n%x<1?x:0)==n*2

Essayez-le en ligne!

Rubis , 33 octets

->n{(1...n).sum{|i|n%i<1?i:0}==n}

Essayez-le en ligne!

TI-BASIC (TI-84), 30 23 octets

:2Ans=sum(seq(Ans/Xnot(remainder(Ans,X)),X,1,Ans,1

Horriblement inefficace, mais ça marche.
La réduction du nombre de bytec a accéléré le programme de beaucoup.
L'entrée est en Ans.
La sortie est Ansentrée et est automatiquement imprimée à la fin du programme.

Explication:
(TI-BASIC n'a pas de commentaires, alors supposez simplement que cela ;fait un commentaire)

:2Ans=sum(seq(Ans/Xnot(remainder(Ans,X)),X,1,Ans    ;Full program

 2Ans                                               ;double the input
          seq(                                      ;generate a list
                                         X,          ;using the variable X,
                                           1,        ;starting at 1,
                                             Ans     ;and ending at the input
                                                     ;with an implied increment of 1
              Ans/X                                 ;from the input divided by X
                   not(                ),           ;multiplied by the negated result of
                       remainder(Ans,X)              ;the input modulo X
                                                     ;(result: 0 or 1)
      sum(                                          ;sum up the elements in the list
     =                                              ;equal?

Exemple:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Remarque: Le nombre d'octets d'un programme est évalué en utilisant la valeur dans [MEM] > [2] > [7] (36 octets) puis en soustrayant la longueur du nom du programme,CDGF2 (5 octets) et 8 octets supplémentaires utilisés pour stockage du programme:

36 - 5 - 8 = 23 octets

Java (JDK) , 54 octets

n->{int s=0,d=0;for(;++d<n;)s+=n%d<1?d:0;return s==n;}

Essayez-le en ligne!

Bien que pour une correspondance stricte nombre par nombre, ce qui suit renverra les mêmes valeurs, mais ne fait que 40 octets.

n->n==6|n==28|n==496|n==8128|n==33550336

Essayez-le en ligne!

Assemblage x86, 45 43 octets.

6A 00 31 C9 31 D2 41 39  C1 7D 0B 50 F7 F9 58 85
D2 75 F1 51 EB EE 31 D2  59 01 CA 85 C9 75 F9 39
D0 75 05 31 C0 40 EB 02  31 C0 C3

Explication (Intel Syntax):

PUSH $0          ; Terminator for later
XOR ECX, ECX        ; Clear ECX
.factor:
    XOR EDX, EDX    ; Clear EDX
    INC ECX
    CMP ECX, EAX    ; divisor >= input number?
    JGE .factordone ; if so, exit loop.
    PUSH EAX        ; backup EAX
    IDIV ECX        ; divide EDX:EAX by ECX, store result in EAX and remainder in EDX
    POP EAX         ; restore EAX
    TEST EDX, EDX   ; remainder == 0?
    JNZ .factor     ; if not, jump back to loop start
    PUSH ECX        ; push factor
    JMP .factor     ; jump back to loop start
.factordone:
XOR EDX, EDX        ; clear EDX
.sum:
    POP ECX         ; pop divisor
    ADD EDX, ECX    ; sum into EDX
    TEST ECX, ECX   ; divisor == 0?
    JNZ .sum        ; if not, loop.
CMP EAX, EDX        ; input number == sum?
JNE .noteq          ; if not, skip to .noteq
    XOR EAX, EAX    ; clear EAX
    INC EAX         ; increment EAX (sets to 1)
JMP .return         ; skip to .return
.noteq:
    XOR EAX, EAX    ; clear EAX
.return:
RETN

L'entrée doit être fournie EAX.
La fonction se définit EAXsur 1pour parfait et sur 0pour imparfait.

EDIT : nombre d'octets réduit de deux en remplaçant MOV EAX, $1par XOR EAX, EAXetINC EAX

Labyrinthe , 80 octets

?::`}:("(!@
perfect:
{:{:;%"}
+puts; "
}zero: "
}else{(:
"negI"  _~
""""""{{{"!@

Les caractères latins ne perfect puts zero else neg Isont en fait que des commentaires *.
c'est-à-dire que si l'entrée est parfaite, un 0est imprimé, sinon -1.

Essayez-le en ligne!

* donc ceci ou ce travail aussi ...

?::`}:("(!@               ?::`}:("(!@
       :                  BEWARE :
{:{:;%"}                  {:{:;%"}
+    ; "                  +LAIR; "
}    : "                  } OF : "
}    {(:                  }MINO{(:
"    "  _~                "TAUR"  _~
""""""{{{"!@              """"""{{{"!@

Comment?

Prend en entrée un entier positif net place une variable d'accumulateur de -nsur la pile auxiliaire, puis effectue un test de divisibilité pour chaque entier de n-1bas en haut, y compris, 1en ajoutant tout ce qui se divise ndans l'accumulateur. Une fois cette opération terminée, si la variable accumulateur est non nulle, a -1est émis, sinon a0 est.

Le ?::`}:(n'est exécuté qu'une seule fois, au début de l'exécution:

?::`}:(                                                      Main,Aux
?       - take an integer from STDIN and place it onto Main  [[n],[]]
 :      - duplicate top of Main                            [[n,n],[]]
  :     - duplicate top of Main                          [[n,n,n],[]]
   `    - negate top of Main                            [[n,n,-n],[]]
    }   - place top of Main onto Aux                       [[n,n],[-n]]
     :  - duplicate top of Main                          [[n,n,n],[-n]]
      ( - decrement top of Main                        [[n,n,n-1],[-n]]

La prochaine instruction, " est un no-op, mais nous avons trois instructions voisines, donc nous nous branchons en fonction de la valeur en haut de Main, zéro nous fait avancer, tandis que non zéro nous mène à droite.

Si l'entrée était, 1nous allons de l'avant parce que le haut de Main est zéro:

(!@                                                          Main,Aux
(   - decrement top of Main                             [[1,1,-1],[-1]]
 !  - print top of Main, a -1
  @ - exit the labyrinth

Mais si l'entrée était supérieure à 1ce que nous tournons à droite parce que le haut de Main est différent de zéro:

:}                                                           Main,Aux
:  - duplicate top of Main                         [[n,n,n-1,n-1],[-n]]
 } - place top of Main onto Aux                        [[n,n,n-1],[-n,n-1]]

À ce stade, nous avons une branche à trois voisins, mais nous savons qu'elle n-1est non nulle, nous tournons donc à droite ...

"%                                                           Main,Aux
"  - no-op                                             [[n,n,n-1],[-n,n-1]]
 % - place modulo result onto Main                   [[n,n%(n-1)],[-n,n-1]]
   - ...i.e we've got our first divisibility indicator n%(n-1), an
   -    accumulator, a=-n, and our potential divisor p=n-1:
   -                                                 [[n,n%(n-1)],[a,p]]

Nous sommes maintenant à une autre succursale à trois voisins à %.

Si le résultat de %était non nul, nous allons à gauche pour décrémenter notre diviseur potentiel p=p-1, et quittons l'accumulateur a, tel qu'il est:

;:{(:""}"                                                    Main,Aux
;          - drop top of Main                                [[n],[a,p]]
 :         - duplicate top of Main                         [[n,n],[a,p]]
  {        - place top of Aux onto Main                  [[n,n,p],[a]]
           - three-neighbour branch but n-1 is non-zero so we turn left
   (       - decrement top of Main                     [[n,n,p-1],[a]]
    :      - duplicate top of Main                 [[n,n,p-1,p-1],[a]]
     ""    - no-ops                                [[n,n,p-1,p-1],[a]]
       }   - place top of Main onto Aux                [[n,n,p-1],[a,p-1]]
        "  - no-op                                     [[n,n,p-1],[a,p-1]]
         % - place modulo result onto Main           [[n,n%(p-1)],[a,p-1]]
           - ...and we branch again according to the divisibility
           -    of n by our new potential divisor, p-1

... mais si le résultat de %était égal à zéro (pour la première passe que lorsque n=2) nous allons tout droit sur Both Ajouter le diviseur à notre accumulateur, a=a+pET décrémenter notre potentiel diviseur, p=p-1:

;:{:{+}}""""""""{(:""}                                       Main,Aux
;                      - drop top of Main                    [[n],[a,p]]
 :                     - duplicate top of Main             [[n,n],[a,p]]
  {                    - place top of Aux onto Main      [[n,n,p],[a]]
   :                   - duplicate top of Main         [[n,n,p,p],[a]]
    {                  - place top of Aux onto Main  [[n,n,p,p,a],[]]
     +                 - perform addition            [[n,n,p,a+p],[]]
      }                - place top of Main onto Aux      [[n,n,p],[a+p]]
       }               - place top of Main onto Aux        [[n,n],[a+p,p]]
        """""""        - no-ops                            [[n,n],[a+p,p]]
                       - a branch, but n is non-zero so we turn left
               "       - no-op                             [[n,n],[a+p,p]]
                {      - place top of Aux onto Main      [[n,n,p],[a+p]]
                       - we branch, but p is non-zero so we turn right
                 (     - decrement top of Main         [[n,n,p-1],[a+p]]
                  :    - duplicate top of Main     [[n,n,p-1,p-1],[a+p]]
                   ""  - no-ops                    [[n,n,p-1,p-1],[a+p]]
                     } - place top of Main onto Aux    [[n,n,p-1],[a+p,p-1]]

À ce stade, si p-1est toujours non nul, nous tournons à gauche:

"%                                                           Main,Aux
"  - no-op                                             [[n,n,p-1],[a+p,p-1]]
 % - modulo                                          [[n,n%(p-1)],[a+p,p-1]]
   - ...and we branch again according to the divisibility
   -    of n by our new potential divisor, p-1

... mais si p-1frappé à zéro, nous allons directement à la :deuxième ligne du labyrinthe (vous avez déjà vu toutes les instructions, donc je laisse leurs descriptions et je donne juste leur effet):

:":}"":({):""}"%;:{:{+}}"""""""{{{                           Main,Aux
:                                  -                   [[n,n,0,0],[a,0]]
 "                                 -                   [[n,n,0,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
  :                                -                 [[n,n,0,0,0],[a,0]]
   }                               -                   [[n,n,0,0],[a,0,0]]
                                   - top of Main is zero so we go straight
    ""                             -                   [[n,n,0,0],[a,0,0]]
      :                            -                 [[n,n,0,0,0],[a,0,0]]
       (                           -                [[n,n,0,0,-1],[a,0,0]]
        {                          -              [[n,n,0,0,-1,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
         (                         -             [[n,n,0,0,-1,-1],[a,0]]
          :                        -          [[n,n,0,0,-1,-1,-1],[a,0]]
           ""                      -          [[n,n,0,0,-1,-1,-1],[a,0]]
             }                     -             [[n,n,0,0,-1,-1],[a,0,-1]]
                                   - top of Main is non-zero so we turn left
              "                    -             [[n,n,0,0,-1,-1],[a,0,-1]]
               %                   - (-1)%(-1)=0     [[n,n,0,0,0],[a,0,-1]]
                ;                  -                   [[n,n,0,0],[a,0,-1]]
                 :                 -                 [[n,n,0,0,0],[a,0,-1]]
                  {                -              [[n,n,0,0,0,-1],[a,0]]
                   :               -           [[n,n,0,0,0,-1,-1],[a,0]]
                    {              -         [[n,n,0,0,0,-1,-1,0],[a]]
                     +             -           [[n,n,0,0,0,-1,-1],[a]]
                      }            -              [[n,n,0,0,0,-1],[a,-1]]
                       }           -                 [[n,n,0,0,0],[a,-1,-1]]
                        """""""    -                 [[n,n,0,0,0],[a,-1,-1]]
                                   - top of Main is zero so we go straight
                               {   -              [[n,n,0,0,0,-1],[a,-1]]
                                {  -           [[n,n,0,0,0,-1,-1],[a]]
                                 { -         [[n,n,0,0,0,-1,-1,a],[]]

Maintenant, cela {a trois instructions voisines, donc ...

... si aest zéro, ce qui sera parfait n, alors nous allons tout droit:

"!@                                                          Main,Aux
"   -                                        [[n,n,0,0,0,-1,-1,a],[]]
    - top of Main is a, which is zero, so we go straight
 !  - print top of Main, which is a, which is a 0
  @ - exit the labyrinth

... si aest non nul, ce qu'il sera pour non parfait n, alors nous tournons à gauche:

_~"!@                                                        Main,Aux
_     - place a zero onto Main             [[n,n,0,0,0,-1,-1,a,0],[]]
 ~    - bitwise NOT top of Main (=-1-x)   [[n,n,0,0,0,-1,-1,a,-1],[]]
  "   -                                   [[n,n,0,0,0,-1,-1,a,-1],[]]
      - top of Main is NEGATIVE so we turn left
   !  - print top of Main, which is -1
    @ - exit the labyrinth

CJam , 17 octets

ri_,(;{1$\%!},:+=

Essayez-le en ligne!

Javascript, 62

n=>n==[...Array(n).keys()].filter(a=>n%a<1).reduce((a,b)=>a+b)

Explication (bien que ce soit assez simple)

n=> //return function that takes n
  n== //and returns if n is equal to
    [...Array(n).keys()] //an array [0..(n-1)]...
      .filter(a=>n%a<1) //where all of the elements that are not divisors of n are taken out...
      .reduce((a,b)=>a+b) //summed up

Merci à Jo King pour l'amélioration!

05AB1E , 4 octets

ѨOQ

Essayez-le en ligne!

Explication

  O    # the sum
Ñ      # of the divisors of the input
 ¨     # with the last one removed
   Q   # equals the input

Powershell, 46 octets 43 octets

param($i)1..$i|%{$o+=$_*!($i%$_)};$o-eq2*$i

Essayez-le en ligne!

Edit: -3 octets grâce à @AdmBorkBork

C (gcc) , 41 octets

f(n,i,s){for(i=s=n;--i;s-=n%i?0:i);n=!s;}

Essayez-le en ligne!

1: 0
12: 0
13: 0
18: 0
20: 0
1000: 0
33550335: 0
6: 1
28: 1
496: 1
8128: 1
33550336: 1
-65536: 0 <---- Unable to represent final test case with four bytes, fails

Faites-moi savoir si cet échec pour le cas final est un problème.

Smalltalk, 34 octets

((1to:n-1)select:[:i|n\\i=0])sum=n

Forth (gforth) , 45 octets

: f 0 over 1 ?do over i mod 0= i * - loop = ;

Essayez-le en ligne!

Explication

Boucle sur chaque nombre de 1 à n-1, sommant toutes les valeurs qui divisent n parfaitement. Renvoie vrai si la somme est égale à n

Explication du code

: f                \ start word definition
  0 over 1         \ create a value to hold the sum and setup the bounds of the loop
  ?do              \ start a counted loop from 1 to n. (?do skips if start = end)
    over           \ copy n to the top of the stack
    i mod 0=       \ check if i divides n perfectly
    i * -          \ if so, use the fact that -1 = true in forth to add i to the sum
  loop             \ end the counted loop
  =                \ check if the sum and n are equal
;                  \ end the word definition

Pyth , 9 13 octets

qsf!%QTSt

Essayez-le en ligne!

Merci aux commentateurs pour l'aide au golf

Recherche tous les facteurs de l'entrée, les additionne et les compare à l'entrée d'origine.

Lot, 81 octets

@set s=-%1
@for /l %%i in (1,1,%1)do @set/as+=%%i*!(%1%%%%i)
@if %s%==%1 echo 1

Prend ncomme paramètre de ligne de commande et sort 1s'il s'agit d'un nombre parfait. Méthode de force brute, démarre la somme à -nafin qu'elle puisse s'inclure ndans la boucle.

Fusain , 13 octets

Ｎθ⁼θΣΦθ∧ι¬﹪θι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Sorties -pour des nombres parfaits. Utilise la force brute. Explication:

Ｎθ              Numeric input
     Φθ         Filter on implicit range
        ι       Current value (is non-zero)
       ∧        Logical And
           θ    Input value
          ﹪     Modulo
            ι   Current value
         ¬      Is zero
    Σ           Sum of matching values
  ⁼             Equals
   θ            Input value

Wolfram Language (Mathematica) , 14 octets

PerfectNumberQ

Essayez-le en ligne!

Pyth, 8 octets

qs{*MPyP

Essayez-le en ligne ici .

qs{*MPyPQQ   Implicit: Q=eval(input())
             Trailing QQ inferred
       PQ    Prime factors of Q
      y      Powerset
     P       Remove last element - this will always be the full prime factorisation
   *M        Take product of each
  {          Deduplicate
 s           Sum
q        Q   Is the above equal to Q? Implicit print

Retina 0.8.2 , 44 octets

.+
$*
M!&`(.+)$(?<=^\1+)
+`^1(1*¶+)1
$1
^¶+$

Essayez-le en ligne! Utilise la force brute, donc le lien inclut uniquement les cas de test les plus rapides. Explication:

.+
$*

Convertissez en unaire.

M!&`(.+)$(?<=^\1+)

Faites correspondre tous les facteurs de l'entrée. Cela utilise le mode de chevauchement, qui dans Retina 0.8.2 nécessite que toutes les correspondances commencent à des positions différentes, de sorte que les correspondances sont en fait retournées dans l'ordre décroissant, en commençant par l'entrée d'origine.

+`^1(1*¶+)1
$1

Soustrayez les facteurs appropriés de l'entrée.

^¶+$

Testez si le résultat est nul.

Java 8, 66 octets

Quelqu'un doit utiliser l'API Stream à un moment donné, même s'il existe un moyen plus court de le faire

n->java.util.stream.IntStream.range(1,n).filter(i->n%i<1).sum()==n

Essayez-le en ligne!

cQuents , 8 octets

?#N=U\zN

Essayez-le en ligne!

Explication

?           Mode query: return whether or not input is in sequence
 #          Conditional: iterate N, add N to sequence if condition is true
  N=         Condition: N == 
    U    )                   sum(                  )
     \z )                        proper_divisors( )
       N                                         N
        ))    implicit