Tôi không đủ tốt cho bạn?


29

Lý lịch:

Thử thách Perfect Numbers hiện tại khá thiếu sót và phức tạp, vì nó yêu cầu bạn xuất ra ở định dạng phức tạp liên quan đến các yếu tố của số. Đây là một hoàn toàn repost của thách thức.

Thử thách

Cho một số nguyên dương thông qua bất kỳ định dạng đầu vào tiêu chuẩn nào , hãy phân biệt xem nó có hoàn hảo hay không.

Một số hoàn hảo là một số bằng tổng của tất cả các ước số đúng của nó (các ước số dương của nó nhỏ hơn chính nó). Ví dụ: là một số hoàn hảo, vì các ước của nó là , tổng của nó là , trong khi không phải là một số hoàn hảo vì các ước của nó ( ) có tổng bằng , không phải .61,2,36121,2,3,4,61612

Các trường hợp thử nghiệm:

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

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

Quy tắc

  • Chương trình của bạn không phải hoàn thành các trường hợp thử nghiệm lớn hơn, nếu có hạn chế về bộ nhớ hoặc thời gian, nhưng về mặt lý thuyết thì nó có thể nếu nó được cung cấp thêm bộ nhớ / thời gian.
  • Đầu ra có thể là hai giá trị riêng biệt và nhất quán thông qua bất kỳ định dạng đầu ra được phép nào . Nếu không rõ ràng ngay lập tức những gì thể hiện Hoàn hảo / Không hoàn hảo, vui lòng đảm bảo chỉ định trong câu trả lời của bạn.

Đợi đã, sự thật là dành cho những giá trị không hoàn hảo, và falsey là dành cho những giá trị đó?
Esolanging Fruit

2
@ Tvde1 Các ước số thích hợp phải nhỏ hơn số, nếu không, không có số nào khác hơn 1là hoàn hảo, vì mọi số đều chia hết cho 1chính nó. Tổng các ước số thích hợp của 10
Jo King

3
@Grimy Chỉ khi bạn có thể chứng minh như vậy . Chúc may mắn! (mặc dù tôi đang tự hỏi làm thế nào để tiết kiệm byte)
Jo King

1
Vì vậy, không quá tệ. Nó sẽ cắt kích thước của câu trả lời regex ECMA theo hệ số khoảng 3.
Grimmy

3
"Đầu ra có thể là hai giá trị riêng biệt và nhất quán" - chúng ta có thể không sử dụng "Truthy vs falsey" ở đây không (ví dụ: Python sử dụng zero vs non zero; danh sách có nội dung so với danh sách trống; và kết hợp giữa chúng)?
Jonathan Allan

Câu trả lời:



9

Neim , 3 byte

𝐕𝐬𝔼

Hãy thử trực tuyến!

(Tôi thực sự không biết làm thế nào để chạy tất cả các trường hợp thử nghiệm cùng một lúc, vì tôi đã bắt đầu học Neim khoảng mười lăm phút trước, nhưng tôi đã kiểm tra chúng riêng lẻ.)

In 0 cho không hoàn hảo, 1 cho hoàn hảo.

𝐕      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
" Tôi đoán? "; " Hoặc một cái gì đó như thế. ". Khi bạn thậm chí không chắc chắn những gì bạn đã tự viết, haha. ;) Nhưng vâng, đó thực sự là cách nó hoạt động. Tôi không biết Neim, nhưng sử dụng đầu vào hoàn toàn như thế và hoàn toàn xuất hiện ở cuối, hoàn toàn tương tự trong 05AB1E.
Kevin Cruijssen

Làm thế nào là 𝔼1 byte? Có phải Neim chỉ sử dụng 128 ký tự không nổi bật như vậy?
kajacx

3
@kajacx Neim có trang mã riêng . Do đó, mỗi trong số 256 ký tự có trong bảng mã có thể được mã hóa bằng 1 byte.
Ông Xcoder

8

R , 33 29 byte

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

Hãy thử trực tuyến!

Trả về TRUEcho số hoàn hảo và FALSEcho những người không hoàn hảo.


Điều gì làm 2! S liên tiếp giúp bạn?
Hội trường CT

@CTHall Tôi đọc sai thông số kỹ thuật; ban đầu họ ánh xạ 0(hoàn hảo) đến FALSEvà khác không TRUEnhưng tôi đã xóa một trong số chúng để đảo ngược ánh xạ. Đó là một golf thủ thuật hữu ích để đúc ra khỏi numericđến logical, thường kết hợp với whichhoặc [.
Giuseppe


7

Japt -! , 4 byte

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

Vì một số lý do ¦không hoạt động trên tio nên tôi cần sử dụng -!cờ và ¥thay vào đó

Hãy thử trực tuyến!


Đó không phải là vấn đề TIO; Ukhông được tự động chèn trước đó !.
Shaggy

6

Python 3 , 46 byte

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

Hãy thử trực tuyến!

Lực lượng vũ phu, tổng hợp các yếu tố và kiểm tra sự bình đẳng.


2
Sử dụng điều kiện hiểu như một mặt nạ cho biến lặp của bạn sẽ tiết kiệm được một byte.
Jonathan Frech

Vì bạn có thể trả lại sự thật cho một số không hoàn hảo, lambda x:sum(i for i in range(1,x)if x%i<1)^xnên cũng hoạt động tốt.
nedla2004

5

Python , 45 byte

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

Truecho hoàn hảo; Falsecho những người khác (chuyển cái này với ==-> !=)

Hãy thử trực tuyến!

 44 42  41 byte (-2 nhờ vào ovs) nếu chúng ta có thể xuất ra bằng cách sử dụng "truey vs falsey":

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

(falsey ( 0)) cho hoàn hảo; sự thật (một số nguyên khác không)


Nếu định dạng đầu ra thứ hai là hợp lệ, điều này có thể được thực hiện trong 42 byte .
OVS

@ovs ah, làm tốt lắm.
Jonathan Allan

@ovs .. và một cái khác được lưu từ đó - cảm ơn!
Jonathan Allan

5

Octave , 25 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

(Hết thời gian thử nghiệm cuối cùng trên TIO.)


@Arnauld Chỉ cần quên xóa f=sau khi chuyển đổi từ một hàm đệ quy.
tsh

Chỉ tò mò, tại sao không đi với một phiên bản đệ quy? (Nó sẽ là 34 byte.)
Arnauld

@Arnauld vì phiên bản đệ quy đơn giản là thất bại đối với testcase lớn hơn do tràn ngăn xếp. Có lẽ tôi cần một số môi trường mặc định ở chế độ nghiêm ngặt để làm cho nó hoạt động.
tsh

2
Đủ công bằng, nhưng chương trình của bạn không phải hoàn thành các trường hợp thử nghiệm lớn hơn (dù sao tôi nghĩ đó là quy tắc mặc định).
Arnauld

4

C # (Trình biên dịch tương tác Visual C #) , 46 byte

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

Trả về 0 nếu hoàn hảo, nếu không thì trả về số dương. Tôi không biết nếu xuất ra các loại số nguyên khác nhau được cho phép thay cho hai giá trị trung thực và giả khác biệt và không thể tìm thấy bất kỳ cuộc thảo luận nào về meta về nó. Nếu điều này là không hợp lệ, tôi sẽ loại bỏ nó.

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 49 47 byte

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

Hãy thử trực tuyến!



3

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

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

Không hiệu quả khủng khiếp, nhưng nó hoạt động.
Việc giảm số lượng nhân viên đã tăng tốc chương trình lên rất nhiều.
Đầu vào là trong Ans.
Đầu ra nằm trong Ansvà được tự động in ra khi chương trình hoàn thành.

Giải thích:
(TI-BASIC không có nhận xét, vì vậy chỉ cần giả sử rằng ;đưa ra nhận xét)

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

Thí dụ:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Lưu ý: Số byte của chương trình được ước tính bằng giá trị trong [MEM] > [2] > [7] (36 byte) sau đó trừ đi độ dài của tên chương trình CDGF2, (5 byte) và thêm 8 byte được sử dụng cho lưu trữ chương trình:

36 - 5 - 8 = 23 byte


3

Java (JDK) , 54 byte

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

Hãy thử trực tuyến!

Mặc dù đối với một số nghiêm ngặt theo khớp số, phần sau sẽ trả về cùng các giá trị, nhưng chỉ có 40 byte.

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

Hãy thử trực tuyến!


Các quy tắc nóiYour 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 Điều đó có nghĩa là tôi hoàn toàn không thể sử dụng Java int, mà là một BigInteger? Bởi vì Java có BigIntegers, nhưng nó sẽ không bao giờ có inthơn 31 bit như đã ký, không thể giữ bất kỳ giá trị nào khác ngoài giá trị được biểu thị ở đây ...
Olivier Grégoire

không, nhưng nếu chương trình vẫn hoạt động nếu intloại không bị ràng buộc
Jo King

1
@JoKing Ok, tôi đã chuyển đổi hai giải pháp một lần nữa để có sự tính toán trước.
Olivier Grégoire

3

x86 hội, 45 43 byte.

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

Giải thích (Cú pháp của 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

Đầu vào nên được cung cấp trong EAX.
Bộ chức năng EAXđể 1hoàn hảo và 0không hoàn hảo.

EDIT : Giảm Byte-Count bằng hai bằng cách thay thế MOV EAX, $1bằng XOR EAX, EAXINC EAX


1
Tôi sử dụng một cụm macro để tôi không biết chắc chắn nhưng nhận xét "; số chia> số đầu vào" đối với tôi sẽ là "; số chia> = số đầu vào"
RosLuP

Hội có các thao tác dễ dàng, người ta có thể giảm thời lượng hướng dẫn đặt tất cả vào một dòng, sử dụng thụt lề và nhận xét cứ sau 10 20 lệnh asm ....
RosLuP

@RosLuP Tôi đã sửa nhận xét trong mã (cảm ơn), nhưng tôi không biết ý của bạn với nhận xét thứ hai của bạn.
Fayti1703

3

Mê cung , 80 byte

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

Các ký tự Latinh perfect puts zero else neg Ithực sự chỉ là ý kiến ​​*.
tức là nếu đầu vào hoàn hảo thì a 0được in, nếu không thì -1là.

Hãy thử trực tuyến!


* vì vậy cái này hay cái này cũng hoạt động ...

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

Làm sao?

Lấy đầu vào là một số nguyên dương nvà đặt biến tích lũy -nlên ngăn xếp phụ, sau đó thực hiện kiểm tra chia hết cho từng số nguyên từ n-1xuống, và bao gồm 1, thêm bất kỳ số nào chia ncho bộ tích. Một khi điều này hoàn thành nếu biến tích lũy khác không a -1là đầu ra, nếu không thì 0là.

Việc ?::`}:(này chỉ được thực hiện một lần, khi bắt đầu thực hiện:

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

Hướng dẫn tiếp theo ", là không có, nhưng chúng tôi có ba hướng dẫn lân cận để chúng tôi phân nhánh theo giá trị ở đầu Main, zero đưa chúng tôi về phía trước, trong khi khác không đưa chúng tôi đi đúng.

Nếu đầu vào là 1chúng tôi sẽ chuyển tiếp vì đỉnh của Main bằng 0:

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

Nhưng nếu đầu vào lớn hơn 1chúng ta rẽ phải vì đỉnh Main không khác không:

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

Tại thời điểm này, chúng tôi có một chi nhánh ba người hàng xóm, nhưng chúng tôi biết n-1là khác không, vì vậy chúng tôi rẽ phải ...

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

Chúng tôi đang ở một chi nhánh ba người hàng xóm khác tại %.

Nếu kết quả %là khác không, chúng ta sẽ đi bên trái để giảm số chia tiềm năng của mình p=p-1và rời khỏi bộ tích lũy a, như sau:

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

... nhưng nếu kết quả %bằng 0 (chỉ cho lần đầu tiên khi n=2chúng ta đi thẳng vào BÓNG, hãy thêm số chia vào bộ tích lũy của chúng tôi a=a+p, VÀ làm giảm ước số tiềm năng của chúng tôi , 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]]

Tại thời điểm này nếu p-1vẫn là khác không, chúng ta rẽ trái:

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

... nhưng nếu p-1đạt 0, chúng ta sẽ đi thẳng lên :dòng thứ hai của mê cung (bạn đã xem tất cả các hướng dẫn trước đó, vì vậy tôi sẽ bỏ các mô tả của họ ra và chỉ đưa ra hiệu ứng của chúng):

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

Bây giờ điều này {có ba hướng dẫn lân cận, vì vậy ...

... Nếu alà 0, nó sẽ là hoàn hảo n, thì chúng ta sẽ đi thẳng:

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

... nếu alà khác không, nó sẽ không hoàn hảo n, thì chúng ta rẽ trái:

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

Giải thích (mặc dù nó khá đơn giản)

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

Cảm ơn Jo King vì sự cải tiến!




2

C (gcc) , 41 byte

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

Hãy thử trực tuyến!

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

Hãy cho tôi biết nếu thất bại cho trường hợp cuối cùng là một vấn đề.



2
"Đầu ra có thể là hai giá trị riêng biệt và nhất quán thông qua bất kỳ định dạng đầu ra được phép nào." Bạn không trả lại bất kỳ hai giá trị riêng biệt.
Olivier Grégoire

2
@ OlivierGrégoire May mắn thay, có thể dễ dàng sửa chữa bằng cách thay thế dấu cách bằng dấu chấm than!
Neil

1
@Neil Tốt hơn nữa, nó có thể được sửa bằng n=!s;thay vì return!s;để lưu 5 byte.

@ OlivierGrégoire ahh, tôi quên điểm đó. Ngoài ra, cập nhật với các mã được cải thiện. Tôi đã thử một cái gì đó tương tự, nhưng tôi là thằng ngốc tôi đã làm s=sđiều đó nhiều khả năng đã được tối ưu hóa.
Marcos


2

Forth (gforth) , 45 byte

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

Hãy thử trực tuyến!

Giải trình

Vòng lặp trên mỗi số từ 1 đến n-1, tổng hợp tất cả các giá trị chia n hoàn hảo. Trả về true nếu tổng bằng n

Giải thích mã

: 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

Bình thường , 9 13 byte

qsf!%QTSt

Hãy thử trực tuyến!

Cảm ơn các bình luận viên đã giúp đỡ golf

Tìm tất cả các yếu tố của đầu vào, tính tổng chúng và so sánh với đầu vào ban đầu.


Một vài sân gôn cho bạn - q0có thể được thay thế bằng !SQtạo ra phạm vi [1-Q], vì vậy phạm vi [1-Q)có thể được tạo bằng cách sử dụng StQ. Vì Qhiện tại đang ở cuối chương trình, cả hai có thể được bỏ qua. Phiên bản Fettled, 9 byte -qsf!%QTSt
Sok

1

Mẻ, 81 byte

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

Lấy nlàm tham số dòng lệnh và xuất ra 1nếu đó là một số hoàn hảo. Phương pháp Brute force, bắt đầu tổng tại -nđể nó có thể bao gồm nchính nó trong vòng lặp.


1

Than , 13 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu ra -cho số hoàn hảo. Sử dụng vũ lực. Giải trình:

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

Bình thường, 8 byte

qs{*MPyP

Hãy thử trực tuyến tại đây .

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

Võng mạc 0.8.2 , 44 byte

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

Hãy thử trực tuyến! Sử dụng lực lượng vũ phu, vì vậy liên kết chỉ bao gồm các trường hợp thử nghiệm nhanh hơn. Giải trình:

.+
$*

Chuyển đổi sang unary.

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

Phù hợp với tất cả các yếu tố của đầu vào. Điều này sử dụng chế độ chồng lấp, trong Retina 0.8.2 yêu cầu tất cả các trận đấu bắt đầu ở các vị trí khác nhau, do đó, các trận đấu thực sự được trả về theo thứ tự giảm dần, bắt đầu với đầu vào ban đầu.

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

Trừ các yếu tố thích hợp từ đầu vào.

^¶+$

Kiểm tra xem kết quả có bằng không.


1

Java 8, 66 byte


Ai đó phải sử dụng API luồng tại một số điểm, ngay cả khi có cách ngắn hơn để làm điều đó

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

Hãy thử trực tuyến!


1

cQuents , 8 byte

?#N=U\zN

Hãy thử trực tuyến!

Giải trình

?           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
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.