ฉันไม่ดีพอสำหรับคุณ


29

พื้นหลัง:

ปัจจุบัน ความท้าทายที่สมบูรณ์แบบตัวเลขค่อนข้างมีข้อบกพร่องและซับซ้อนเนื่องจากจะขอให้คุณส่งออกในรูปแบบที่ซับซ้อนซึ่งเกี่ยวข้องกับปัจจัยของตัวเลข นี่คือrepost อย่างหมดจดของความท้าทาย

ท้าทาย

กำหนดจำนวนเต็มบวกให้กับค่าใด ๆ รูปแบบอินพุตมาตรฐานให้แยกความแตกต่างระหว่างว่าสมบูรณ์หรือไม่

ตัวเลขที่สมบูรณ์แบบคือตัวเลขที่เท่ากับผลรวมของตัวหารที่เหมาะสมทั้งหมด (ตัวหารที่เป็นบวกน้อยกว่าของตัวเอง) ตัวอย่างเช่น6เป็นตัวเลขที่สมบูรณ์แบบเนื่องจากตัวหารคือ1,2,3ซึ่งรวมกันได้ถึง6ในขณะที่12ไม่ใช่ตัวเลขที่สมบูรณ์แบบตั้งแต่ตัวหาร ( 1,2,3,4,6 ) รวมได้ถึง16ไม่ได้1212

กรณีทดสอบ:

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

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

กฎระเบียบ

  • โปรแกรมของคุณไม่จำเป็นต้องใช้กรณีทดสอบขนาดใหญ่จนเสร็จสมบูรณ์หากมีข้อ จำกัด ด้านหน่วยความจำหรือเวลา
  • เอาท์พุทสามารถเป็นสองค่าที่แตกต่างกันและสอดคล้องกันผ่านรูปแบบการออกที่ได้รับอนุญาต หากไม่ชัดเจนว่าอะไรคือสิ่งที่แสดงถึงความสมบูรณ์แบบ / ไม่สมบูรณ์โปรดระบุในคำตอบของคุณ

รอดังนั้นความจริงสำหรับค่าที่ไม่สมบูรณ์แบบและความเท็จสำหรับค่าที่เป็นอย่างไร
ผลไม้แยกแยะ

2
@ Tvde1 ตัวหารที่เหมาะสมต้องน้อยกว่าจำนวนมิฉะนั้นจะไม่มีเลขอื่นใดนอกจาก1จะสมบูรณ์แบบเนื่องจากทุกตัวหารด้วย1ตัวมันเอง ผลรวมของตัวหารที่เหมาะสม1คือ0
Jo King

3
@Grimy เฉพาะในกรณีที่คุณสามารถพิสูจน์ได้ โชคดี! (แม้ว่าฉันจะสงสัยว่าจะประหยัดไบต์ได้อย่างไร)
Jo King

1
ดังนั้นไม่เลวร้ายเกินไป มันจะลดขนาดของคำตอบ regex ECMA โดยปัจจัยประมาณ 3
Grimmy

3
"เอาต์พุตอาจมีค่าที่แตกต่างกันและสอดคล้องกันสองค่า" - เราไม่สามารถใช้ "ความจริงเทียบกับความเท็จ" ได้ที่นี่ (เช่นสำหรับ Python ที่ใช้ศูนย์กับไม่ใช่ศูนย์รายการที่มีเนื้อหาเทียบกับรายการว่างเปล่าและชุดค่าผสม)
Jonathan Allan

คำตอบ:


16

Brachylogขนาด 4 ไบต์

fk+?

ลองออนไลน์!

เพรดิเคตสำเร็จสำหรับอินพุตที่สมบูรณ์และล้มเหลวสำหรับอินพุตไม่สมบูรณ์การพิมพ์true.หรือfalse.ถ้ารันเป็นโปรแกรมที่สมบูรณ์ (ยกเว้นในกรณีทดสอบล่าสุดซึ่งใช้เวลามากกว่าหนึ่งนาทีใน TIO)

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

1
ฉันชอบที่โค้ดบอกว่าfk: x
Ismael Miguel

9

Neim , 3 ไบต์

𝐕𝐬𝔼

ลองออนไลน์!

(จริง ๆ แล้วฉันไม่ทราบวิธีการเรียกใช้กรณีทดสอบทั้งหมดในครั้งเดียวเนื่องจากฉันเริ่มเรียนรู้ Neim ประมาณสิบห้านาทีที่แล้ว แต่ฉันตรวจสอบเป็นรายบุคคล)

พิมพ์ 0 สำหรับความไม่สมบูรณ์, 1 เพื่อความสมบูรณ์แบบ

𝐕      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
" ฉันเดา "; " หรืออะไรทำนองนั้น " เมื่อคุณไม่แน่ใจด้วยซ้ำว่าคุณเขียนอะไรเองฮ่าฮ่า ;) แต่ใช่ว่าเป็นวิธีการทำงาน ฉันไม่รู้จัก Neim แต่การใช้อินพุตโดยปริยายเช่นนั้น
Kevin Cruijssen

วิธีการคือ𝔼1 ไบต์? Neim ใช้อักขระที่ไม่ใช่รูปแบบดังกล่าวเพียง 128 ตัวหรือไม่
kajacx

3
@kajacx Neim มีของตัวเองหน้ารหัส ดังนั้นแต่ละอักขระ 256 ตัวที่มีอยู่ในเพจรหัสสามารถเข้ารหัสได้โดยใช้ 1 ไบต์
นาย Xcoder

8

R , 33 29 ไบต์

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

ลองออนไลน์!

ส่งคืนTRUEตัวเลขที่สมบูรณ์และFALSEสำหรับจำนวนที่ไม่สมบูรณ์


สิ่งที่ 2! s อยู่ในแถวทำให้คุณได้รับ?
CT Hall

@CTH ทุกอย่างฉันผิด spec; พวกเขาแมป0(สมบูรณ์แบบ) ถึงFALSEและไม่ใช่ศูนย์TRUEแต่ฉันลบหนึ่งในนั้นเพื่อย้อนกลับการแมป มันเป็นเคล็ดลับการเล่นกอล์ฟมีประโยชน์ในการหล่อจากnumericไปlogicalมักจะร่วมกับหรือwhich [
จูเซปเป้


7

Japt -! , 4 ไบต์

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

ด้วยเหตุผลบางอย่างใช้¦ไม่ได้กับ tio ดังนั้นฉันจึงจำเป็นต้องใช้การ-!ตั้งค่าสถานะและ¥แทน

ลองออนไลน์!


นั่นไม่ใช่ปัญหาของ TIO ไม่ได้รับอัตโนมัติแทรกไว้ก่อนU !
Shaggy

6

Python 3 , 46 ไบต์

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

ลองออนไลน์!

แรงเดรัจฉานสรุปปัจจัยและตรวจสอบความเท่าเทียมกัน


2
การใช้เงื่อนไขความเข้าใจเป็นมาสก์สำหรับตัวแปรการวนซ้ำของคุณจะบันทึกเป็นไบต์
Jonathan Frech

เนื่องจากคุณสามารถคืนความจริงตามจำนวนที่ไม่สมบูรณ์ได้lambda x:sum(i for i in range(1,x)if x%i<1)^xเช่นกัน
nedla2004

5

Pythonขนาด 45 ไบต์

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

Trueเพื่อความสมบูรณ์แบบ; Falseสำหรับผู้อื่น (เปลี่ยนเป็น==-> !=)

ลองออนไลน์!

 44 42  41 ไบต์ (-2 ขอบคุณ ovs) หากเราอาจส่งออกโดยใช้ "facty vs falsey":

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

(falsey ( 0)) เพื่อความสมบูรณ์แบบ; ความจริง (จำนวนเต็มไม่เป็นศูนย์) เป็นอย่างอื่น


หากรูปแบบการออกที่สองคือการที่ถูกต้องนี้สามารถทำได้ใน42 ไบต์
ovs

@ovs ah ทำได้ดีมาก
Jonathan Allan

@ovs .. และอีกบันทึกไว้จากที่ - ขอบคุณ!
Jonathan Allan

5

อ็อกเทฟ 25 ไบต์

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

ลองออนไลน์!

คำอธิบาย

@(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 ไบต์

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

ลองออนไลน์!

(การหมดเวลาทดสอบครั้งสุดท้ายของ TIO)


@Arnauld เพียงแค่ลืมที่จะลบf=หลังจากแปลงจากฟังก์ชั่นซ้ำ
tsh

Just out of curiosity, why not going with a recursive version? (It would be 34 bytes.)
Arnauld

@Arnauld because recursive version would simply failed for larger testcase due to stack overflow. Maybe I need some environments default to strict mode to make it work.
tsh

2
ยุติธรรมเพียงพอ แต่โปรแกรมของคุณไม่จำเป็นต้องทำกรณีทดสอบให้ใหญ่ขึ้น (ซึ่งฉันคิดว่าเป็นกฎเริ่มต้น)
Arnauld

4

C # (Visual C # Interactive Compiler) , 46 ไบต์

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

ส่งคืน 0 ถ้าสมบูรณ์มิฉะนั้นจะส่งกลับจำนวนบวก ฉันไม่ทราบว่าจะอนุญาตให้แสดงจำนวนเต็มชนิดต่าง ๆ แทนที่ค่าความจริงและค่าเท็จสองค่าและไม่พบการสนทนาเกี่ยวกับเมตาเกี่ยวกับมัน หากสิ่งนี้ไม่ถูกต้องฉันจะลบออก

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 49 47 ไบต์

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

ลองออนไลน์!



3

TI-BASIC (TI-84), 30 23 ไบต์

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

ไม่มีประสิทธิภาพอย่างน่ากลัว แต่มันได้ผล
การลด bytecount ทำให้โปรแกรมเร็วขึ้นมาก การป้อนข้อมูลที่อยู่ใน
เอาต์พุตอยู่ในและพิมพ์ออกมาโดยอัตโนมัติเมื่อโปรแกรมเสร็จสิ้นAns
Ans

คำอธิบาย:
(TI-BASIC ไม่มีความคิดเห็นดังนั้นเพียงถือว่า;เป็นความคิดเห็น)

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

ตัวอย่าง:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

หมายเหตุ: จำนวนไบต์ของโปรแกรมถูกประเมินโดยใช้ค่าใน[MEM] > [2] > [7] (36 ไบต์) จากนั้นลบความยาวของชื่อโปรแกรมCDGF2 (5 ไบต์) และ 8 ไบต์พิเศษสำหรับใช้ จัดเก็บโปรแกรม:

36 - 5 - 8 = 23 ไบต์


3

Java (JDK) , 54 ไบต์

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

ลองออนไลน์!

แม้ว่าจะเป็นตัวเลขที่เข้มงวดโดยการจับคู่ตัวเลขต่อไปนี้จะส่งคืนค่าเดียวกัน แต่มีเพียง 40 ไบต์

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

ลองออนไลน์!


กฎบอกว่าYour 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

@ โจกิ้งนั่นหมายความว่าฉันไม่สามารถใช้ Java intเลย แต่เป็นBigInteger? เพราะ Java มีBigIntegersแต่มันจะไม่เคยมีintที่มากกว่า 31 บิตลงนามซึ่งไม่สามารถเก็บค่าอื่น ๆ ที่นอกเหนือจากที่แสดงที่นี่ ...
โอลิเวียGrégoire

ไม่ แต่ถ้าโปรแกรมยังคงใช้งานได้หากintประเภทไม่ได้รับการ จำกัด
Jo King

1
@ โจกิ้งเอาล่ะฉันเปลี่ยนโซลูชั่นทั้งสองอีกครั้งเพื่อให้มีการคำนวณก่อน
Olivier Grégoire

3

สมัชชา x86, 45 43 ไบต์

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

คำอธิบาย (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

EAXการป้อนข้อมูลควรได้รับการจัดให้อยู่ใน
ฟังก์ชั่นตั้งค่าEAXให้1สมบูรณ์แบบและ0ไม่สมบูรณ์

แก้ไข : ลดจำนวนไบต์สองด้วยการแทนที่MOV EAX, $1ด้วยXOR EAX, EAXและINC EAX


1
ฉันใช้แอสเซมบลีแมโครดังนั้นฉันไม่รู้แน่ แต่ความคิดเห็น "; ตัวหาร> ใส่หมายเลข" สำหรับฉันจะเป็น "; ตัวหาร> = ใส่หมายเลข"
RosLuP

การประกอบมีการดำเนินการที่ง่ายใครสามารถลดความยาวของคำสั่งให้อยู่ในบรรทัดใช้การเยื้องและแสดงความคิดเห็นทุก ๆ 10 20 คำสั่ง asm ....
RosLuP

@RosLuP ฉันได้แก้ไขความคิดเห็นในโค้ด (ขอบคุณ) แต่ฉันไม่รู้ว่าคุณหมายถึงอะไรกับความคิดเห็นที่สองของคุณ
Fayti1703

3

เขาวงกต 80 ไบต์

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

perfect puts zero else neg Iแท้จริงแล้วตัวอักษรละตินเป็นเพียงความคิดเห็น *
เช่นถ้าป้อนข้อมูลได้อย่างสมบูรณ์แบบ0จะพิมพ์มิฉะนั้น-1จะเป็น

ลองออนไลน์!


* ดังนั้นสิ่งนี้หรืองานนี้ด้วย ...

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

อย่างไร?

ทำหน้าที่เป็นอินพุทจำนวนเต็มบวกnและวางตัวแปรสะสมของ-nลงบนสแต็คเสริมจากนั้นทำการทดสอบการหารสำหรับแต่ละจำนวนเต็มจากn-1ลงไปและรวมถึง1การเพิ่มใด ๆ ที่จะหารnกับตัวสะสม ครั้งนี้จะเสร็จสมบูรณ์หากตัวแปรสะสมไม่เป็นศูนย์-1เป็นเอาท์พุทมิฉะนั้น0เป็น

?::`}:(จะถูกดำเนินการเพียงครั้งเดียวที่จุดเริ่มต้นของการดำเนินการ:

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

คำสั่งถัดไป", เป็นแบบไม่มี op แต่เรามีคำสั่งใกล้เคียงสามคำดังนั้นเราจึงแยกสาขาตามค่าที่ด้านบนของ Main, zero นำเราไปข้างหน้า, ในขณะที่ non-zero พาเราไปทางขวา

หากอินพุตเป็น1เราไปข้างหน้าเพราะส่วนบนของหน้าหลักเป็นศูนย์:

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

แต่ถ้าอินพุตมากกว่าที่1เราเลี้ยวขวาเพราะด้านบนของ Main ไม่ใช่ศูนย์:

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

ณ จุดนี้เรามีสาขาสามเพื่อนบ้าน แต่เรารู้ว่าn-1ไม่ใช่ศูนย์ดังนั้นเราเลี้ยวขวา ...

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

%ขณะนี้เรามีอีกสาขาสามเพื่อนบ้านที่

หากผลลัพธ์%ไม่ใช่ศูนย์เราจะปล่อยให้ตัวหารที่มีศักยภาพของเราลดลงp=p-1และออกจากตัวสะสมaเนื่องจากเป็น:

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

... แต่ถ้าผลลัพธ์ของการ%เป็นศูนย์ (สำหรับการผ่านครั้งแรกเฉพาะเมื่อn=2) เราไปที่ทั้งสองเพิ่มตัวหารลงในตัวสะสมของเราa=a+pและลดตัวหารที่อาจเกิดขึ้นของเรา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]]

ณ จุดนี้หากp-1ยังคงไม่เป็นศูนย์เราเลี้ยวซ้าย:

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

... แต่ถ้าp-1กดศูนย์เราจะตรงไป:ที่บรรทัดที่สองของเขาวงกต (คุณเคยเห็นคำแนะนำทั้งหมดมาก่อนดังนั้นฉันจะทิ้งคำอธิบายไว้และให้ผล):

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

ตอนนี้{มีสามคำแนะนำเพื่อนบ้านดังนั้น ...

... ถ้าaเป็นศูนย์ซึ่งมันจะสมบูรณ์แบบnเราก็จะไปที่:

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

... หากaไม่ใช่ศูนย์ซึ่งจะไม่สมบูรณ์nเราจะเลี้ยวซ้าย:

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

คำอธิบาย (แม้ว่ามันจะค่อนข้างง่าย)

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

ขอบคุณJo Kingสำหรับการปรับปรุง!




2

C (gcc) , 41 ไบต์

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

ลองออนไลน์!

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

แจ้งให้เราทราบหากความล้มเหลวของคดีสุดท้ายเป็นปัญหา



2
"เอาต์พุตสามารถเป็นค่าที่แตกต่างและสอดคล้องกันสองค่าผ่านรูปแบบเอาต์พุตที่อนุญาต" คุณไม่ได้ส่งคืนค่าที่แตกต่างสองค่าใด ๆ
Olivier Grégoire

2
@ OlivierGrégoireโชคดีที่สามารถแก้ไขได้อย่างง่ายดายโดยแทนที่พื้นที่ด้วยเครื่องหมายอัศเจรีย์!
Neil

1
@ Neil ดีกว่า แต่ก็สามารถแก้ไขได้ด้วยn=!s;แทนที่จะreturn!s;บันทึก 5 ไบต์

@ OlivierGrégoireอ่าฉันลืมจุดนั้นไป ปรับปรุงด้วยรหัสที่ปรับปรุงแล้ว ฉันพยายามบางสิ่งบางอย่างที่คล้ายกัน แต่คนบ้าฉันฉันไม่s=sซึ่งกว่าจะได้รับการปรับให้เหมาะสมออก
Marcos


2

Forth (gforth) , 45 ไบต์

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

ลองออนไลน์!

คำอธิบาย

วนซ้ำทุกตัวเลขจาก 1 ถึง n-1 โดยรวมค่าทั้งหมดที่หาร n อย่างสมบูรณ์ ผลตอบแทนจริงถ้ารวมเท่ากับ n

รหัสคำอธิบาย

: 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ไบต์

qsf!%QTSt

ลองออนไลน์!

ขอบคุณผู้แสดงความคิดเห็นสำหรับความช่วยเหลือกอล์ฟ

ค้นหาปัจจัยทั้งหมดของอินพุตป้อนผลรวมและเปรียบเทียบกับอินพุตต้นฉบับ


Golfs ไม่กี่สำหรับคุณ - q0สามารถถูกแทนที่ด้วย!และSQผลิตช่วง[1-Q]ดังนั้นช่วงที่สามารถสร้างขึ้นโดยใช้[1-Q) StQเนื่องจากQs อยู่ในตอนท้ายของโปรแกรมจึงสามารถละเว้นได้ทั้งคู่ Fettled version, 9 bytes -qsf!%QTSt
Sok

1

แบตช์, 81 ไบต์

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

ใช้nเป็นพารามิเตอร์บรรทัดคำสั่งและส่งออก1ถ้าเป็นตัวเลขที่สมบูรณ์ วิธีเดรัจฉานบังคับเริ่มต้นผลรวมที่-nเพื่อให้สามารถรวมnตัวเองในวง


1

ถ่าน 13 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เอาต์พุต-สำหรับตัวเลขที่สมบูรณ์ ใช้กำลังดุร้าย คำอธิบาย:

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 ไบต์

qs{*MPyP

ลองออนไลน์ได้ที่นี่

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

เรติน่า 0.8.2 , 44 ไบต์

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

ลองออนไลน์! ใช้กำลังดุร้ายดังนั้นลิงก์จะรวมเฉพาะกรณีทดสอบที่เร็วกว่าเท่านั้น คำอธิบาย:

.+
$*

แปลงเป็นเอก

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

ตรงกับปัจจัยทั้งหมดของอินพุต วิธีนี้ใช้โหมดการทับซ้อนกันซึ่งใน Retina 0.8.2 ต้องตรงกันทั้งหมดเพื่อเริ่มต้นที่ตำแหน่งที่แตกต่างกันดังนั้นการแข่งขันจะกลับมาในลำดับถัดลงมาจริงเริ่มต้นด้วยการป้อนข้อมูลเดิม

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

ลบปัจจัยที่เหมาะสมออกจากอินพุต

^¶+$

ทดสอบว่าผลลัพธ์เป็นศูนย์หรือไม่



โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.