Bin ich nicht gut genug für dich?


29

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

Warten Sie, so wahr ist für Werte, die nicht perfekt sind, und falsch ist für Werte, die sind?
Esolanging Fruit

2
@TVDE1 Richtige Teiler müssen kleiner als die Zahl sein, sonst wäre keine andere Zahl als 1perfekt, da jede Zahl für sich teilbar ist 1. Die Summe der richtigen Teiler von 1ist0
Jo King

3
@Grimy Nur wenn du es beweisen kannst . Viel Glück! (obwohl ich mich frage, wie das Bytes sparen würde)
Jo King

1
Also nein, schade.
Dies

3
"Ausgabe kann aus zwei unterschiedlichen und konsistenten Werten bestehen" - können wir hier nicht "truthy vs falsey" verwenden (z. B. für Python mit Null gegen Null; eine Liste mit Inhalt gegen eine leere Liste und Kombinationen davon)?
Jonathan Allan

Antworten:



9

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.

2
" Ich denke? "; " oder so ähnlich. " Wenn Sie nicht einmal sicher sind, was Sie selbst geschrieben haben, haha. ;) Aber ja, so funktioniert das ja. Ich kenne Neim nicht, aber die implizite Verwendung der Eingabe und die implizite Ausgabe am Ende ist in 05AB1E ähnlich.
Kevin Cruijssen

Wie ist 𝔼1 Byte? Verwendet Neim nur 128 solcher nicht standardmäßigen Zeichen?
Kajacx

3
@kajacx Neim hat eine eigene Codepage . Daher kann jedes der 256 Zeichen in der Codepage mit 1 Byte codiert werden.
Mr. Xcoder

8

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 .


Was bringen dir die 2! S in einer Reihe?
CT Hall

@CTHall Ich habe die Spezifikation falsch gelesen. Sie waren ursprünglich auf 0(perfekt) FALSEund nicht auf null abgebildet , TRUEaber ich habe einen davon entfernt, um die Zuordnung umzukehren. Es ist ein nützlicher Golftrick, von numericzu zu werfen logical, oft in Verbindung mit whichoder [.
Giuseppe


7

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!


Das ist kein TIO-Problem. Uwird vorher nicht automatisch eingefügt !.
Shaggy

6

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.


2
Wenn Sie die Verständnisbedingung als Maske für Ihre Iterationsvariable verwenden, wird ein Byte gespeichert.
Jonathan Frech

Da man für eine unvollkommene Zahl wahrheitsgemäß zurückgeben kann, lambda x:sum(i for i in range(1,x)if x%i<1)^xsollte das auch funktionieren.
nedla2004

5

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)


Wenn das zweite Ausgabeformat gültig ist, kann dies in 42 Bytes erfolgen .
Ovs

@ovs ah, schön gemacht.
Jonathan Allan

@ovs ..und ein anderer davon gerettet - danke!
Jonathan Allan

5

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

4

JavaScript, 38 Bytes

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

Probieren Sie es online!

(Letztes Testfall-Timeout bei TIO.)


@Arnauld Hab gerade vergessen, die f=nach der Konvertierung von einer rekursiven Funktion zu entfernen .
Dienstag,

Warum nicht aus Neugier eine rekursive Version verwenden? (Es wären 34 Bytes.)
Arnauld

@Arnauld, da die rekursive Version für einen größeren Testfall aufgrund eines Stapelüberlaufs einfach fehlgeschlagen wäre. Vielleicht brauche ich einige Umgebungen standardmäßig im strikten Modus, damit es funktioniert.
Dienstag,

2
Fair genug, aber Ihr Programm muss die größeren Testfälle nicht abschließen (was meiner Meinung nach die Standardregel ist).
Arnauld

4

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!



3

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


3

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!


Die Regeln besagenYour 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 Bedeutet das, dass ich überhaupt kein Java verwenden kann int, sondern ein BigInteger? Weil Java hat BigIntegers, aber es wird nie intmehr als 31 Bit als vorzeichenbehaftet haben, die keinen anderen Wert als die hier dargestellten enthalten können ...
Olivier Grégoire

nein, aber wenn das Programm trotzdem funktionieren sollte, wenn der intTyp unbegrenzt war
Jo King

1
@JoKing Ok, ich habe die beiden Lösungen erneut gewechselt, um die Berechnung zuerst zu haben.
Olivier Grégoire

3

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


1
Ich verwende eine Makrobaugruppe, daher weiß ich nicht genau, aber der Kommentar "; Divisor> Eingabenummer" wäre für mich "; Divisor> = Eingabenummer"
RosLuP

Die Montage ist einfach zu handhaben. Man könnte die Länge der Anweisungen reduzieren, alle 10 bis 20 Anweisungen in eine Zeile setzen, Einrückungen verwenden und Kommentare
abgeben

@RosLuP Ich habe den Kommentar im Code korrigiert (danke), aber ich weiß nicht, was Sie mit Ihrem zweiten Kommentar meinen.
Fayti1703

3

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


2

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!




2

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.



2
"Die Ausgabe kann aus zwei unterschiedlichen und konsistenten Werten in jedem zulässigen Ausgabeformat bestehen." Sie geben keine zwei unterschiedlichen Werte zurück.
Olivier Grégoire

2
@ OlivierGrégoire Zum Glück lässt sich das leicht beheben, indem das Leerzeichen durch ein Ausrufezeichen ersetzt wird!
Neil

1
@Neil Besser noch, es kann mit behoben werden, n=!s;anstatt return!s;5 Bytes zu sparen.

@ OlivierGrégoire ahh, ich habe diesen Punkt vergessen. Außerdem wurde das mit dem verbesserten Code aktualisiert. Ich habe etwas Ähnliches ausprobiert, aber der Idiot, den ich bin, wurde s=shöchstwahrscheinlich optimiert.
Marcos


2

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

2

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.


Ein paar Golfplätze für Sie - q0können durch ersetzt !werden und SQproduzieren die Reichweite [1-Q], sodass die Reichweite [1-Q)mit generiert werden kann StQ. Da sich die Qs nun am Ende des Programms befinden, können beide weggelassen werden. Fettled Version, 9 Bytes -qsf!%QTSt
Sok

1

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.


1

Kohle , 13 Bytes

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

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

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

1

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.



1

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
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.