Apa aku tidak cukup baik untukmu?

29

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 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.
Jo King
sumber
Tunggu, jadi kebenaran untuk nilai-nilai yang tidak sempurna, dan falsey untuk nilai-nilai itu?
Buah Esolanging
2
@ Tvde1 Pembagi yang tepat harus kurang dari angka, jika tidak, tidak ada angka selain 1sempurna, karena setiap angka dapat dibagi dengan 1sendirinya. Jumlah dari pembagi yang tepat 1adalah0
Jo King
3
@Grimy Hanya jika Anda bisa membuktikannya . Semoga berhasil! (meskipun saya bertanya-tanya bagaimana itu akan menghemat byte)
Jo King
1
Jadi tidak, terlalu buruk. Itu akan memotong ukuran jawaban regex ECMA dengan faktor sekitar 3.
Grimmy
3
"Output dapat berupa dua nilai yang berbeda dan konsisten" - bisakah kita tidak menggunakan "truthy vs falsey" di sini (misalnya untuk Python menggunakan nol vs bukan nol; daftar dengan konten vs daftar kosong; dan kombinasinya)?
Jonathan Allan

Jawaban:

16

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.
String yang tidak terkait
sumber
1
Saya suka bagaimana kode mengatakan fk: x
Ismael Miguel
9

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.
String yang tidak terkait
sumber
2
" Saya kira? "; " atau sesuatu seperti itu. " Ketika Anda bahkan tidak yakin dengan apa yang Anda tulis sendiri, haha. ;) Tapi ya, memang begitu cara kerjanya. Saya tidak tahu Neim, tetapi menggunakan input secara implisit seperti itu dan mengeluarkan secara implisit pada akhirnya secara implisit, serupa di 05AB1E.
Kevin Cruijssen
Bagaimana 𝔼1 byte? Apakah Neim hanya menggunakan 128 karakter yang tidak standar?
kajacx
3
@kajacx Neim memiliki halaman kode sendiri . Oleh karena itu, masing-masing dari 256 karakter yang ada dalam codepage dapat dikodekan menggunakan 1 byte.
Tn. Xcoder
8

R , 33 29 byte

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

Cobalah online!

Pengembalian TRUEuntuk angka sempurna dan FALSEuntuk yang tidak sempurna.

Giuseppe
sumber
Apa yang membuat Anda 2 baris berturut-turut?
CT Hall
@ CTHall saya salah membaca spec; mereka awalnya dipetakan 0(sempurna) ke FALSEdan bukan nol TRUEtetapi saya menghapus salah satu dari mereka untuk membalikkan pemetaan. Ini adalah trik golf yang berguna untuk melakukan lemparan numericke logical, sering bersamaan dengan whichatau [.
Giuseppe
7

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!

Luis felipe De jesus Munoz
sumber
Itu bukan masalah TIO; Utidak dimasukkan secara otomatis sebelumnya !.
Shaggy
6

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.

Neil A.
sumber
2
Menggunakan kondisi pemahaman sebagai topeng untuk variabel iterasi Anda akan menghemat satu byte.
Jonathan Frech
Karena Anda dapat mengembalikan yang benar untuk angka yang tidak sempurna, lambda x:sum(i for i in range(1,x)if x%i<1)^xharusnya bekerja juga.
nedla2004
5

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

Jonathan Allan
sumber
Jika format output kedua valid, ini dapat dilakukan dalam 42 byte .
Ovs
@ovs ah, bagus sekali.
Jonathan Allan
@ovs .. dan yang lain diselamatkan - terima kasih!
Jonathan Allan
5

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
Luis Mendo
sumber
4

JavaScript, 38 byte

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

Cobalah online!

(Batas waktu testcase terakhir di TIO.)

tsh
sumber
@Arnauld Hanya lupa untuk menghapus f=setelah mengkonversi dari fungsi rekursif.
tsh
Hanya ingin tahu, mengapa tidak pergi dengan versi rekursif? (Ini akan menjadi 34 byte.)
Arnauld
@Arnauld karena versi rekursif hanya akan gagal untuk testcase yang lebih besar karena stack overflow. Mungkin saya perlu beberapa lingkungan default ke mode ketat untuk membuatnya bekerja.
tsh
2
Cukup adil, tetapi program Anda tidak harus menyelesaikan kasus uji yang lebih besar (yang saya pikir merupakan aturan standar, toh).
Arnauld
4

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!

Perwujudan Ketidaktahuan
sumber
3

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

Tau
sumber
3

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!

Olivier Grégoire
sumber
Aturan mengatakanYour 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 Apakah itu berarti saya tidak bisa menggunakan Java intsama sekali, tetapi lebih dari itu BigInteger? Karena Java memiliki BigIntegers, tetapi tidak akan pernah memiliki intyang lebih dari 31 bit seperti yang ditandatangani, yang tidak dapat memiliki nilai selain yang diwakili di sini ...
Olivier Grégoire
tidak, tetapi jika program tetap bekerja jika intjenisnya tidak terikat
Jo King
1
@JoKing Ok, saya beralih dua solusi lagi untuk melakukan perhitungan terlebih dahulu.
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

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

Fayti1703
sumber
1
Saya menggunakan perakitan makro jadi saya tidak tahu pasti tetapi komentar "; pembagi> nomor masukan" bagi saya akan menjadi "; pembagi> = nomor masukan"
RosLuP
Majelis memiliki operasi yang mudah, seseorang dapat mengurangi panjang instruksi, menempatkan semua dalam satu baris, menggunakan indentasi dan komentar setiap 10 20 instruksi asm ....
RosLuP
@ RosLuP Saya sudah memperbaiki komentar dalam kode (terima kasih), tapi saya tidak tahu apa yang Anda maksud dengan komentar kedua Anda.
Fayti1703
3

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
Jonathan Allan
sumber
2

CJam , 17 byte

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

Cobalah online!

Buah Esolanging
sumber
2

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!

vityavv
sumber
2

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
Emigna
sumber
2

Powershell, 46 byte, 43 byte

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

Cobalah secara Online!

Edit: -3 byte terima kasih kepada @AdmBorkBork

J. Bergmann
sumber
43 byte dengan menggulirkan akumulator ke dalam loop dan memeriksa 2*$iuntuk menghilangkan subtract-one parens.
AdmBorkBork
2

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.

Marcos
sumber
1
41 byte
tsh
2
"Output dapat berupa dua nilai yang berbeda dan konsisten melalui format output apa pun yang diizinkan." Anda tidak mengembalikan dua nilai berbeda.
Olivier Grégoire
2
@ OlivierGrégoire Untungnya itu dapat segera diperbaiki dengan mengganti ruang dengan tanda seru!
Neil
1
@Neil Lebih baik lagi, ini bisa diperbaiki dengan n=!s;bukannya return!s;menyimpan 5 byte.
@ OlivierGrégoire ahh, saya lupa saat itu. Juga, perbarui dengan kode yang ditingkatkan. Saya mencoba sesuatu yang serupa, tetapi idiot saya adalah saya s=syang lebih mungkin dioptimalkan.
Marcos
2

Smalltalk, 34 byte

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

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
reffu
sumber
2

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.

JPeroutek
sumber
Beberapa golf untuk Anda - q0dapat diganti dengan !, dan SQmenghasilkan rentang [1-Q], sehingga rentang tersebut [1-Q)dapat dihasilkan menggunakan StQ. Karena Qs sekarang di akhir program, keduanya dapat dihilangkan. Versi lemah, 9 byte -qsf!%QTSt
Sok
1

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.

Neil
sumber
1

Arang , 13 byte

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

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

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
Neil
sumber
1

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
Sok
sumber
1

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.

Neil
sumber
1

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!

Benjamin Urquhart
sumber
1

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