Fundo:

O desafio atual do Perfect Numbers é um tanto falho e complicado, pois solicita que você produza em um formato complexo que envolva os fatores do número. Este é um repost puramente do problema da decisão .

Desafio

Dado um número inteiro positivo através de qualquer formato de entrada padrão , faça uma distinção entre ser perfeito ou não.

Um número perfeito é um número que é igual à soma de todos os seus divisores adequados (seus divisores positivos menores que ele próprio). Por exemplo, é um número perfeito, pois seus divisores são , que somam , enquanto não é um número perfeito, pois seus divisores ( ) somam , não .$6$$1,2,3$$6$$12$$1,2,3,4,6$$16$$12$

Casos de teste:

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

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

Regras

• Seu programa não precisa concluir os casos de teste maiores, se houver restrições de memória ou tempo, mas, teoricamente, deve ser possível se receber mais memória / tempo.
• A saída pode ter dois valores distintos e consistentes em qualquer formato de saída permitido . Se não for imediatamente óbvio o que representa Perfeito / Imperfeito, certifique-se de especificar em sua resposta.

Braquilog , 4 bytes

fk+?

Experimente online!

O predicado consegue entradas perfeitas e falha em entradas imperfeitas, impressão true.ou false.se for executado como um programa completo (exceto no último caso de teste que leva mais de um minuto no TIO).

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

Neim , 3 bytes

𝐕𝐬𝔼

Experimente online!

(Na verdade, eu não sei como executar todos os casos de teste de uma só vez, desde que comecei a aprender Neim cerca de quinze minutos atrás, mas os verifiquei individualmente.)

Imprime 0 para imperfeito, 1 para perfeito.

𝐕      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 bytes

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

Experimente online!

Retorna TRUEpara números perfeitos e FALSEpara números imperfeitos.

Gelatina , 3 bytes

Æṣ=

Experimente online!

Japonês -! , 4 bytes

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

Por alguma razão, ¦não funciona no tio, então eu preciso usar a -!bandeira e, em ¥vez disso,

Experimente online!

Python 3 , 46 bytes

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

Experimente online!

Força bruta, soma os fatores e verifica a igualdade.

Python , 45 bytes

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

Truepara perfeito; Falsepara outras pessoas (alterne com ==-> !=)

Experimente online!

 44 42  41 bytes (-2 graças a ovs) se pudermos produzir usando "truthy vs falsey":

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

(falsey ( 0)) para perfeito; truthy (um número inteiro diferente de zero)

Oitava , 25 bytes

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

Experimente online!

Explicação

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

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

Experimente online!

(Último tempo limite da caixa de teste no TIO.)

C # (compilador interativo do Visual C #) , 46 bytes

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

Retorna 0 se perfeito, caso contrário, retorna um número positivo. Eu não sei se a saída de diferentes tipos de números inteiros é permitida no lugar de dois valores distintos de verdade e falsidade, e não consegui encontrar nenhuma discussão sobre meta sobre isso. Se isso for inválido, eu o removerei.

Experimente online!

C # (compilador interativo do Visual C #) , 49 47 bytes

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

Experimente online!

Ruby , 33 bytes

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

Experimente online!

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

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

Horrivelmente ineficiente, mas funciona.
Reduzir o número de bytes acelerou muito o programa.
A entrada é no Ans.
A saída está emAns impressa e automaticamente impressa quando o programa é concluído.

Explicação:
(O TI-BASIC não tem comentários, então assuma que ;faz um comentário)

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

Exemplo:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Nota: A contagem de bytes de um programa é avaliada usando o valor em [MEM] > [2] > [7] (36 bytes), subtraindo o comprimento do nome do programa CDGF2, (5 bytes) e 8 bytes extras usados ​​para armazenando o programa:

36-5-5 = 23 bytes

Java (JDK) , 54 bytes

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

Experimente online!

Embora para um número estrito por número correspondente, o seguinte retornará os mesmos valores, mas é de apenas 40 bytes.

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

Experimente online!

Montagem x86, 45 43 bytes.

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

Explicação (Sintaxe da 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

A entrada deve ser fornecida em EAX.
Conjuntos de funções EAXpara 1para aperfeiçoar e0 para imperfeito.

EDIT : Reduzido Byte-Count por dois, substituindo MOV EAX, $1por XOR EAX, EAXeINC EAX

Labirinto , 80 bytes

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

Os caracteres latinos perfect puts zero else neg Isão na verdade apenas comentários *.
ou seja, se a entrada é perfeita, a 0é impressa, caso contrário, -1é.

Experimente online!

* Então este ou este trabalho também ...

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

Quão?

Pega como entrada um número inteiro positivo ne coloca uma variável acumuladora -nna pilha auxiliar e, em seguida, executa um teste de divisibilidade para cada número inteiro de n-1baixo para, e incluindo 1, adicionando qualquer um que seja dividido nno acumulador. Quando isso estiver concluído, se a variável do acumulador for diferente de zero, a -1é emitida, caso contrário, a 0é.

O ?::`}:(é executado apenas uma vez, no início da execução:

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

A próxima instrução,, "é no-op, mas temos três instruções vizinhas, portanto, ramificamos de acordo com o valor no topo de Main, zero nos leva adiante, enquanto diferente de zero nos leva à direita.

Se a entrada foi 1, seguimos em frente porque o topo de Main é zero:

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

Mas se a entrada for maior do 1que virar à direita, porque a parte superior de Main é diferente de zero:

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

Neste ponto, temos um ramo de três vizinhos, mas sabemos que n-1é diferente de zero, por isso vimos à direita ...

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

Agora estamos em outra filial de três vizinhos em %.

Se o resultado de %for diferente de zero, vamos para a esquerda para diminuir nosso divisor em potencial p=p-1e deixar o acumulador a, como ele é:

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

... mas se o resultado de %foi zero (para a primeira passagem somente quando n=2), vamos direto para AMBOS, adicionamos o divisor ao nosso acumulador a=a+p, E diminui nosso divisor em potencial 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]]

Neste ponto, se p-1ainda for diferente de zero, vire à esquerda:

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

... mas se p-1acertar zero, vamos direto para a :segunda linha do labirinto (você já viu todas as instruções antes, então deixo suas descrições de fora e apenas produzo seus efeitos):

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

Agora isso {tem três instruções vizinhas, então ...

... se afor zero, o que será perfeito n, então vamos direto:

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

... se afor diferente de zero, o que não será perfeito n, viramos à esquerda:

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

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

Experimente online!

Javascript, 62

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

Explicação (embora seja bastante simples)

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

Obrigado a Jo King pela melhoria!

05AB1E , 4 bytes

ѨOQ

Experimente online!

Explicação

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

Powershell, 46 bytes 43 bytes

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

Experimente Online!

Edit: -3 bytes graças a @AdmBorkBork

C (gcc) , 41 bytes

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

Experimente 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

Deixe-me saber se essa falha no caso final é um problema.

Smalltalk, 34 bytes

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

Quarto (gforth) , 45 bytes

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

Experimente online!

Explicação

Repete todos os números de 1 a n-1, somando todos os valores que dividem n perfeitamente. Retorna true se sum for n

Código Explicação

: 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

Pitão , 9 13 bytes

qsf!%QTSt

Experimente online!

Obrigado aos comentaristas pela ajuda do golfe

Localiza todos os fatores da entrada, soma-os e compara-os à entrada original.

Lote, 81 bytes

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

Toma ncomo parâmetro da linha de comando e gera 1se for um número perfeito. Método de força bruta, inicia a soma em -npara que ele possa se incluir nno loop.

Carvão vegetal , 13 bytes

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

Experimente online! Link é a versão detalhada do código. Saídas -para números perfeitos. Usa força bruta. Explicação:

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

PerfectNumberQ

Experimente online!

Pitão, 8 bytes

qs{*MPyP

Experimente online aqui .

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

Retina 0.8.2 , 44 bytes

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

Experimente online! Usa força bruta, portanto, o link inclui apenas os casos de teste mais rápidos. Explicação:

.+
$*

Converta para unário.

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

Combine todos os fatores da entrada. Isso usa o modo de sobreposição, que no Retina 0.8.2 exige que todas as correspondências sejam iniciadas em posições diferentes; portanto, as correspondências são realmente retornadas em ordem decrescente, começando com a entrada original.

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

Subtraia os fatores adequados da entrada.

^¶+$

Teste se o resultado é zero.

Java 8, 66 bytes

Alguém precisa usar a API de fluxo em algum momento, mesmo se houver uma maneira mais curta de fazer isso

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

Experimente online!

cQuents , 8 bytes

?#N=U\zN

Experimente online!

Explicação

?           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