Хіба я недостатньо хороший для вас?


29

Фон:

Поточний виклик Perfect Numbers є досить хибним і складним, оскільки він просить вивести в складному форматі, що включає фактори числа. Це суто щодо вирішення проблеми.

Виклик

Давши додатне ціле число через будь-який стандартний формат введення , розрізняйте, чи ідеальне воно чи ні.

Досконале число - це число, яке дорівнює сумі всіх належних дільників (його позитивних дільників менше, ніж самого себе). Наприклад, - це досконале число, оскільки його дільники - 1,2,3 , що дорівнює 6 , а 12 - не ідеальне число, оскільки його дільники ( 1,2,3,4,6 ) складають до 16 , а не 12 .61,2,36121,2,3,4,61612

Випробування:

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

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

Правила

  • Вашій програмі не доведеться виконувати більші тестові випадки, якщо є пам'ять або обмеження в часі, але теоретично вона повинна бути спроможна, якби їй було надано більше пам'яті / часу.
  • Вихід може бути двома чіткими та послідовними значеннями через будь-який дозволений формат виводу . Якщо не відразу зрозуміло, що являє собою Ідеальне / Недосконале, будь ласка, обов'язково вкажіть у своїй відповіді.

Зачекайте, значить, правда - це значення, які не є ідеальними, а фальси - для цінностей, які є?
Esolanging Fruit

2
@ Tvde1 Власні дільники повинні бути меншими за число, інакше жодне число, окрім як 1було б ідеальним, оскільки кожне число ділиться 1само собою. Сума власних дільників 1є0
Джо Кінг

3
@Grimy Тільки якщо ви можете це довести . Удачі! (хоча мені цікаво, як би це врятувало байтів)
Джо Кінг,

1
Так ні, занадто погано. Це дозволило б зменшити розмір відповіді на регулярний вираз ECMA в 3 рази
Гріммі

3
"Вихід може бути двома чіткими і послідовними значеннями" - чи не можемо ми тут використовувати "truthy vs falsey" (наприклад, для Python, що використовує нуль проти не нуля; список із вмістом проти порожнього списку; і їх комбінації)?
Джонатан Аллан

Відповіді:


16

Брахілог , 4 байти

fk+?

Спробуйте в Інтернеті!

Присудок домагається ідеальних вводів і не вдається для недосконалих входів, друку true.або, false.якщо вони виконуються як повноцінна програма (за винятком останнього тестового випадку, який займає TIO більше хвилини).

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

1
Мені подобається, як написано в коді fk: x
Ісмаель Мігель

9

Нейм , 3 байти

𝐕𝐬𝔼

Спробуйте в Інтернеті!

(Я насправді не знаю, як запустити всі тестові справи одразу, оскільки я почав вивчати Нейма близько п’ятнадцяти хвилин тому, але перевіряв їх окремо.)

Відбитки 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
" Гадаю? "; " чи щось подібне. ". Коли ти навіть не впевнений, що ти сам написав, ха-ха. ;) Але так, саме так воно і працює. Я не знаю Нейма, але використання вхідних даних неявно, як і виведення неявно в кінці неявно, схоже в 05AB1E.
Кевін Кройсейсен

Як 𝔼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 підряд?
КТ зал

@CTHall я неправильно прочитав специфікацію; вони спочатку відображалися 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не вставляється автоматично раніше !.
Кудлатий

6

Python 3 , 46 байт

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

Спробуйте в Інтернеті!

Груба сила, підсумовує фактори та перевіряє рівність.


2
Використання умови розуміння як маски для вашої змінної ітерації дозволить зберегти байт.
Джонатан Фрех

Оскільки ви можете повернути truthy за недосконале число, також lambda x:sum(i for i in range(1,x)if x%i<1)^xслід працювати.
nedla2004

5

Пітон , 45 байт

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

Trueдля ідеального; Falseдля інших (перемкніть це на ==-> !=)

Спробуйте в Інтернеті!

 44 42  41 байт (-2 завдяки овам), якщо ми можемо вивести, використовуючи "truthy vs falsey":

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

(falsey ( 0)) для ідеального; truthy (ненульове ціле число) в іншому випадку


Якщо другий вихідний формат дійсний, це можна зробити в 42 байтах .
ов

@ovs ах, прекрасно зроблено.
Джонатан Аллан

@ovs ..і ще одне врятоване від цього - дякую!
Джонатан Аллан

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

Щойно з цікавості, чому б не піти з рекурсивною версією? (Це було б 34 байти.)
Арнольд

@Arnauld, оскільки рекурсивна версія просто не вдалася до більшого тестового зразка через переповнення стека. Можливо, мені потрібні деякі середовища за замовчуванням для суворого режиму, щоб він працював.
tsh

2
Досить справедливо, але вашій програмі не доведеться завершувати більші тестові випадки (що, на мою думку, це правило за замовчуванням).
Арнольд

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

Жахливо неефективно, але це працює.
Скорочення кількості рахунків скоротило програму на багато.
Введення в 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

@JoKing Це означає, що я взагалі не можу використовувати Java int, а скоріше a BigInteger? Оскільки у Java є BigIntegers, але вона ніколи не матиме intбільше 31 біт, як підписано, який не може мати іншого значення, ніж представлені тут ...
Олів'є Грегоар

ні, але якщо програма все-таки працюватиме, якщо intтип був без обмежень
Jo King

1
@JoKing Гаразд, я знову переключив два рішення, щоб спочатку здійснити обчислення.
Олів'є Грегоар

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

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недосконале.

EDIT : Скорочення кількості байтів на два, замінивши MOV EAX, $1наXOR EAX, EAX іINC EAX


1
Я використовую збірку макросів, тому я не знаю точно, але коментар "; дільник> вхідний номер" для мене буде "; дільник> = номер введення"
RosLuP

Збірка - це легкі операції, можна зменшити довжину інструкцій, щоб все було в рядку, використовуйте відступи та коментуйте кожні 10 20 інструкцій щодо отримання ....
RosLuP

@RosLuP Я зафіксував коментар у коді (спасибі), але я не знаю, що ви маєте на увазі під своїм другим коментарем.
Fayti1703

3

Лабіринт , 80 байт

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

Латинські символи - perfect puts zero else neg Iце фактично лише коментарі *.
тобто, якщо введення ідеальне 0, друкується a , інакше -1є.

Спробуйте в Інтернеті!


* тож ця чи ця робота теж ...

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

Як?

Приймає як вхід додатне ціле число nі розміщує змінну акумулятора -nна допоміжному стеку, потім проводить тест на роздільність для кожного цілого числа від n-1вниз до, включаючи 1, додаючи будь-яке, що ділитьn до акумулятора. Як тільки це буде завершено, якщо змінна акумулятора не дорівнює нулю -1, виводиться a, інакше a 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]]

Наступна інструкція, " - не-оп, але у нас є три сусідні вказівки, тому ми розгалужуємося відповідно до значення у верхній частині Main, нуль веде нас уперед, тоді як не нульове - це нас право.

Якщо вхід був, 1ми йдемо вперед, тому що верхня частина Main дорівнює нулю:

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

Дякую Джо Кінгу за покращення!




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
"Вихід може бути двома чіткими і послідовними значеннями через будь-який дозволений формат виводу." Ви не повертаєте жодних двох різних значень.
Олів'є Грегоар

2
@ OlivierGrégoire На щастя, це можна легко виправити, замінивши пробіл знаком оклику!
Ніл

1
@Neil Ще краще, це можна виправити n=!s;замість того, return!s;щоб зберегти 5 байт.

@ OlivierGrégoire ах, я забув цю точку. Також оновлено код із покращеним кодом. Я спробував щось подібне, але я ідіот, який я зробив, s=sі більш ніж ймовірно оптимізувався.
Маркос


2

Четвертий (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

Спробуйте в Інтернеті!

Дякую коментарям за допомогу в гольфі

Знаходить усі фактори введення, підсумовує їх і порівнює їх з початковим входом.


Кілька гольфів для вас - q0можуть бути замінені !і SQвиробляють асортимент [1-Q], так що діапазон [1-Q)можна створити за допомогою StQ. Оскільки Qтепер в кінці програми s, вони можуть бути опущені. Невдала версія, 9 байт -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

Відняти відповідні коефіцієнти від вхідних даних.

^¶+$

Перевірте, чи є результат нульовим.



Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.