Tło:

Obecne wyzwanie Perfect Numbers jest raczej wadliwe i skomplikowane, ponieważ wymaga od ciebie wyjścia w złożonym formacie z uwzględnieniem czynników liczby. Jest to repost wyłącznie problemu decyzyjnego .

Wyzwanie

Biorąc pod uwagę dodatnią liczbę całkowitą za pośrednictwem dowolnego standardowego formatu wejściowego , rozróżnij, czy jest ona idealna, czy nie.

Liczba doskonała to liczba równa sumie wszystkich jej właściwych dzielników (jej dodatnich dzielników mniej niż siebie). Na przykład $6$ jest liczbą idealną, ponieważ jej dzielniki wynoszą $1,2,3$ , co daje sumę do $6$ , a $12$ nie jest liczbą idealną, ponieważ jej dzielniki ( $1,2,3,4,6$ ) sumują się do $16$ , nie $12$ .

Przypadki testowe:

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

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

Zasady

• Twój program nie musi wypełniać większych przypadków testowych, jeśli istnieją ograniczenia pamięciowe lub czasowe, ale powinien teoretycznie być w stanie, gdyby otrzymał więcej pamięci / czasu.
• Dane wyjściowe mogą mieć dwie różne i spójne wartości w dowolnym dozwolonym formacie wyjściowym . Jeśli nie jest od razu oczywiste, co reprezentuje Doskonały / Niedoskonały, prosimy o podanie w swojej odpowiedzi.

Brachylog , 4 bajty

fk+?

Wypróbuj online!

Predykatowi udaje się uzyskać idealne dane wejściowe, a nieudanym - niedokładne dane wejściowe, drukowanie true.lub false.uruchomienie jako kompletny program (z wyjątkiem ostatniego przypadku testowego, który zajmuje więcej niż minutę na TIO).

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

Neim , 3 bajty

𝐕𝐬𝔼

Wypróbuj online!

(Właściwie nie wiem, jak uruchomić wszystkie przypadki testowe jednocześnie, ponieważ zacząłem uczyć się Neima około piętnaście minut temu, ale sprawdziłem je indywidualnie).

Drukuje 0 za niedoskonałe, 1 za idealne.

𝐕      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 bajtów

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

Wypróbuj online!

Zwraca TRUEliczby idealne i FALSEniedoskonałe.

Galaretka , 3 bajty

Æṣ=

Wypróbuj online!

Japt -! , 4 bajty

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

Z jakiegoś powodu ¦nie działa na Tio, więc muszę użyć -!flagi i¥ zamiast tego

Wypróbuj online!

Python 3 , 46 bajtów

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

Wypróbuj online!

Brutalna siła, sumuje czynniki i sprawdza równość.

Python , 45 bajtów

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

Truedla idealnego; Falsedla innych (przełącz to za pomocą ==-> !=)

Wypróbuj online!

 44 42  41 bajtów (-2 dzięki ovs), jeśli możemy wyprowadzać dane używając „truey vs falsey”:

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

(falsey ( 0)) dla ideału; prawda (liczba całkowita niezerowa) w przeciwnym razie

Oktawa , 25 bajtów

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

Wypróbuj online!

Wyjaśnienie

@(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 bajtów

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

Wypróbuj online!

(Limit czasu ostatniej próby w TIO.)

C # (interaktywny kompilator Visual C #) , 46 bajtów

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

Zwraca 0, jeśli jest idealne, w przeciwnym razie zwraca liczbę dodatnią. Nie wiem, czy wypuszczanie różnych typów liczb całkowitych jest dozwolone zamiast dwóch odrębnych wartości prawdy i fałszu, i nie mogłem znaleźć dyskusji na temat meta na ten temat. Jeśli jest to nieważne, usunę go.

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 49 47 bajtów

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

Wypróbuj online!

Ruby , 33 bajty

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

Wypróbuj online!

TI-BASIC (TI-84), 30 23 bajtów

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

Strasznie nieefektywne, ale działa.
Zmniejszenie liczby bajtów znacznie przyspieszyło program.
Wejście jest w Ans.
Wyjście jest wAns i są automatycznie drukowane po zakończeniu programu.

Objaśnienie:
(TI-BASIC nie ma komentarzy, więc załóżmy, że ;robi komentarz)

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

Przykład:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Uwaga: Liczba bajtów programu jest obliczana przy użyciu wartości w [MEM] > [2] > [7] (36 bajtów), a następnie odejmując długość nazwy programu CDGF2, (5 bajtów) i dodatkowe 8 bajtów używanych dla przechowywanie programu:

36 - 5 - 8 = 23 bajty

Java (JDK) , 54 bajty

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

Wypróbuj online!

Chociaż dla ścisłego dopasowania liczby do liczby następujące, zwrócą te same wartości, ale tylko 40 bajtów.

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

Wypróbuj online!

Montaż x86, 45 43 bajtów.

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

Wyjaśnienie (składnia Intel):

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

Dane wejściowe należy podać w EAX.
Zestawy funkcji EAXdo 1idealnego i do0 za niedoskonałe.

Edycja : zredukowany Liczba bajtów w dwóch zastępując MOV EAX, $1z XOR EAX, EAXaINC EAX

Labirynt , 80 bajtów

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

Znaki łacińskie perfect puts zero else neg Isą w rzeczywistości tylko komentarzami *.
tzn. jeśli dane wejściowe są idealne, 0drukowane jest, w przeciwnym razie -1jest

Wypróbuj online!

* więc to lub to też działa ...

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

W jaki sposób?

Przyjmuje jako dane wejściowe dodatnią liczbę całkowitą ni umieszcza zmienną akumulatora -nna stosie pomocniczym, a następnie wykonuje test podzielności dla każdej liczby całkowitej od w n-1dół do włącznie 1, dodając dowolne, które dzielą ndo akumulatora. Po zakończeniu tej czynności, jeżeli zmienna akumulatora jest niezerowa, -1wyprowadzane jest a , w przeciwnym razie a 0jest.

?::`}:(Jest wykonywany tylko raz, na początku realizacji:

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

Następna instrukcja, "to brak operacji, ale mamy trzy sąsiednie instrukcje, więc rozgałęziamy się zgodnie z wartością na górze Main, zero prowadzi nas do przodu, a niezerowe prowadzi nas w prawo.

Jeśli dane wejściowe 1byłyby kontynuowane, ponieważ górna część Main ma zero:

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

Ale jeśli dane wejściowe były większe niż 1skręcamy w prawo, ponieważ góra Main jest różna od zera:

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

W tym momencie mamy oddział trzech sąsiadów, ale wiemy, że n-1jest niezerowy, więc skręcamy w prawo ...

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

Jesteśmy teraz w innym oddziale trzech sąsiadów w %.

Jeśli wynik %był niezerowy, idziemy w lewo, aby zmniejszyć nasz potencjalny dzielnik p=p-1, i opuścić akumulator a, ponieważ jest:

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

... ale jeśli wynik %był zerowy (dla pierwszego przejścia tylko wtedy n=2) a=a+p, przejdźmy DO ZARÓWNO dodajmy dzielnik do naszego akumulatora , ORAZ zmniejszamy nasz potencjalny dzielnik 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]]

W tym momencie, jeśli p-1nadal nie jest zero, skręcamy w lewo:

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

... ale jeśli p-1osiągniemy zero, przejdziemy prosto do :drugiej linii labiryntu (widziałeś już wszystkie instrukcje wcześniej, więc pomijam ich opisy i po prostu daję efekt):

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

Teraz {ma trzy sąsiednie instrukcje, więc ...

... jeśli awynosi zero, co będzie idealne n, to idziemy prosto:

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

... jeśli ajest niezerowe, co będzie niedokładne n, wówczas skręcamy w lewo:

_~"!@                                                        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 bajtów

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

Wypróbuj online!

JavaScript, 62

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

Wyjaśnienie (chociaż jest to dość proste)

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

Dzięki Jo King za ulepszenie!

05AB1E , 4 bajty

ѨOQ

Wypróbuj online!

Wyjaśnienie

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

PowerShell, 46 bajtów 43 bajty

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

Wypróbuj online!

Edycja: -3 bajty dzięki @AdmBorkBork

C (gcc) , 41 bajtów

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

Wypróbuj 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

Daj mi znać, jeśli to niepowodzenie w ostatniej sprawie jest problemem.

Smalltalk, 34 bajty

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

Dalej (gforth) , 45 bajtów

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

Wypróbuj online!

Wyjaśnienie

Zapętla każdą liczbę od 1 do n-1, sumując wszystkie wartości, które dzielą n idealnie. Zwraca true, jeśli suma jest równa n

Wyjaśnienie kodu

: 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 bajtów

qsf!%QTSt

Wypróbuj online!

Dziękuję komentatorom za pomoc w golfie

Znajduje wszystkie czynniki wejściowe, sumuje je i porównuje z oryginalnymi danymi wejściowymi.

Partia, 81 bajtów

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

Pobiera njako parametr wiersza polecenia i wypisuje, 1jeśli jest to liczba idealna. Metoda brute force rozpoczyna sumę od, -naby mogła się włączyć ndo pętli.

Węgiel drzewny , 13 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjścia -dla idealnych liczb. Używa brutalnej siły. Wyjaśnienie:

Ｎθ              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 bajtów

PerfectNumberQ

Wypróbuj online!

Pyth, 8 bajtów

qs{*MPyP

Wypróbuj online tutaj .

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 bajty

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

Wypróbuj online! Używa brutalnej siły, więc link zawiera tylko szybsze przypadki testowe. Wyjaśnienie:

.+
$*

Konwertuj na unary.

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

Dopasuj wszystkie czynniki wejściowe. Wykorzystuje to tryb nakładania się, który w Retina 0.8.2 wymaga, aby wszystkie mecze zaczynały się na różnych pozycjach, więc mecze są zwracane w kolejności malejącej, zaczynając od oryginalnych danych wejściowych.

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

Odejmij odpowiednie dane wejściowe.

^¶+$

Sprawdź, czy wynik wynosi zero.

Java 8, 66 bajtów

Ktoś musi kiedyś użyć interfejsu API strumienia, nawet jeśli jest to krótszy sposób

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

Wypróbuj online!

cQuents , 8 bajtów

?#N=U\zN

Wypróbuj online!

Wyjaśnienie

?           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