¿No soy lo suficientemente bueno para ti?

29

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 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,61612

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.
Jo King
fuente
Espera, ¿entonces la verdad es para valores que no son perfectos, y falsey es para valores que sí lo son?
Esolanging Fruit
2
@ Tvde1 Los divisores adecuados tienen que ser menores que el número; de lo contrario, ningún otro número 1sería perfecto, ya que cada número es divisible por 1sí mismo. La suma de los divisores propios de 1es0
Jo King
3
@Grimy Solo si puedes demostrarlo . ¡Buena suerte! (aunque me pregunto cómo eso ahorraría bytes)
Jo King
1
Entonces no, qué mal.
Reduciría
3
"La salida puede ser dos valores distintos y consistentes": ¿no podemos usar "verdad contra falsey" aquí (por ejemplo, para Python usando cero vs no cero; una lista con contenido frente a una lista vacía y sus combinaciones)?
Jonathan Allan

Respuestas:

16

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.
Cadena no relacionada
fuente
1
Me gusta cómo dice el código fk: x
Ismael Miguel
9

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.
Cadena no relacionada
fuente
2
" ¿Supongo? "; " o algo así ". Cuando ni siquiera estás seguro de lo que has escrito, jaja. ;) Pero sí, así es como funciona. No conozco a Neim, pero usar la entrada implícitamente así y la salida implícita al final implícitamente, es similar en 05AB1E.
Kevin Cruijssen
¿Cómo es 𝔼1 byte? ¿Neim usa solo 128 de esos caracteres no estándar?
kajacx
3
@kajacx Neim tiene su propia página de códigos . Por lo tanto, cada uno de los 256 caracteres presentes en la página de códigos se puede codificar con 1 byte.
Sr. Xcoder
8

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.

Giuseppe
fuente
¿Qué te dan los 2! S seguidos?
CT Hall
@CTHall leí mal la especificación; originalmente asignaron 0(perfecto) a FALSEy distinto de cero, TRUEpero eliminé uno de ellos para revertir el mapeo. Es un truco de golf útil para fundición a partir numericde logical, a menudo en combinación con whicho [.
Giuseppe
7

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!

Luis felipe De jesus Munoz
fuente
Eso no es un problema de TIO; Uno se inserta automáticamente antes !.
Shaggy
6

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.

Neil A.
fuente
2
Usar la condición de comprensión como una máscara para su variable de iteración ahorraría un byte.
Jonathan Frech
Dado que puede devolver la verdad para un número imperfecto, también lambda x:sum(i for i in range(1,x)if x%i<1)^xdebería funcionar.
nedla2004
5

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

Jonathan Allan
fuente
Si el segundo formato de salida es válido, esto se puede hacer en 42 bytes .
ovs
@ovs ah, bien hecho.
Jonathan Allan
@ovs ... y otro salvado de eso, ¡gracias!
Jonathan Allan
5

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
Luis Mendo
fuente
4

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

tsh
fuente
@Arnauld Simplemente olvidé eliminar el f=después de convertir de una función recursiva.
tsh
Solo por curiosidad, ¿por qué no optar por una versión recursiva? (Sería 34 bytes.)
Arnauld
@Arnauld porque la versión recursiva simplemente fallaba para un caso de prueba más grande debido al desbordamiento de la pila Tal vez necesito algunos entornos predeterminados en modo estricto para que funcione.
tsh
2
Es justo, pero su programa no tiene que completar los casos de prueba más grandes (que creo que es la regla predeterminada, de todos modos).
Arnauld
4

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!

Encarnación de la ignorancia
fuente
3

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

Tau
fuente
3

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!

Olivier Grégoire
fuente
Las reglas dicenYour 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 ¿Eso significa que no puedo usar Java inten absoluto, sino más bien un BigInteger? Porque Java tiene BigIntegers, pero nunca tendrá un intmás de 31 bits como firmado, que no puede contener ningún otro valor que los representados aquí ...
Olivier Grégoire
no, pero si el programa todavía funciona si el inttipo no tiene límites
Jo King
1
@JoKing Ok, cambié las dos soluciones nuevamente para tener el cálculo primero.
Olivier Grégoire
3

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

Fayti1703
fuente
1
Uso un ensamblaje macro, así que no estoy seguro, pero el comentario "; divisor> número de entrada" para mí sería "; divisor> = número de entrada"
RosLuP
El ensamblaje tiene operaciones fáciles, uno podría reducir la longitud de las instrucciones, poner todo en una línea, usar sangría y comentar cada 10 20 instrucciones asm ...
RosLuP
@RosLuP He arreglado el comentario en el código (gracias), pero no sé a qué te refieres con tu segundo comentario.
Fayti1703
3

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
Jonathan Allan
fuente
2

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!

vityavv
fuente
2

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
Emigna
fuente
2

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

J. Bergmann
fuente
43 bytes haciendo rodar el acumulador en el bucle y comprobando 2*$ipara eliminar los pares de restar uno.
AdmBorkBork
2

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.

Marcos
fuente
1
41 bytes
tsh
2
"La salida puede ser dos valores distintos y consistentes a través de cualquier formato de salida permitido". No está devolviendo dos valores distintos.
Olivier Grégoire
2
@ OlivierGrégoire ¡Afortunadamente eso se puede solucionar fácilmente reemplazando el espacio con un signo de exclamación!
Neil
1
@Neil Mejor aún, se puede arreglar en n=!s;lugar de return!s;guardar 5 bytes.
@ OlivierGrégoire ahh, olvidé ese punto. Además, se actualizó con el código mejorado. Intenté algo similar, pero el idiota que soy lo hice, s=slo que probablemente se optimizó.
Marcos
2

Smalltalk, 34 bytes

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

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
reffu
fuente
2

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.

JPeroutek
fuente
Unos cuantos campos de golf para usted: q0se pueden reemplazar !y SQproducen el rango [1-Q], por lo que el rango [1-Q)se puede generar usando StQ. Como los Qs están ahora al final del programa, ambos pueden omitirse. Versión combinada, 9 bytes -qsf!%QTSt
Sok
1

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.

Neil
fuente
1

Carbón , 13 bytes

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

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:

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
Neil
fuente
1

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
Sok
fuente
1

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.

Neil
fuente
1

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!

Benjamin Urquhart
fuente
1

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
Stephen
fuente