Czy nie jest dla Ciebie wystarczająco dobry?


29

Tło:

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

Wyzwanie

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

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

Przypadki testowe:

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

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

Zasady

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

Czekaj, więc prawda jest dla wartości, które nie są idealne, a falsey dla wartości, które są?
Esolanging Fruit

2
@ Tvde1 Właściwe dzielniki muszą być mniejsze niż liczba, w przeciwnym razie żadna inna liczba nie 1byłaby idealna, ponieważ każda liczba jest podzielna 1sama z siebie. Suma właściwych dzielników 1wynosi0
Jo King

3
@Grimy Tylko jeśli możesz to udowodnić . Powodzenia! (choć zastanawiam się, jak to by zaoszczędziło bajty)
Jo King

1
Więc nie, szkoda.
Zmniejszyłoby

3
„Dane wyjściowe mogą być dwiema odrębnymi i spójnymi wartościami” - czy nie możemy tutaj użyć „prawda vs falsey” (np. Dla Pythona używającego zera vs zera; lista z treścią a pustą listą oraz ich kombinacje)?
Jonathan Allan

Odpowiedzi:



9

Neim , 3 bajty

𝐕𝐬𝔼

Wypróbuj online!

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

Drukuje 0 za niedoskonałe, 1 za idealne.

𝐕      Pop an int from the stack and push its proper divisors,
       implicitly reading the int from a line of input as the otherwise absent top of the stack.
 𝐬     Pop a list from the stack and push the sum of the values it contains.
  𝔼    Pop two ints from the stack and push 1 if they are equal, 0 if they are not;
       implicitly reading the same line of input that was already read as the second int, I guess?
       Implicitly print the contents of the stack, or something like that.

2
Chyba? ”; „ lub coś takiego. ”. Kiedy nawet nie jesteś pewien, co sam napisałeś, haha. ;) Ale tak, tak właśnie działa. Nie znam Neima, ale użycie danych wejściowych niejawnie w ten sposób i niejawnego wyjścia na końcu jest podobne w 05AB1E.
Kevin Cruijssen

Jak jest 𝔼1 bajt? Czy Neim używa tylko 128 takich niestandardowych znaków?
kajacx

3
@kajacx Neim ma własną stronę kodową . Dlatego każdy z 256 znaków obecnych na stronie kodowej można zakodować za pomocą 1 bajtu.
Pan Xcoder

8

R , 33 29 bajtów

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

Wypróbuj online!

Zwraca TRUEliczby idealne i FALSEniedoskonałe.


Co ci daje 2! S z rzędu?
CT Hall

@CTHall Źle odczytałem specyfikację; pierwotnie zamapowali 0(idealny) FALSEi niezerowy, TRUEale usunąłem jeden z nich, aby odwrócić odwzorowanie. Jest to przydatne do golfa sztuczka z obsadą numericdo logical, często w połączeniu z whichlub [.
Giuseppe


7

Japt -! , 4 bajty

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

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

Wypróbuj online!


To nie jest problem TIO; Unie jest wcześniej automatycznie wstawiany !.
Shaggy

6

Python 3 , 46 bajtów

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

Wypróbuj online!

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


2
Użycie warunku zrozumienia jako maski dla zmiennej iteracyjnej pozwoliłoby zaoszczędzić bajt.
Jonathan Frech,

Ponieważ możesz zwrócić prawdę za niedokładną liczbę, lambda x:sum(i for i in range(1,x)if x%i<1)^xpowinno również działać.
nedla2004

5

Python , 45 bajtów

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

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

Wypróbuj online!

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

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

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


Jeśli drugi format wyjściowy jest prawidłowy, można to zrobić w 42 bajtach .
ovs

@ovs ah, ładnie wykonane.
Jonathan Allan

@ovs .. i kolejny zapisany z tego - dzięki!
Jonathan Allan

5

Oktawa , 25 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

@(n)                        % Define anonymous function with input n
             1:n            % Row vector [1,2,...,n]
           t=               % Store in variable t
     mod(n,     )           % n modulo [1,2,...,n], element-wise. Gives 0 for divisors
    ~                       % Logical negate. Gives 1 for divisors
                  t'        % t transposed. Gives column vector [1;2;...;n]
                 *          % Matrix multiply
                      2*n   % Input times 2
                    ==      % Equal? This is the output value

4

JavaScript, 38 bajtów

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

Wypróbuj online!

(Limit czasu ostatniej próby w TIO.)


@Arnauld Po prostu zapomniałem usunąć f=po konwersji z funkcji rekurencyjnej.
tsh

Z ciekawości, dlaczego nie wybrać wersji rekurencyjnej? (To by było 34 bajty.)
Arnauld

@Arnauld, ponieważ wersja rekurencyjna po prostu zawiodła dla większej skrzynki testowej z powodu przepełnienia stosu. Może potrzebuję niektórych środowisk domyślnie do trybu ścisłego, aby działał.
tsh

2
W porządku, ale twój program nie musi wypełniać większych przypadków testowych (co moim zdaniem jest domyślną regułą).
Arnauld

4

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

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

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

Wypróbuj online!

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

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

Wypróbuj online!



3

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

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

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

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

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

 2Ans                                               ;double the input
          seq(                                      ;generate a list
                                         X,          ;using the variable X,
                                           1,        ;starting at 1,
                                             Ans     ;and ending at the input
                                                     ;with an implied increment of 1
              Ans/X                                 ;from the input divided by X
                   not(                ),           ;multiplied by the negated result of
                       remainder(Ans,X)              ;the input modulo X
                                                     ;(result: 0 or 1)
      sum(                                          ;sum up the elements in the list
     =                                              ;equal?

Przykład:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

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

36 - 5 - 8 = 23 bajty


3

Java (JDK) , 54 bajty

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

Wypróbuj online!

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

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

Wypróbuj online!


Zasady mówią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

@JoKing Czy to oznacza, że ​​nie mogę w ogóle używać Javy int, a raczej BigInteger? Ponieważ Java ma BigIntegers, ale nigdy nie będzie miała intwięcej niż 31 bitów zgodnie z podpisem, które nie mogą mieć żadnej innej wartości niż te tutaj reprezentowane ...
Olivier Grégoire

nie, ale jeśli program powinien nadal działać, jeśli inttyp był nieograniczony
Jo King

1
@JoKing Ok, zmieniłem ponownie dwa rozwiązania, aby najpierw wykonać obliczenia.
Olivier Grégoire

3

Montaż x86, 45 43 bajtów.

6A 00 31 C9 31 D2 41 39  C1 7D 0B 50 F7 F9 58 85
D2 75 F1 51 EB EE 31 D2  59 01 CA 85 C9 75 F9 39
D0 75 05 31 C0 40 EB 02  31 C0 C3

Wyjaśnienie (składnia Intel):

PUSH $0          ; Terminator for later
XOR ECX, ECX        ; Clear ECX
.factor:
    XOR EDX, EDX    ; Clear EDX
    INC ECX
    CMP ECX, EAX    ; divisor >= input number?
    JGE .factordone ; if so, exit loop.
    PUSH EAX        ; backup EAX
    IDIV ECX        ; divide EDX:EAX by ECX, store result in EAX and remainder in EDX
    POP EAX         ; restore EAX
    TEST EDX, EDX   ; remainder == 0?
    JNZ .factor     ; if not, jump back to loop start
    PUSH ECX        ; push factor
    JMP .factor     ; jump back to loop start
.factordone:
XOR EDX, EDX        ; clear EDX
.sum:
    POP ECX         ; pop divisor
    ADD EDX, ECX    ; sum into EDX
    TEST ECX, ECX   ; divisor == 0?
    JNZ .sum        ; if not, loop.
CMP EAX, EDX        ; input number == sum?
JNE .noteq          ; if not, skip to .noteq
    XOR EAX, EAX    ; clear EAX
    INC EAX         ; increment EAX (sets to 1)
JMP .return         ; skip to .return
.noteq:
    XOR EAX, EAX    ; clear EAX
.return:
RETN

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

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


1
Używam zestawu makr, więc nie wiem na pewno, ale komentarz „; dzielnik> numer wejściowy” dla mnie to „; dzielnik> = numer wejściowy”
RosLuP

Montaż jest łatwy w obsłudze, można zmniejszyć długość instrukcji, umieszcza wszystko w linii, używać wcięć i komentować co 10 20 instrukcji asm ....
RosLuP

@RosLuP Naprawiłem komentarz w kodzie (dzięki), ale nie wiem, co masz na myśli przez swój drugi komentarz.
Fayti1703

3

Labirynt , 80 bajtów

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

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

Wypróbuj online!


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

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

W jaki sposób?

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

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

?::`}:(                                                      Main,Aux
?       - take an integer from STDIN and place it onto Main  [[n],[]]
 :      - duplicate top of Main                            [[n,n],[]]
  :     - duplicate top of Main                          [[n,n,n],[]]
   `    - negate top of Main                            [[n,n,-n],[]]
    }   - place top of Main onto Aux                       [[n,n],[-n]]
     :  - duplicate top of Main                          [[n,n,n],[-n]]
      ( - decrement top of Main                        [[n,n,n-1],[-n]]

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

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

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

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

:}                                                           Main,Aux
:  - duplicate top of Main                         [[n,n,n-1,n-1],[-n]]
 } - place top of Main onto Aux                        [[n,n,n-1],[-n,n-1]]

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

"%                                                           Main,Aux
"  - no-op                                             [[n,n,n-1],[-n,n-1]]
 % - place modulo result onto Main                   [[n,n%(n-1)],[-n,n-1]]
   - ...i.e we've got our first divisibility indicator n%(n-1), an
   -    accumulator, a=-n, and our potential divisor p=n-1:
   -                                                 [[n,n%(n-1)],[a,p]]

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

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

;:{(:""}"                                                    Main,Aux
;          - drop top of Main                                [[n],[a,p]]
 :         - duplicate top of Main                         [[n,n],[a,p]]
  {        - place top of Aux onto Main                  [[n,n,p],[a]]
           - three-neighbour branch but n-1 is non-zero so we turn left
   (       - decrement top of Main                     [[n,n,p-1],[a]]
    :      - duplicate top of Main                 [[n,n,p-1,p-1],[a]]
     ""    - no-ops                                [[n,n,p-1,p-1],[a]]
       }   - place top of Main onto Aux                [[n,n,p-1],[a,p-1]]
        "  - no-op                                     [[n,n,p-1],[a,p-1]]
         % - place modulo result onto Main           [[n,n%(p-1)],[a,p-1]]
           - ...and we branch again according to the divisibility
           -    of n by our new potential divisor, p-1

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

;:{:{+}}""""""""{(:""}                                       Main,Aux
;                      - drop top of Main                    [[n],[a,p]]
 :                     - duplicate top of Main             [[n,n],[a,p]]
  {                    - place top of Aux onto Main      [[n,n,p],[a]]
   :                   - duplicate top of Main         [[n,n,p,p],[a]]
    {                  - place top of Aux onto Main  [[n,n,p,p,a],[]]
     +                 - perform addition            [[n,n,p,a+p],[]]
      }                - place top of Main onto Aux      [[n,n,p],[a+p]]
       }               - place top of Main onto Aux        [[n,n],[a+p,p]]
        """""""        - no-ops                            [[n,n],[a+p,p]]
                       - a branch, but n is non-zero so we turn left
               "       - no-op                             [[n,n],[a+p,p]]
                {      - place top of Aux onto Main      [[n,n,p],[a+p]]
                       - we branch, but p is non-zero so we turn right
                 (     - decrement top of Main         [[n,n,p-1],[a+p]]
                  :    - duplicate top of Main     [[n,n,p-1,p-1],[a+p]]
                   ""  - no-ops                    [[n,n,p-1,p-1],[a+p]]
                     } - place top of Main onto Aux    [[n,n,p-1],[a+p,p-1]]

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

"%                                                           Main,Aux
"  - no-op                                             [[n,n,p-1],[a+p,p-1]]
 % - modulo                                          [[n,n%(p-1)],[a+p,p-1]]
   - ...and we branch again according to the divisibility
   -    of n by our new potential divisor, p-1

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

:":}"":({):""}"%;:{:{+}}"""""""{{{                           Main,Aux
:                                  -                   [[n,n,0,0],[a,0]]
 "                                 -                   [[n,n,0,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
  :                                -                 [[n,n,0,0,0],[a,0]]
   }                               -                   [[n,n,0,0],[a,0,0]]
                                   - top of Main is zero so we go straight
    ""                             -                   [[n,n,0,0],[a,0,0]]
      :                            -                 [[n,n,0,0,0],[a,0,0]]
       (                           -                [[n,n,0,0,-1],[a,0,0]]
        {                          -              [[n,n,0,0,-1,0],[a,0]]
                                   - top of Main is zero so we go straight
                                   -  ...but we hit the wall and so turn around
         (                         -             [[n,n,0,0,-1,-1],[a,0]]
          :                        -          [[n,n,0,0,-1,-1,-1],[a,0]]
           ""                      -          [[n,n,0,0,-1,-1,-1],[a,0]]
             }                     -             [[n,n,0,0,-1,-1],[a,0,-1]]
                                   - top of Main is non-zero so we turn left
              "                    -             [[n,n,0,0,-1,-1],[a,0,-1]]
               %                   - (-1)%(-1)=0     [[n,n,0,0,0],[a,0,-1]]
                ;                  -                   [[n,n,0,0],[a,0,-1]]
                 :                 -                 [[n,n,0,0,0],[a,0,-1]]
                  {                -              [[n,n,0,0,0,-1],[a,0]]
                   :               -           [[n,n,0,0,0,-1,-1],[a,0]]
                    {              -         [[n,n,0,0,0,-1,-1,0],[a]]
                     +             -           [[n,n,0,0,0,-1,-1],[a]]
                      }            -              [[n,n,0,0,0,-1],[a,-1]]
                       }           -                 [[n,n,0,0,0],[a,-1,-1]]
                        """""""    -                 [[n,n,0,0,0],[a,-1,-1]]
                                   - top of Main is zero so we go straight
                               {   -              [[n,n,0,0,0,-1],[a,-1]]
                                {  -           [[n,n,0,0,0,-1,-1],[a]]
                                 { -         [[n,n,0,0,0,-1,-1,a],[]]

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

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

"!@                                                          Main,Aux
"   -                                        [[n,n,0,0,0,-1,-1,a],[]]
    - top of Main is a, which is zero, so we go straight
 !  - print top of Main, which is a, which is a 0
  @ - exit the labyrinth

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

_~"!@                                                        Main,Aux
_     - place a zero onto Main             [[n,n,0,0,0,-1,-1,a,0],[]]
 ~    - bitwise NOT top of Main (=-1-x)   [[n,n,0,0,0,-1,-1,a,-1],[]]
  "   -                                   [[n,n,0,0,0,-1,-1,a,-1],[]]
      - top of Main is NEGATIVE so we turn left
   !  - print top of Main, which is -1
    @ - exit the labyrinth


2

JavaScript, 62

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

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

n=> //return function that takes n
  n== //and returns if n is equal to
    [...Array(n).keys()] //an array [0..(n-1)]...
      .filter(a=>n%a<1) //where all of the elements that are not divisors of n are taken out...
      .reduce((a,b)=>a+b) //summed up

Dzięki Jo King za ulepszenie!




2

C (gcc) , 41 bajtów

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

Wypróbuj online!

1: 0
12: 0
13: 0
18: 0
20: 0
1000: 0
33550335: 0
6: 1
28: 1
496: 1
8128: 1
33550336: 1
-65536: 0 <---- Unable to represent final test case with four bytes, fails

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



2
„Dane wyjściowe mogą mieć dwie różne i spójne wartości w dowolnym dozwolonym formacie wyjściowym.” Nie zwracasz żadnych dwóch różnych wartości.
Olivier Grégoire

2
@ OlivierGrégoire Na szczęście można to łatwo naprawić, zastępując spacje wykrzyknikiem!
Neil

1
@ Neil Jeszcze lepiej, można to naprawić za pomocą n=!s;zamiast return!s;zapisać 5 bajtów.

@ OlivierGrégoire ahh, zapomniałem o tym punkcie. Zaktualizowałem również ulepszony kod. Próbowałem czegoś podobnego, ale zrobiłem tego idiota, s=sktóry bardziej niż prawdopodobnie został zoptymalizowany.
Marcos


2

Dalej (gforth) , 45 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Wyjaśnienie kodu

: f                \ start word definition
  0 over 1         \ create a value to hold the sum and setup the bounds of the loop
  ?do              \ start a counted loop from 1 to n. (?do skips if start = end)
    over           \ copy n to the top of the stack
    i mod 0=       \ check if i divides n perfectly
    i * -          \ if so, use the fact that -1 = true in forth to add i to the sum
  loop             \ end the counted loop
  =                \ check if the sum and n are equal
;                  \ end the word definition

2

Pyth , 9 13 bajtów

qsf!%QTSt

Wypróbuj online!

Dziękuję komentatorom za pomoc w golfie

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


Kilka golfów dla Ciebie - q0można je zastąpić !i SQdaje zasięg [1-Q], dzięki czemu zasięg [1-Q)można wygenerować za pomocą StQ. Ponieważ Qs są już na końcu programu, oba można pominąć. Wersja Fettled, 9 bajtów -qsf!%QTSt
Sok

1

Partia, 81 bajtów

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

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


1

Węgiel drzewny , 13 bajtów

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

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

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

qs{*MPyP

Wypróbuj online tutaj .

qs{*MPyPQQ   Implicit: Q=eval(input())
             Trailing QQ inferred
       PQ    Prime factors of Q
      y      Powerset
     P       Remove last element - this will always be the full prime factorisation
   *M        Take product of each
  {          Deduplicate
 s           Sum
q        Q   Is the above equal to Q? Implicit print

1

Retina 0.8.2 , 44 bajty

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

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

.+
$*

Konwertuj na unary.

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

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

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

Odejmij odpowiednie dane wejściowe.

^¶+$

Sprawdź, czy wynik wynosi zero.


1

Java 8, 66 bajtów


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

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

Wypróbuj online!


1

cQuents , 8 bajtów

?#N=U\zN

Wypróbuj online!

Wyjaśnienie

?           Mode query: return whether or not input is in sequence
 #          Conditional: iterate N, add N to sequence if condition is true
  N=         Condition: N == 
    U    )                   sum(                  )
     \z )                        proper_divisors( )
       N                                         N
        ))    implicit
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.