Ne suis-je pas assez bien pour toi?


29

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 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.

Attendez, alors la vérité est pour les valeurs qui ne sont pas parfaites, et Falsey est pour les valeurs qui le sont?
Esolanging Fruit

2
@ Tvde1 Les diviseurs corrects doivent être inférieurs au nombre, sinon aucun nombre autre que 1serait parfait, car chaque nombre est divisible par 1lui-même. La somme des diviseurs propres de 1est0
Jo King

3
@Grimy Seulement si vous pouvez le prouver . Bonne chance! (même si je me demande comment cela permettrait d'économiser des octets)
Jo King

1
Alors non, tant pis. Cela réduirait la taille d'une réponse d'expression régulière ECMA d'un facteur d'environ 3.
Grimmy

3
"La sortie peut être deux valeurs distinctes et cohérentes" - ne pouvons-nous pas utiliser "vérité vs falsey" ici (par exemple pour Python utilisant zéro vs non nul; une liste avec du contenu vs une liste vide; et leurs combinaisons)?
Jonathan Allan

Réponses:



9

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.

2
" Je suppose? "; " ou quelque chose comme ça. ". Quand vous n'êtes même pas sûr de ce que vous avez écrit, haha. ;) Mais oui, c'est bien ainsi que cela fonctionne. Je ne connais pas Neim, mais utiliser l'entrée implicitement comme ça et sortir implicitement à la fin implicitement, est similaire dans 05AB1E.
Kevin Cruijssen

Comment est 𝔼1 octet? Neim n'utilise-t-il que 128 de ces personnages non standard?
kajacx

3
@kajacx Neim a sa propre page de codes . Par conséquent, chacun des 256 caractères présents dans la page de codes peut être codé en utilisant 1 octet.
M. Xcoder

8

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.


Qu'est-ce que les 2! S d'affilée vous procurent?
CT Hall

@CTHall J'ai mal lu la spécification; ils ont à l'origine mappé 0(parfait) FALSEet différent de zéro, TRUEmais j'ai supprimé l'un d'eux pour inverser le mappage. C'est une astuce de golf utile pour lancer de numericà logical, souvent en conjonction avec whichou [.
Giuseppe


7

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!


Ce n'est pas un problème TIO; Un'est pas inséré automatiquement auparavant !.
Shaggy

6

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é.


2
L'utilisation de la condition de compréhension comme masque pour votre variable d'itération sauverait un octet.
Jonathan Frech

Puisque vous pouvez renvoyer la vérité pour un nombre imparfait, cela lambda x:sum(i for i in range(1,x)if x%i<1)^xdevrait également fonctionner.
nedla2004

5

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


Si le deuxième format de sortie est valide, cela peut être fait en 42 octets .
OVS

@ovs ah, bien joué.
Jonathan Allan

@ovs ..et un autre sauvé de cela - merci!
Jonathan Allan

5

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

4

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


@Arnauld J'ai juste oublié de supprimer la f=conversion après une fonction récursive.
tsh

Par curiosité, pourquoi ne pas opter pour une version récursive? (Ce serait 34 octets.)
Arnauld

@Arnauld car la version récursive échouerait simplement pour un plus grand cas de test en raison d'un débordement de pile. Peut-être que j'ai besoin de certains environnements par défaut en mode strict pour le faire fonctionner.
tsh

2
D'accord, mais votre programme n'a pas à compléter les cas de test les plus importants (ce qui, je pense, est la règle par défaut, de toute façon).
Arnauld

4

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!



3

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


3

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!


Les règles disentYour program doesn't have to complete the larger test cases, if there's memory or time constraints, but it should be theoretically able to if it were given more memory/time.
Jo King

@JoKing Est-ce à dire que je ne peux pas du tout utiliser Java int, mais plutôt un BigInteger? Parce que Java a BigIntegers, mais il n'aura jamais intplus de 31 bits comme signé, qui ne peut avoir aucune autre valeur que celles représentées ici ...
Olivier Grégoire

non, mais si le programme devrait toujours fonctionner si le inttype n'était pas borné
Jo King

1
@JoKing Ok, j'ai de nouveau changé les deux solutions pour avoir le calcul en premier.
Olivier Grégoire

3

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


1
J'utilise un macro assembly donc je ne sais pas avec certitude mais le commentaire "; diviseur> numéro d'entrée" pour moi serait "; diviseur> = numéro d'entrée"
RosLuP

L'assemblage a des opérations faciles, on pourrait réduire la longueur des instructions met tout en ligne, utiliser l'indentation et commenter toutes les 10 instructions asm 20 ...
RosLuP

@RosLuP J'ai corrigé le commentaire dans le code (merci), mais je ne sais pas ce que vous voulez dire avec votre deuxième commentaire.
Fayti1703

3

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


2

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!




2

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.



2
"La sortie peut être deux valeurs distinctes et cohérentes à travers n'importe quel format de sortie autorisé." Vous ne renvoyez pas deux valeurs distinctes.
Olivier Grégoire

2
@ OlivierGrégoire Heureusement, cela peut être facilement résolu en remplaçant l'espace par un point d'exclamation!
Neil

1
@Neil Mieux encore, il peut être corrigé avec n=!s;au lieu d' return!s;économiser 5 octets.

@ OlivierGrégoire ahh, j'ai oublié ce point. En outre, mis à jour le avec le code amélioré. J'ai essayé quelque chose de similaire, mais l'idiot que je suis, je l'ai fait, s=sce qui a probablement été optimisé.
Marcos


2

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

2

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.


Quelques golfs pour vous - q0peuvent être remplacés par !et SQproduisent la gamme [1-Q], de sorte que la gamme [1-Q)peut être générée à l'aide StQ. Comme les Qs sont maintenant à la fin du programme, ils peuvent tous les deux être omis. Version effilée, 9 octets -qsf!%QTSt
Sok

1

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.


1

Fusain , 13 octets

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

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:

Nθ              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


1

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

1

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.


1

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!


1

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.