Hintergrund:

Die aktuelle Herausforderung für perfekte Zahlen ist ziemlich fehlerhaft und kompliziert, da Sie aufgefordert werden, in einem komplexen Format auszugeben, das die Faktoren der Zahl berücksichtigt. Dies ist eine rein entscheidungsbedingte Neuauflage der Herausforderung.

Herausforderung

Unterscheiden Sie bei einer positiven Ganzzahl durch jedes Standardeingabeformat , ob es perfekt ist oder nicht.

Eine perfekte Zahl ist eine Zahl, die der Summe aller ihrer richtigen Teiler entspricht (ihre positiven Teiler sind kleiner als sie selbst). Zum Beispiel ist $6$ eine perfekte Zahl, da ihre Teiler $1,2,3$ , die sich zu $6$ summieren , während $12$ keine perfekte Zahl ist, da ihre Teiler ( $1,2,3,4,6$ ) sich zu $16$ summieren nicht $12$ .

Testfälle:

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

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

Regeln

• Ihr Programm muss die größeren Testfälle nicht abschließen, wenn es Speicher- oder Zeitbeschränkungen gibt, aber es sollte theoretisch in der Lage sein, wenn es mehr Speicher / Zeit erhält.
• Die Ausgabe kann aus zwei unterschiedlichen und konsistenten Werten in jedem zulässigen Ausgabeformat bestehen . Wenn nicht sofort ersichtlich ist, was für Perfect / Imperfect steht, geben Sie dies bitte in Ihrer Antwort an.

Brachylog , 4 Bytes

fk+?

Probieren Sie es online!

Das Prädikat ist erfolgreich für perfekte Eingaben und schlägt fehl für fehlerhafte Eingaben, Drucken true.oder false.wenn es als vollständiges Programm ausgeführt wird (mit Ausnahme des letzten Testfalls, der mehr als eine Minute für TIO dauert).

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

Neim , 3 Bytes

𝐕𝐬𝔼

Probieren Sie es online!

(Eigentlich kann ich nicht alle Testfälle auf einmal ausführen, da ich vor ungefähr fünfzehn Minuten angefangen habe, Neim zu lernen, aber ich habe sie einzeln überprüft.)

Druckt 0 für nicht perfekt, 1 für perfekt.

𝐕      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 Bytes

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

Probieren Sie es online!

Gibt TRUEfür perfekte und FALSEfür unvollständige Zahlen zurück .

Gelee , 3 Bytes

Æṣ=

Probieren Sie es online!

Japt -! , 4 Bytes

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

Aus irgendeinem Grund ¦funktioniert tio nicht und ich muss stattdessen das -!Flag und ¥verwenden

Probieren Sie es online!

Python 3 , 46 Bytes

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

Probieren Sie es online!

Brute Force, summiert die Faktoren und prüft auf Gleichheit.

Python , 45 Bytes

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

Truefür perfekt; Falsefür andere (schalte dies mit ==-> !=)

Probieren Sie es online!

 44 42  41 Bytes (-2 dank Ovs), wenn wir mit "truthy vs falsey" ausgeben dürfen:

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

(falsey ( 0)) für perfekt; sonst wahr (eine ganze Zahl ungleich Null)

Oktave , 25 Bytes

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

Probieren Sie es online!

Erläuterung

@(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 Bytes

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

Probieren Sie es online!

(Letztes Testfall-Timeout bei TIO.)

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

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

Gibt 0 zurück, wenn es perfekt ist, andernfalls wird eine positive Zahl zurückgegeben. Ich weiß nicht, ob die Ausgabe verschiedener Arten von Ganzzahlen anstelle von zwei unterschiedlichen Wahrheits - und Falschwerten zulässig ist, und konnte keine Diskussion über Meta darüber finden. Wenn dies ungültig ist, werde ich es entfernen.

Probieren Sie es online!

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

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

Probieren Sie es online!

Ruby , 33 Bytes

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

Probieren Sie es online!

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

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

Schrecklich ineffizient, aber es funktioniert.
Die Reduzierung des Bytecount beschleunigte das Programm um ein Vielfaches.
Eingang ist in Ans.
Die Ausgabe erfolgt in Ansund wird automatisch ausgedruckt, wenn das Programm abgeschlossen ist.

Erläuterung:
(TI-BASIC hat keine Kommentare, nehmen Sie also einfach an, ;dass dies ein Kommentar ist.)

: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?

Beispiel:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Hinweis: Die Byteanzahl eines Programms wird anhand des Werts in [MEM] > [2] > [7] (36 Bytes) ausgewertet, wobei die Länge des Programmnamens abgezogen wird.CDGF2 (5 Bytes) und zusätzliche 8 Bytes für Speichern des Programms:

36 - 5 - 8 = 23 Bytes

Java (JDK) , 54 Byte

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

Probieren Sie es online!

Bei einer strengen Übereinstimmung von Zahl zu Zahl werden im Folgenden dieselben Werte zurückgegeben, jedoch nur 40 Byte.

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

Probieren Sie es online!

x86-Assembly, 45 43 Bytes.

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

Erklärung (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

Die Eingabe sollte in erfolgen EAX.
Funktion setzt EAXauf 1perfekt und auf 0unvollkommen.

BEARBEITEN : Reduziert die Anzahl der Bytes um zwei durch Ersetzen MOV EAX, $1durch XOR EAX, EAXundINC EAX

Labyrinth , 80 Bytes

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

Die lateinischen Zeichen perfect puts zero else neg Isind eigentlich nur Kommentare *.
dh wenn die Eingabe perfekt 0ist, wird a gedruckt, andernfalls -1.

Probieren Sie es online!

* also das oder das klappt auch ...

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

Wie?

Nimmt als Eingabe eine positive ganze Zahl nund platziert eine Akkumulatorvariable von-n auf den Hilfsstapel, führt dann einen Teilbarkeitstest für jede ganze Zahl von n-1unten bis einschließlich durch 1und fügt alle hinzu, die sich nzum Akkumulator teilen . Ist dies abgeschlossen, wenn die Speichervariable nicht Null -1ist, wird a ausgegeben, andernfalls a0 ist a.

Das ?::`}:(wird zu Beginn der Ausführung nur einmal ausgeführt:

?::`}:(                                                      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]]

Die nächste Anweisung, " ist ein No-Op, aber wir haben drei benachbarte Befehle, sodass wir entsprechend dem Wert oben auf Main verzweigen. Null bringt uns vorwärts, während Nicht-Null uns nach rechts bringt.

Wenn die Eingabe war 1 , gehen wir vorwärts, weil die Spitze von Main Null ist:

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

Aber wenn die Eingabe größer war als 1 wir nach rechts abbiegen, weil die Spitze von Main ungleich Null ist:

:}                                                           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]]

Zu diesem Zeitpunkt haben wir einen Zweig mit drei Nachbarn, aber wir wissen, dass er n-1nicht Null ist, also biegen wir rechts ab ...

"%                                                           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]]

Wir sind jetzt in einer anderen Filiale mit drei Nachbarn in %.

Wenn das Ergebnis von %ungleich Null ist, dekrementieren wir nach links unseren potenziellen Divisor p=p-1und lassen den Akkumulator awie folgt:

;:{(:""}"                                                    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

... aber wenn das Ergebnis von %Null war (für den ersten Durchgang nur, wenn n=2), gehen wir direkt zu BEIDEM, fügen Sie den Divisor zu unserem Akkumulator hinzu a=a+p, UND dekrementieren Sie unseren potenziellen Divisor 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]]

An dieser Stelle, wenn p-1immer noch nicht Null ist, biegen wir links ab:

"%                                                           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

... aber wenn p-1wir Null treffen, gehen wir direkt zum: zweiten Zeile des Labyrinths (Sie haben alle Anweisungen schon einmal gesehen, also lasse ich ihre Beschreibungen aus und gebe nur ihre Wirkung):

:":}"":({):""}"%;:{:{+}}"""""""{{{                           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],[]]

Jetzt das { drei benachbarte Anweisungen, so ...

... wenn aNull ist, was es für perfekt sein wird n, dann gehen wir geradeaus:

"!@                                                          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

... wenn anicht null ist, was für nicht perfekt ist n, dann biegen wir links ab:

_~"!@                                                        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 Bytes

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

Probieren Sie es online!

Javascript, 62

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

Erklärung (obwohl es ziemlich einfach ist)

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

Danke an Jo King für die Verbesserung!

05AB1E , 4 Bytes

ѨOQ

Probieren Sie es online!

Erläuterung

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

Powershell, 46 Bytes 43 Bytes

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

Probieren Sie es online!

Edit: -3 Bytes dank @AdmBorkBork

C (gcc) , 41 Bytes

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

Probieren Sie es online!

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

Lassen Sie mich wissen, ob dieses Scheitern im letzten Fall ein Problem ist.

Smalltalk, 34 Bytes

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

Viertens (gviertens) , 45 Bytes

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

Probieren Sie es online!

Erläuterung

Durchläuft jede Zahl von 1 bis n-1 und summiert alle Werte, die n perfekt teilen. Gibt true zurück, wenn sum gleich n ist

Code-Erklärung

: 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 Bytes

qsf!%QTSt

Probieren Sie es online!

Vielen Dank an die Kommentatoren für die Golfhilfe

Findet alle Faktoren der Eingabe, summiert sie und vergleicht sie mit der ursprünglichen Eingabe.

Batch, 81 Bytes

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

Nimmt nals Befehlszeilenparameter und gibt , 1wenn es eine perfekte Zahl ist. Bei der Brute-Force-Methode beginnt die Summe bei, -nsodass sie sich nselbst in die Schleife einschließen kann.

Kohle , 13 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ausgänge -für perfekte Zahlen. Verwendet rohe Gewalt. Erläuterung:

Ｎθ              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 Byte

PerfectNumberQ

Probieren Sie es online!

Pyth, 8 Bytes

qs{*MPyP

Probieren Sie es hier online aus .

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 Bytes

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

Probieren Sie es online! Verwendet Brute Force, sodass Link nur die schnelleren Testfälle enthält. Erläuterung:

.+
$*

In Unary konvertieren.

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

Passen Sie alle Faktoren der Eingabe an. Dies verwendet den Überlappungsmodus, bei dem in Retina 0.8.2 alle Übereinstimmungen an verschiedenen Positionen beginnen müssen, sodass die Übereinstimmungen tatsächlich in absteigender Reihenfolge zurückgegeben werden, beginnend mit der ursprünglichen Eingabe.

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

Subtrahieren Sie die richtigen Faktoren von der Eingabe.

^¶+$

Testen Sie, ob das Ergebnis Null ist.

Java 8, 66 Bytes

Irgendwann muss jemand die Stream-API verwenden, auch wenn es einen kürzeren Weg gibt

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

Probieren Sie es online!

cQuents , 8 Bytes

?#N=U\zN

Probieren Sie es online!

Erläuterung

?           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