Fondo:

El desafío actual de Perfect Numbers es bastante defectuoso y complicado, ya que le pide que imprima en un formato complejo que involucra los factores del número. Este es un problema puramente decisivo del desafío.

Reto

Dado un entero positivo a través de cualquier formato de entrada estándar , distinga si es perfecto o no.

Un número perfecto es un número que es igual a la suma de todos sus divisores propios (sus divisores positivos son menores que él). Por ejemplo, $6$ es un número perfecto, ya que sus divisores son $1,2,3$ , que suman $6$ , mientras que $12$ no es un número perfecto ya que sus divisores ( ) suman , no .$1,2,3,4,6$$16$$12$

Casos de prueba:

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

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

Reglas

• Su programa no tiene que completar los casos de prueba más grandes, si hay limitaciones de memoria o tiempo, pero debería ser teóricamente capaz si se le diera más memoria / tiempo.
• La salida puede ser dos valores distintos y consistentes a través de cualquier formato de salida permitido . Si no es inmediatamente obvio lo que representa Perfecto / Imperfecto, asegúrese de especificar en su respuesta.

Brachylog , 4 bytes

fk+?

Pruébalo en línea!

El predicado tiene éxito para entradas perfectas y falla para entradas imperfectas, impresión true.o false.si se ejecuta como un programa completo (excepto en el último caso de prueba que lleva más de un minuto en TIO).

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

Neim , 3 bytes

𝐕𝐬𝔼

Pruébalo en línea!

(En realidad, no sé cómo ejecutar todos los casos de prueba a la vez, ya que comencé a aprender Neim hace unos quince minutos, pero los comprobé individualmente).

Imprime 0 para imperfecto, 1 para perfecto.

𝐕      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

Pruébalo en línea!

Devoluciones TRUEpara números perfectos y FALSEpara números imperfectos.

Jalea , 3 bytes

Æṣ=

Pruébalo en línea!

Japt -! , 4 bytes

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

Por alguna razón ¦no funciona en tio, así que necesito usar la -!bandera y en su ¥lugar

Pruébalo en línea!

Python 3 , 46 bytes

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

Pruébalo en línea!

Fuerza bruta, suma los factores y verifica la igualdad.

Python , 45 bytes

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

Truepara perfecto Falsepara otros (cambie esto con ==-> !=)

Pruébalo en línea!

 44 42  41 bytes (-2 gracias a ovs) si podemos generar el uso de "truthy vs falsey":

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

(falsey ( 0)) para perfecto; verdad (un número entero distinto de cero) de lo contrario

Octava , 25 bytes

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

Pruébalo en línea!

Explicació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 bytes

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

Pruébalo en línea!

(Último tiempo de espera del caso de prueba en TIO).

C # (compilador interactivo de Visual C #) , 46 bytes

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

Devuelve 0 si es perfecto; de lo contrario, devuelve un número positivo. No sé si la salida de diferentes tipos de enteros está permitida en lugar de dos valores distintos de verdad y falsedad, y no pude encontrar ninguna discusión sobre meta al respecto. Si esto no es válido, lo eliminaré.

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 49 47 bytes

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

Pruébalo en línea!

Rubí , 33 bytes

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

Pruébalo en línea!

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

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

Horriblemente ineficiente, pero funciona.
La reducción del bytecount aceleró mucho el programa.
La entrada está adentro Ans.
La salida está adentro Ansy se imprime automáticamente cuando se completa el programa.

Explicación:
(TI-BASIC no tiene comentarios, así que supongamos que ;hace un comentario)

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

Ejemplo:

6
            6
prgmCDGF2
            1
7
            7
prgmCDGF2
            0

Nota: El recuento de bytes de un programa se evalúa utilizando el valor en [MEM] > [2] > [7] (36 bytes) y luego resta la longitud del nombre del programa,CDGF2 , (5 bytes) y 8 bytes adicionales utilizados para almacenar el programa:

36 - 5 - 8 = 23 bytes

Java (JDK) , 54 bytes

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

Pruébalo en línea!

Aunque para una coincidencia estricta número por número, lo siguiente devolverá los mismos valores, pero solo tiene 40 bytes.

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

Pruébalo en línea!

Conjunto 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

Explicación (sintaxis 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

La entrada se debe proporcionar en EAX.
Conjuntos de funciones EAXa 1para perfeccionar y 0para imperfecta.

EDITAR : Redujo el conteo de bytes por dos reemplazando MOV EAX, $1con XOR EAX, EAXyINC EAX

Laberinto , 80 bytes

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

Los caracteres latinos perfect puts zero else neg Ison en realidad solo comentarios *.
es decir, si la entrada es perfecta, 0se imprime a, de lo contrario -1es.

Pruébalo en línea!

* así que esto o este trabajo también ...

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

¿Cómo?

Toma como entrada un número entero positivo ny coloca una variable de acumulador -nen la pila auxiliar, luego realiza una prueba de divisibilidad para cada número entero desde n-1abajo hasta e incluyendo 1, agregando cualquiera que divida nal acumulador. Una vez que esto se completa, si la variable del acumulador no es cero, -1se emite, de lo contrario, se0 es

El ?::`}:(solo se ejecuta una vez, al comienzo de la ejecución:

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

La siguiente instrucción "es no operativa, pero tenemos tres instrucciones contiguas, por lo que nos ramificamos de acuerdo con el valor en la parte superior de Main, cero nos lleva hacia adelante, mientras que no cero nos lleva a la derecha.

Si la entrada fue 1, avanzamos porque la parte superior de Main es cero:

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

Pero si la entrada fue mayor que 1giramos a la derecha porque la parte superior de Main no es cero:

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

En este punto tenemos una rama de tres vecinos, pero sabemos n-1que no es cero, así que giramos a la derecha ...

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

Ahora estamos en otra sucursal de tres vecinos en %.

Si el resultado de %no es cero, vamos a la izquierda para disminuir nuestro divisor potencial p=p-1, y dejamos el acumulador a, como está:

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

... pero si el resultado de la %era de cero (para el primer pase sólo cuando n=2) seguimos de frente a AMBOS añadir el divisor en nuestro acumulador, a=a+p, y decremento nuestro potencial divisor 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]]

En este punto, si p-1todavía no es cero, giramos a la izquierda:

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

... pero si p-1llega a cero, vamos directamente a la :segunda línea del laberinto (has visto todas las instrucciones antes, así que dejo sus descripciones y solo doy su efecto):

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

Ahora esto {tiene tres instrucciones vecinas, así que ...

... si aes cero, lo que será perfecto n, entonces vamos directamente:

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

... si ano es cero, lo que será para no perfecto n, entonces giramos a la izquierda:

_~"!@                                                        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$\%!},:+=

Pruébalo en línea!

Javascript, 62

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

Explicación (aunque es bastante simple)

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

¡Gracias a Jo King por la mejora!

05AB1E , 4 bytes

ѨOQ

Pruébalo en línea!

Explicación

  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

Pruébalo en línea!

Editar: -3 bytes gracias a @AdmBorkBork

C (gcc) , 41 bytes

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

Pruébalo en línea!

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

Avíseme si esa falla para el caso final es un problema.

Smalltalk, 34 bytes

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

Adelante (gforth) , 45 bytes

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

Pruébalo en línea!

Explicación

Recorre cada número de 1 a n-1, sumando todos los valores que dividen n perfectamente. Devuelve verdadero si la suma es igual a n

Explicación del Código

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

qsf!%QTSt

Pruébalo en línea!

Gracias a los comentaristas por la ayuda del golf.

Encuentra todos los factores de la entrada, los suma y los compara con la 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

Se toma ncomo un parámetro de línea de comandos y 1se muestra si es un número perfecto. El método de fuerza bruta comienza la suma en -npara que pueda incluirse nen el bucle.

Carbón , 13 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Salidas -para números perfectos. Utiliza fuerza bruta. Explicació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

Wolfram Language (Mathematica) , 14 bytes

PerfectNumberQ

Pruébalo en línea!

Pyth, 8 bytes

qs{*MPyP

Pruébelo en línea aquí .

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
^¶+$

Pruébalo en línea! Utiliza la fuerza bruta, por lo que el enlace solo incluye los casos de prueba más rápidos. Explicación:

.+
$*

Convierte a unario.

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

Haga coincidir todos los factores de la entrada. Utiliza el modo de superposición, que en Retina 0.8.2 requiere que todas las coincidencias comiencen en diferentes posiciones, por lo que las coincidencias se devuelven en orden descendente, comenzando con la entrada original.

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

Resta los factores apropiados de la entrada.

^¶+$

Prueba si el resultado es cero.

Java 8, 66 bytes

Alguien tiene que usar la API de transmisión en algún momento, incluso si hay una forma más corta de hacerlo

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

Pruébalo en línea!

cQuents , 8 bytes

?#N=U\zN

Pruébalo en línea!

Explicación

?           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