Задний план:

Текущая задача «Совершенные числа» довольно ошибочна и сложна, поскольку она требует, чтобы вы выводили в сложном формате, включающем факторы числа. Это сугубо решение проблемы с перепостом задачи.

Вызов

Учитывая положительное целое число в любом стандартном формате ввода , различайте, является ли оно идеальным или нет.

Совершенное число - это число, равное сумме всех его собственных делителей (его положительных делителей меньше, чем самого себя). Например, - идеальное число, поскольку его делители равны , что в сумме составляет , а - не идеальное число, поскольку его делители ( ) суммируют до , а не .$6$$1,2,3$$6$$12$$1,2,3,4,6$$16$$12$

Тестовые случаи:

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

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

правила

• Ваша программа не должна выполнять большие тестовые случаи, если есть ограничения памяти или времени, но она должна быть теоретически способна, если бы ей дали больше памяти / времени.
• Выходными данными могут быть два разных и непротиворечивых значения в любом допустимом выходном формате . Если сразу неясно, что представляет собой Совершенство / Несовершенство, обязательно укажите в своем ответе.

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

fk+?

Попробуйте онлайн!

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

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

Нейм , 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.

R , 33 29 байт

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

Попробуйте онлайн!

Возвращает TRUEза идеальные числа и FALSEза несовершенные.

Желе , 3 байта

Æṣ=

Попробуйте онлайн!

Japt -! , 4 байта

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

По какой-то причине ¦не работает на TIO, поэтому мне нужно использовать -!флаг и ¥вместо

Попробуйте онлайн!

Python 3 , 46 байт

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

Попробуйте онлайн!

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

Python , 45 байт

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

Trueдля идеального; Falseдля других (переключите это с помощью ==-> !=)

Попробуйте онлайн!

 44 42  41 байт (-2 благодаря ovs), если мы можем вывести, используя «истинный против фальси»:

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

(falsey ( 0)) для идеального; истинный (ненулевое целое) в противном случае

Октава , 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

JavaScript, 38 байт

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

Попробуйте онлайн!

(Тайм-аут последнего теста на TIO.)

C # (интерактивный компилятор Visual C #) , 46 байт

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

Возвращает 0, если идеально, в противном случае возвращает положительное число. Я не знаю, допускается ли вывод различных типов целых чисел вместо двух разных значений истина и ложь, и я не смог найти никакого обсуждения мета об этом. Если это неверно, я удалю его.

Попробуйте онлайн!

C # (интерактивный компилятор Visual C #) , 49 47 байт

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

Попробуйте онлайн!

Рубин , 33 байта

->n{(1...n).sum{|i|n%i<1?i:0}==n}

Попробуйте онлайн!

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 байта

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

Попробуйте онлайн!

Сборка 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течение несовершенной.

РЕДАКТИРОВАТЬ : Уменьшено количество байтов на два путем замены MOV EAX, $1на XOR EAX, EAXиINC EAX

Лабиринт , 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выводится 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]]

Следующая инструкция, " - no-op, но у нас есть три соседние инструкции, поэтому мы выполняем ветвление в соответствии со значением в верхней части 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

CJam , 17 байт

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

Попробуйте онлайн!

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

Спасибо Джо Кингу за улучшение!

05AB1E , 4 байта

ѨOQ

Попробуйте онлайн!

объяснение

  O    # the sum
Ñ      # of the divisors of the input
 ¨     # with the last one removed
   Q   # equals the input

Powershell, 46 байт, 43 байта

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

Попробуйте онлайн!

Изменить: -3 байта благодаря @AdmBorkBork

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

Дайте мне знать, если этот провал в последнем случае является проблемой.

Smalltalk, 34 байта

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

Forth (gforth) , 45 байтов

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

Попробуйте онлайн!

объяснение

Перебирает каждое число от 1 до n-1, суммируя все значения, которые делят n идеально. Возвращает true, если сумма равна 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

Pyth , 9 13 байт

qsf!%QTSt

Попробуйте онлайн!

Спасибо комментаторам за помощь в гольфе

Находит все факторы ввода, суммирует их и сравнивает с исходным вводом.

Пакет, 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себя в цикл.

Древесный уголь , 13 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Выходы -для идеальных чисел. Использует грубую силу. Объяснение:

Ｎθ              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

Wolfram Language (Mathematica) , 14 байтов

PerfectNumberQ

Попробуйте онлайн!

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

Сетчатка 0.8.2 , 44 байта

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

Попробуйте онлайн! Использует грубую силу, поэтому ссылка включает только более быстрые тестовые случаи. Объяснение:

.+
$*

Преобразовать в одинарный.

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

Соответствуйте всем факторам ввода. При этом используется режим перекрытия, который в Retina 0.8.2 требует, чтобы все совпадения начинались на разных позициях, поэтому совпадения фактически возвращаются в порядке убывания, начиная с исходного ввода.

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

Вычтите соответствующие факторы из входных данных.

^¶+$

Проверьте, равен ли результат нулю.

Java 8, 66 байт

Кто-то должен использовать потоковый API в какой-то момент, даже если есть более короткий способ сделать это

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

Попробуйте онлайн!

cQuents , 8 байтов

?#N=U\zN

Попробуйте онлайн!

объяснение

?           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