Escriba un programa que muestre en la pantalla la suma de los divisores de un número (1 ≤ N ≤ 100) ingresado por el usuario en el rango de 1 a N.

Este es OEIS A000203 .

Ejemplos:

Entrada : 7

7 / 1 = 7
7 / 7 = 1

7 + 1 = 8

Salida: 8

Entrada: 15

15 / 1 = 15
15 / 3 = 5
15 / 5 = 3
15 / 15 = 1

15 + 5 + 3 + 1 = 24

Salida: 24

Entrada: 20

20 / 1 = 20
20 / 2 = 10
20 / 4 = 5
20 / 5 = 4
20 / 10 = 2
20 / 20 = 1

20 + 10 + 5 + 4 + 2 + 1 = 42

Salida: 42

Entrada: 1

1 / 1 = 1

Salida: 1

Entrada: 5

5 / 1 = 5
5 / 5 = 1

5 + 1 = 6

Salida: 6

05AB1E , 2 bytes

ÑO

Pruébalo en línea!

¿Cómo?

Ñ    Divisors
 O   Sum

Código de máquina x86-64, 23 bytes

89 F9 89 FE EB 0D 89 F8 99 F7 F1 85 D2 99 0F 44 D1 01 D6 E2 F1 96 C3

Los bytes de código anteriores definen una función que acepta un solo entero, N, y como resultado devuelve la suma de sus múltiplos.

El parámetro único se pasa en el EDIregistro, de acuerdo con el System V AMD64 ABI (como se usa en los sistemas de estilo * nix). El resultado se devuelve en el EAXregistro, como con todas las convenciones de llamadas x86.

El algoritmo es muy sencillo, similar a muchos de los otros envíos en otros idiomas. Realizamos un bucle N veces, cada vez que calculamos el módulo y lo agregamos a nuestro total acumulado.

Mnemónicos de ensamblaje sin golf:

; unsigned SumOfMultiples(unsigned N  /* (EDI) */)
    mov     ecx, edi      ; make copy of input N, to be used as our loop counter
    mov     esi, edi      ; make copy of input N, to be used as our accumulator
    jmp     CheckEnd      ; jump directly to 'CheckEnd'
AddModulo:
    mov     eax, edi      ; make copy of input N, to be used as input to DIV instruction
    cdq                   ; short way of setting EDX to 0, based on EAX
    div     ecx           ; divide EDX:EAX by ECX, placing remainder in EDX
    test    edx, edx      ; test remainder, and set ZF if it is zero
    cdq                   ; again, set EDX to 0, without clobbering flags
    cmovz   edx, ecx      ; set EDX to ECX only if remainder was zero (EDX = ZF ? 0 : ECX)
    add     esi, edx      ; add EDX to accumulator
CheckEnd:
    loop    AddModulo     ; decrement loop counter (ECX), and keep looping if it != 0
    xchg    eax, esi      ; move result from accumulator (ESI) into EAX
    ret                   ; return, with result in EAX

Pruébalo en línea!

Parece que debería haber una forma de acortar esto, pero no puedo verlo. El módulo de cómputo en x86 requiere bastante código, ya que lo hace usando la instrucción DIV(o IDIV), y ambos usan registros de entrada fijos ( EDXy EAX), cuyos valores se bloquean (porque reciben los resultados, el resto y cociente, respectivamente).

Los únicos trucos reales aquí son los de golf bastante estándar:

• He estructurado el código de una manera algo inusual para que pueda usar la LOOPinstrucción de estilo CISC , que es básicamente una combinación de DEC+ JNZcon el ECXregistro como el operando implícito.
• Estoy usando XCHGal final en lugar de MOVporque el primero tiene una codificación especial de 1 byte cuando EAXes uno de los operandos.
• Solía CDQponer a cero EDXen la preparación para la división, aunque para la división sin signo, normalmente lo pondría a cero usando a XOR. Sin embargo, XORsiempre tiene 2 bytes, mientras CDQque solo tiene 1 byte. Utilizo CDQnuevamente una segunda vez dentro del ciclo a cero EDX, antes de la CMOVZinstrucción. Esto funciona porque puedo garantizar que el cociente de la división (in EAX) siempre está sin signo, por lo que una extensión de inicio de sesión EDXse establecerá EDXigual a 0.

C (gcc), 45 bytes

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

Pruébalo en línea!

Japt , 3 bytes

â)x

Pruébalo en línea!

Brachylog , 2 bytes

f+

Pruébalo en línea!

Explicación

f       Factors
 +      Sum

Mathematica, 14 bytes

Tr@Divisors@#&   

o una respuesta de @Loki

Mathematica, 17 bytes

DivisorSum[#,#&]&

C, C ++, C #, D, Java, 65 62 bytes

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

Esto funciona en todas las tesis 5 lenguajes de programación debido a similitudes.

Optimización C, C ++ y D: 62 60 bytes

En C ++ y D, los enteros se convierten implícitamente en booleanos (cero => falso, no cero => verdadero), por lo que no necesita tener el !=0

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

Optimización D: sistema de plantillas de golf, 55 bytes

T d(T)(T n){T s,i=1;for(;i<=n;++i)s+=n%i?0:i;return s;}

Código para probar :

C :

printf("%d %d %d %d %d", d(7), d(15), d(20), d(1), d(5));

C ++:

std::cout << d(7) << ' ' << d(15) << ' ' << d(20) << ' ' << d(1) << ' ' << d(5);

C# :

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

    static void Main(string[] args)
    {
        var f = new FindSum();
        Console.WriteLine(string.Format("{0}, {1}, {2}, {3}, {4}", f.d(7), f.d(15), f.d(20), f.d(1), f.d(5)));
    }
}

D:

writeln(d(7));
writeln(d(15));
writeln(d(20));
writeln(d(1));
writeln(d(5));

Java:

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

    public static void main(String[] args) {
        FindSum f = new FindSum();
        System.out.println(String.format("%d, %d, %d, %d, %d", f.d(7), f.d(15), f.d(20), f.d(1), f.d(5)));
    }
}

Shnap , 44 43 bytes

-1 adiós gracias al Sr. Xcoder (jaja, me superaron en mi propio idioma)

 $n return:{s=0for d:range(n+1)if n%d<1s+=d}

Esta es una función ( $inicia una función en Shnap).

Pruébalo en línea!

Explicación:

$ n                        //Start function with parameter n
    return: {              //Technically, we are returning a scope-block, which evaluates to the last statement run
        s = 0              //Our result
        for d : range(n+1) //For each value in the iterator range(n+1)
            if n % d < 1  // If n is divisible by d
                s += d     // Add d to the sum
                           // Since (s += d) returns (s + d), and a scope-block returns the last run statement, this will be the last statement and equal to our result
    }

Sin competencia, 19 bytes

Después de muchas actualizaciones de idioma, ahora se puede reducir a unos miserables 19 bytes:

$n=>sum(factors(n))

Pruébalo en línea!

Python, 44 bytes

lambda k:sum(i*(k%i<1)for i in range(1,1+k))

• Gracias a Stephen, ahorre 1 byte eliminando espacios en blanco.
• Gracias a Jonathan Frech, ahorre otro 1 byte cambiando si multiplicar.

J, 23 bytes

[:+/](([:=&0]|[)#])1+i.

Pruébalo en línea!

Para los fanáticos de J, hay una solución inteligente de 13 bytes : >:@#.~/.~&.q:pero como no fue mi invención, no la publico como mi respuesta oficial.

Mi propia solución simplemente filtra 1..n, encuentra divisores, luego los suma. El quid de la cuestión es el tenedor diádico.

](([:=&0]|[)#])

Tenga en cuenta que en este contexto ]es 1..n, y [es n en sí mismo. Por ]|[lo tanto, son los restos al dividir cada elemento de 1..n en n, y =&0le dice si son iguales a 0.

Java (OpenJDK 8) , 53 51 bytes

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

Pruébalo en línea!

Haskell , 30 bytes

f n=sum[i|i<-[1..n],n`mod`i<1]

Pruébalo en línea!

MATL , 6 bytes

t:\~fs

Pruébalo en línea!

-4 bytes gracias a @LuisMendo

10 bytes

Mi solución anterior usando un bucle

:"G@\~@*vs

Pruébalo en línea!

3 bytes

Usando incorporado

Z\s

Pruébalo en línea!

Javascript, 54 44 bytes

n=>[...Array(x=n)].reduce(y=>y+!(n%x)*x--,0)

Guardado 10 bytes gracias a Shaggy

Pruébalo en línea!

const f = n=>[...Array(x=n)].reduce(y=>y+!(n%x)*x--,0)

console.log(f(7))
console.log(f(15))
console.log(f(20))
console.log(f(1))
console.log(f(5))

Brain-Flak , 96 bytes

((({})<>){<(([()]{})){<>(({})(<()>))<>{(({})){({}[()])<>}{}}{}<>([{}()]({})){((<{}{}>))}}{}>{}})

Pruébalo en línea!

Explicación:

_{Ahora anticuado por mejoras.}

El corazón del algoritmo es este:

({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]({})) turns |N, M...| into |N mod M, M...|
{((<{}{}>))} if the top of stack is not zero, replace it and the second with zero

Que es una modificación de mod que nos dará Msi se trata de un factor de Ny 0de otra manera. El código completo está abajo.

((({})<>) place input, N on both stacks
{ Loop to find factors
 <
  (([()]{})) Decrement and Duplicate; get next factor to check
  { if not zero
   (<>({})<>) Copy N from other stack
   ({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]({})){((<{}{}>))} Code explained above
  }
  {} drop the zero
 >
 {} add the factor
}) push the sum

R , 31 26 bytes

function(N)(x=1:N)%*%!N%%x

Pruébalo en línea!

Devuelve una 1x1matriz.

Calcula !N%%xelementos dde mapas de 1:Npor:d->(1 if d divides N, 0 otherwise)

Entonces x%*%x!N%%xes el producto matricial 1:Ncuyo resultado es la suma de xdónde !N%%xestá 1. ¡Ordenado! Técnicamente un puerto de la respuesta Octave de Luis Mendo, pero solo lo vi después de pensar en esto.

Números R +, 14 bytes

numbers::Sigma

Pruébalo en línea!

JavaScript, 31 bytes

f=(n,i=n)=>i&&!(n%i)*i+f(n,i-1)

Pari / GP , 5 bytes

sigma

Pruébalo en línea!

Python 2 , 41 bytes

f=lambda n,i=1:i<=n and(n%i<1)*i+f(n,i+1)

Pruébalo en línea!

VBA (Excel), 73 bytes

a=Cells(1,1)
x=1
While x<=a
If a Mod x = 0 Then b=b+x
x=x+1
Wend
MsgBox b

Pyth , 6 bytes

s*M{yP

Pruébalo aquí!

Pyth no tiene divisores incorporados, así que creo que esto es razonable.

Explicación

s * M {yP - Programa completo con entrada implícita.

     P - Los factores primos de la entrada.
    y - El conjunto de poder de sus factores primos.
   {- Deduplicar.
 * M - Mapa con multiplicación.
s - Suma.
          - Mostrar implícitamente el resultado.

Dado 20, por ejemplo, esto es lo que hace nuestro programa después de cada instrucción:

• P: [2, 2, 5].

• y: [[], [2], [2], [5], [2, 2], [2, 5], [2, 5], [2, 2, 5]].

• {: [[], [2], [5], [2, 2], [2, 5], [2, 2, 5]].

• *M: [1, 2, 5, 4, 10, 20].

• s: 42.

Ohm v2 , 2 bytes

VΣ

Pruébalo en línea!

Esto es bastante sencillo:

V - Divisores.
 Σ - Suma

Casco , 5 bytes

ṁΠuṖp

Pruébalo en línea!

¿Cómo?

ṁΠuṖp: programa completo, entrada implícita.

     p - Factores primos.
    Ṗ - Powerset.
   u - Eliminar duplicados.
ṁΠ - Obtenga el producto de cada lista, suma y salida implícita.

¡Gracias a Zgarb por las sugerencias en el chat!

Octava , 20 bytes

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

Pruébalo en línea!

RProgN 2 , 2 bytes

ƒ+

Explicado

ƒ+
ƒ   # Factorize
 +  # Sum

Trivial, pero sentí que necesitaba ser publicado.

Pruébalo en línea!

Perl 5 , 35 + 1 (-p) = 36 bytes

$\+=($n%$_==0)&&$_ for 1..($n=$_)}{

Pruébalo en línea!

Bash + utilidades GNU, 36

bc<<<`seq -f"n=%g;a+=n*!$1%%n;" $1`a

Pruébalo en línea .

Pure Bash, 41

for((;++i<=$1;a+=$1%i?0:i))
{
:
}
echo $a

Pruébalo en línea .

Primero probé una elegante respuesta de expansión de bash, pero terminó siendo más larga que el simple ciclo anterior:

echo $[$(eval echo +\\\(n={1..$1},$1%n?0:n\\\))]

Añadir ++ , 9 bytes

D,f,@,dFs

Pruébalo en línea!

Claramente llegué aquí demasiado tarde. Esto define una función que obtiene los factores y luego los suma.

QBIC , 17 bytes

[:|~b%a|\p=p+a}?p

Explicación

[:|      FOR a = 1; a <= b (read from cmd line); a++
~b%a|    IF b modulo a has a remainder THEN - empty block - 
\p=p+a   ELSE add divisor 'a' to running total 'p'
}        END IF, NEXT
?p       PRINT p

Gaia , 2 bytes

dΣ

Pruébalo en línea!

Muy claro:

dΣ - Programa completo.

d - Divisores.
 Σ - Suma