Latar Belakang:

Tantangan Angka Sempurna saat ini agak cacat dan rumit, karena ia meminta Anda untuk menghasilkan dalam format yang kompleks yang melibatkan faktor-faktor angka. Ini adalah repost masalah keputusan murni dari tantangan.

Tantangan

Diberi bilangan bulat positif melalui format input standar apa pun , bedakan antara sempurna atau tidak.

Angka sempurna adalah angka yang sama dengan jumlah semua pembagi yang tepat (pembagi positifnya kurang dari itu sendiri). Misalnya, $6$ adalah angka sempurna, karena pembagi-nya adalah $1,2,3$ , yang berjumlah hingga $6$ , sedangkan $12$ bukan angka yang sempurna karena pembagi-pembaginya ( $1,2,3,4,6$ ) berjumlah hingga $16$ , bukan $12$ .

Kasus uji:

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

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

Aturan

• Program Anda tidak harus menyelesaikan kasus uji yang lebih besar, jika ada memori atau kendala waktu, tetapi harus secara teoritis dapat jika diberikan lebih banyak memori / waktu.
• Output dapat berupa dua nilai yang berbeda dan konsisten melalui format output yang diizinkan . Jika tidak jelas apa yang mewakili Sempurna / Tidak Sempurna, pastikan untuk menentukan jawaban Anda.

Brachylog , 4 byte

fk+?

Cobalah online!

Predikat berhasil untuk input sempurna dan gagal untuk input tidak sempurna, pencetakan true.atau false.jika dijalankan sebagai program lengkap (kecuali pada test case terakhir yang membutuhkan lebih dari satu menit pada TIO).

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

Neim , 3 byte

𝐕𝐬𝔼

Cobalah online!

(Saya tidak benar-benar tahu cara menjalankan semua kasus uji sekaligus, karena saya mulai belajar Neim sekitar lima belas menit yang lalu, tetapi saya memang memeriksanya secara individual.)

Mencetak 0 untuk imperfect, 1 untuk perfect.

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

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

Cobalah online!

Pengembalian TRUEuntuk angka sempurna dan FALSEuntuk yang tidak sempurna.

Jelly , 3 byte

Æṣ=

Cobalah online!

Japt -! , 4 byte

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

Untuk beberapa alasan ¦tidak berfungsi pada tio jadi saya harus menggunakan -!flag dan ¥sebagai gantinya

Cobalah online!

Python 3 , 46 byte

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

Cobalah online!

Brute force, jumlah faktor dan memeriksa kesetaraan.

Python , 45 byte

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

Trueuntuk sempurna; Falseuntuk orang lain (ganti ini dengan ==-> !=)

Cobalah online!

 44 42  41 byte (-2 terima kasih kepada ovs) jika kita dapat menampilkan menggunakan "truthy vs falsey":

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

(falsey ( 0)) untuk sempurna; kebenaran (bilangan bulat bukan nol) sebaliknya

Oktaf , 25 byte

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

Cobalah online!

Penjelasan

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

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

Cobalah online!

(Batas waktu testcase terakhir di TIO.)

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

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

Mengembalikan 0 jika sempurna, jika tidak, mengembalikan angka positif. Saya tidak tahu apakah mengeluarkan tipe integer yang berbeda diperbolehkan sebagai pengganti dari dua nilai kebenaran dan falsy yang berbeda, dan tidak dapat menemukan diskusi tentang meta tentang hal itu. Jika ini tidak valid, saya akan menghapusnya.

Cobalah online!

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

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

Cobalah online!

Ruby , 33 byte

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

Cobalah online!

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

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

Sangat tidak efisien, tetapi berhasil.
Mengurangi bytecount mempercepat program dengan banyak.
Input di Ans.
Keluaran dalam Ansdan secara otomatis dicetak ketika program selesai.

Penjelasan:
(TI-BASIC tidak memiliki komentar, jadi anggap saja ;membuat komentar)

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

Contoh:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Catatan: Hitungan byte suatu program dievaluasi menggunakan nilai dalam [MEM] > [2] > [7] (36 byte) lalu kurangi panjang nama program CDGF2,, (5 byte) dan tambahan 8 byte yang digunakan untuk menyimpan program:

36 - 5 - 8 = 23 byte

Java (JDK) , 54 byte

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

Cobalah online!

Meskipun untuk nomor ketat dengan nomor yang cocok, berikut ini akan mengembalikan nilai yang sama, tetapi hanya 40 byte.

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

Cobalah 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

Penjelasan (Sintaks 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

Input harus disediakan di EAX.
Fungsi diatur EAXke 1untuk sempurna dan 0untuk tidak sempurna.

EDIT : Mengurangi Byte-Count oleh dua dengan mengganti MOV EAX, $1dengan XOR EAX, EAXdanINC EAX

Labirin , 80 byte

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

Karakter Latin perfect puts zero else neg Isebenarnya hanya komentar *.
yaitu jika input sempurna a 0dicetak, sebaliknya -1adalah.

Cobalah online!

* jadi ini atau ini bekerja juga ...

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

Bagaimana?

Dibawa sebagai input bilangan bulat positif ndan menempatkan variabel akumulator -nke dalam tumpukan bantu, kemudian melakukan tes pembagian untuk setiap bilangan bulat dari n-1bawah hingga, dan termasuk 1, menambahkan apa pun yang membagi nke akumulator. Setelah ini selesai jika variabel akumulator adalah bukan-nol -1adalah keluaran, jika tidak maka 0adalah.

Ini ?::`}:(hanya dieksekusi satu kali, pada awal eksekusi:

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

Instruksi berikutnya ",, adalah no-op, tetapi kami memiliki tiga instruksi tetangga sehingga kami bercabang sesuai dengan nilai di atas Main, nol membawa kita maju, sedangkan non-nol membawa kita benar.

Jika input tadi 1kita maju karena bagian atas Main adalah nol:

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

Tetapi jika input lebih besar dari 1kita belok kanan karena bagian atas Main tidak nol:

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

Pada titik ini kami memiliki cabang tiga tetangga, tetapi kami tahu n-1tidak nol, jadi kami belok kanan ...

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

Kami sekarang berada di cabang tiga tetangga lainnya di %.

Jika hasilnya %bukan nol, kita ke kiri untuk mengurangi pembagi potensial kita p=p-1,, dan meninggalkan akumulator a, seperti:

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

... tetapi jika hasil %adalah nol (untuk lulus pertama hanya ketika n=2) kita pergi langsung ke KEDUA menambahkan pembagi untuk akumulator kami, a=a+p, DAN pengurangan potensi pembagi kami, 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]]

Pada titik ini jika p-1masih nol kita belok kiri:

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

... tetapi jika p-1mencapai nol kita langsung menuju :pada baris kedua labirin (Anda telah melihat semua instruksi sebelumnya, jadi saya meninggalkan deskripsi mereka dan hanya memberikan efeknya):

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

Sekarang ini {memiliki tiga instruksi tetangga, jadi ...

... jika anol, yang akan sempurna n, maka kita langsung:

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

... jika atidak-nol, yang akan menjadi non-sempurna n, maka kita belok kiri:

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

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

Cobalah online!

Javascript, 62

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

Penjelasan (meskipun sangat sederhana)

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

Terima kasih kepada Jo King untuk peningkatannya!

05AB1E , 4 byte

ѨOQ

Cobalah online!

Penjelasan

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

Powershell, 46 byte, 43 byte

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

Cobalah secara Online!

Edit: -3 byte terima kasih kepada @AdmBorkBork

C (gcc) , 41 byte

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

Cobalah 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

Beritahu saya jika kegagalan untuk kasus terakhir adalah masalah.

Smalltalk, 34 byte

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

Keempat (gforth) , 45 byte

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

Cobalah online!

Penjelasan

Ulangi setiap angka dari 1 hingga n-1, menjumlahkan semua nilai yang membagi n dengan sempurna. Mengembalikan nilai true jika jumlah sama dengan n

Penjelasan Kode

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

qsf!%QTSt

Cobalah online!

Terima kasih kepada komentator atas bantuan golfnya

Menemukan semua faktor input, menjumlahkannya, dan membandingkannya dengan input asli.

Batch, 81 byte

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

Dibawa nsebagai parameter baris perintah dan output 1jika angka yang sempurna. Metode brute force, memulai penjumlahan di -nsehingga dapat memasukkan ndirinya sendiri dalam loop.

Arang , 13 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Output -untuk angka sempurna. Menggunakan kekuatan kasar. Penjelasan:

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

Bahasa Wolfram (Mathematica) , 14 byte

PerfectNumberQ

Cobalah online!

Pyth, 8 byte

qs{*MPyP

Cobalah online di sini .

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 byte

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

Cobalah online! Menggunakan kekuatan kasar, jadi tautan hanya mencakup test case yang lebih cepat. Penjelasan:

.+
$*

Konversikan ke unary.

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

Cocokkan semua faktor input. Ini menggunakan mode tumpang tindih, yang dalam Retina 0.8.2 mengharuskan semua pertandingan dimulai pada posisi yang berbeda, sehingga pertandingan benar-benar dikembalikan dalam urutan menurun, dimulai dengan input asli.

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

Kurangi faktor yang tepat dari input.

^¶+$

Uji apakah hasilnya nol.

Java 8, 66 byte

Seseorang harus menggunakan stream API di beberapa titik, bahkan jika ada cara yang lebih pendek untuk melakukannya

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

Cobalah online!

cQuents , 8 byte

?#N=U\zN

Cobalah online!

Penjelasan

?           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