28
\$\begingroup\$

Write a program that displays on the screen the sum of the divisors of a number (1 ≤ N ≤ 100) entered by the user in the range of 1 to N.

This is OEIS A000203.


Examples:

Input: 7

7 / 1 = 7
7 / 7 = 1

7 + 1 = 8

Output: 8


Input: 15

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

15 + 5 + 3 + 1 = 24

Output: 24


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

Output: 42


Input: 1

1 / 1 = 1

Output: 1


Input: 5

5 / 1 = 5
5 / 5 = 1

5 + 1 = 6

Output: 6

\$\endgroup\$
7
  • 6
    \$\begingroup\$ @H.PWiz I think he means "the divisors of a number N" \$\endgroup\$
    – benzene
    Commented Sep 8, 2017 at 0:18
  • \$\begingroup\$ I think you mean sum of divisors, aka, the sigma function? \$\endgroup\$
    – Stephen
    Commented Sep 8, 2017 at 0:18
  • \$\begingroup\$ Sorry, i mean "The sum of the multiple of N". \$\endgroup\$ Commented Sep 8, 2017 at 0:19
  • \$\begingroup\$ @H.PWiz this is the sum of those, so I dunno \$\endgroup\$
    – Stephen
    Commented Sep 8, 2017 at 0:21
  • \$\begingroup\$ @Stephen That seems like a trivial change to me \$\endgroup\$
    – H.PWiz
    Commented Sep 8, 2017 at 0:21

67 Answers 67

22
\$\begingroup\$

05AB1E, 2 bytes

ÑO

Try it online!

How?

Ñ    Divisors
 O   Sum
\$\endgroup\$
2
  • \$\begingroup\$ Polyglot with 2sable \$\endgroup\$
    – Mr. Xcoder
    Commented Sep 8, 2017 at 9:31
  • 15
    \$\begingroup\$ ÑO - Rejecting the challenge and winning at the same time. That's pretty badass. \$\endgroup\$ Commented Sep 8, 2017 at 20:26
7
\$\begingroup\$

x86-64 Machine Code, 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

The above bytes of code define a function that accepts a single integer, N, and returns the sum of its multiples as a result.

The single parameter is passed in the EDI register, consistent with the System V AMD64 ABI (as used on *nix-style systems). The result is returned in the EAX register, as with all x86 calling conventions.

The algorithm is a very straightforward one, similar to many of the other submissions in other languages. We loop N times, each time computing the modulo and adding that to our running total.

Ungolfed assembly mnemonics:

; 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

Try it online!

It sure seems like there should be a way to make this shorter, but I can't see it. Computing modulo on x86 takes quite a bit of code, since you do it using the DIV (or IDIV) instruction, and both of those use fixed input registers (EDX and EAX), the values of which get clobbered (because they receive the results, the remainder and quotient, respectively).

The only real tricks here are pretty standard golfing ones:

  • I've structured the code in a somewhat unusual way so that I can use the CISC-style LOOP instruction, which is basically just a combination of DEC+JNZ with the ECX register as the implicit operand.
  • I'm using XCHG at the end instead of MOV because the former has a special 1-byte encoding when EAX is one of the operands.
  • I use CDQ to zero out EDX in preparation for the division, even though for unsigned division you would ordinarily just zero it using a XOR. However, XOR is always 2 bytes, while CDQ is only 1 byte. I use CDQ again a second time inside of the loop to zero EDX, before the CMOVZ instruction. This works because I can be guaranteed that the quotient of the division (in EAX) is always unsigned, so a sign-extension into EDX will set EDX equal to 0.
\$\endgroup\$
5
\$\begingroup\$

C (gcc), 45 bytes

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

Try it online!

\$\endgroup\$
4
\$\begingroup\$

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;}

This works in all theses 5 programming languages because of similarities.

C, C++ and D optimization : 62 60 bytes

In C++ and D, integers convert implicitly to booleans ( Zero => false, Not Zero => true ), so you don't need to have the !=0

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

D optimization : golfy template system, 55 bytes

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

C++ optimization by c and c-- : 53 52 bytes

int f(int n,int i=0){return++i<n?f(n,i)+i*!(n%i):n;}

Code to test :

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)));
    }
}
\$\endgroup\$
2
  • \$\begingroup\$ A few things: First, I don't think you need parentheses around the n%i/n%i!=0 in any of the languages. Second, your first solution should be able to have n%i>0 instead of n%i!=0. Third, D's solution can be T d(T)(T n){T s,i=1;for(;i<=n;++i)s+=n%i?0:i;return s;} by abusing the template system and default values. \$\endgroup\$
    – Adalynn
    Commented Sep 9, 2017 at 13:51
  • \$\begingroup\$ 52 bytes, C++ \$\endgroup\$
    – c--
    Commented Nov 24, 2022 at 23:09
3
\$\begingroup\$

Japt, 3 bytes

â)x

Try it online!

\$\endgroup\$
3
  • \$\begingroup\$ Alternative: â x \$\endgroup\$
    – Mr. Xcoder
    Commented Sep 8, 2017 at 22:11
  • \$\begingroup\$ @Mr.Xcoder: not really an alternative; it's doing the exact same thing - only difference is the choice of parenthesising. \$\endgroup\$
    – Shaggy
    Commented Oct 10, 2017 at 16:57
  • \$\begingroup\$ Or with the flag -x, it could be one byte \$\endgroup\$
    – Gymhgy
    Commented Apr 20, 2019 at 19:30
3
\$\begingroup\$

Brachylog, 2 bytes

f+

Try it online!

Explanation

f       Factors
 +      Sum
\$\endgroup\$
3
\$\begingroup\$

Mathematica, 14 bytes

Tr@Divisors@#&   

or an answer by @Loki

Mathematica, 17 bytes

DivisorSum[#,#&]&
\$\endgroup\$
7
  • \$\begingroup\$ @Jennymathy Very nice, thanks! An equivalent and funny way to write it is also: DivisorSum[#, # &] & \$\endgroup\$
    – Hans Olo
    Commented Sep 8, 2017 at 18:15
  • \$\begingroup\$ @Jennymathy Hmm, this is even better: Total@Divisors@ is only 15 characters long! And it works: eg Total@Divisors@15 gives 24 as expected. Mathematica FTW :) \$\endgroup\$
    – Hans Olo
    Commented Sep 8, 2017 at 19:27
  • 2
    \$\begingroup\$ @Loki and Tr@Divisors@#& even better ;-) \$\endgroup\$
    – ZaMoC
    Commented Sep 8, 2017 at 19:29
  • 1
    \$\begingroup\$ @Loki the program must be a function f= that takes an input f[x] that's why I present it in this way.Welcome to PPCG \$\endgroup\$
    – ZaMoC
    Commented Sep 8, 2017 at 19:36
  • 4
    \$\begingroup\$ You can use Tr@*Divisors to shave off a byte. \$\endgroup\$
    – wchargin
    Commented Sep 9, 2017 at 1:52
3
\$\begingroup\$

Shnap, 44 43 bytes

-1 bye thanks to Mr. Xcoder (lol I was outgolfed in my own language)

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

This is a function ($ starts a function in Shnap).

Try it online!

Explanation:

$ 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
    }

Noncompeting, 19 bytes

After many language updates, this can now be reduced to a measly 19 bytes:

$n=>sum(factors(n))

Try it online!

\$\endgroup\$
2
  • 1
    \$\begingroup\$ ==0 is <1 (43 bytes) \$\endgroup\$
    – Mr. Xcoder
    Commented Sep 8, 2017 at 9:22
  • \$\begingroup\$ @Mr. Xcoder thanks... I was outgolfed... In my own language... Which isn't even esoteric xD \$\endgroup\$ Commented Sep 8, 2017 at 10:51
3
\$\begingroup\$

Risky, 3 bytes

+/?+??

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Python, 44 bytes

lambda k:sum(i*(k%i<1)for i in range(1,1+k))
  • Thanks to Stephen, save 1 byte by removing whitespace.
  • Thanks to Jonathan Frech, save another 1 byte by changing if to multiply.
\$\endgroup\$
4
  • \$\begingroup\$ You could also write it as lambda k:sum(-~i*(k%-~i<1)for i in range(k)) \$\endgroup\$ Commented Apr 16, 2022 at 11:04
  • \$\begingroup\$ 41 bytes. \$\endgroup\$ Commented Sep 26, 2022 at 14:05
  • \$\begingroup\$ @97.100.97.109 Maybe that is different enough to post as another answer. \$\endgroup\$
    – tsh
    Commented Sep 27, 2022 at 3:26
  • \$\begingroup\$ @97.100.97.109 And looks like it is similar to this answer. codegolf.stackexchange.com/a/142108/44718 so you can go up vote that one. \$\endgroup\$
    – tsh
    Commented Sep 27, 2022 at 3:27
2
\$\begingroup\$

Pari/GP, 5 bytes

sigma

Try it online!

\$\endgroup\$
2
\$\begingroup\$

J, 23 bytes

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

Try it online!

For J fans, there is a clever 13 byte solution: >:@#.~/.~&.q: but since it wasn't my invention I'm not posting it as my official answer.

My own solution simply filters 1..n, finding divisors, then sums them. The crux of it is the dyadic fork

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

Note that in this context ] is 1..n, and [ is n itself. Hence ]|[ are the remainders when dividing each element of 1..n into n, and =&0 tells you if they're equal to 0.

\$\endgroup\$
3
  • 2
    \$\begingroup\$ This for 13 bytes should be equivalent: +1#.i.*0=i.|] \$\endgroup\$
    – miles
    Commented Sep 8, 2017 at 6:22
  • \$\begingroup\$ @miles, that is really nice. This part is i.|] is a great improvement on my approach. I don't fully understand this part though: +1#.i. -- could you explain it? \$\endgroup\$
    – Jonah
    Commented Sep 8, 2017 at 6:27
  • 2
    \$\begingroup\$ 1#. is base 1 conversion, which is equivalent to +/"1. First i.|] to get the remainders, then 0= to find the ones equal to 0 (the divisors), then i.* to zero out the non-divisors in the range, then sum using 1#., then add + itself since i. is an exclusive range. \$\endgroup\$
    – miles
    Commented Sep 8, 2017 at 6:31
2
\$\begingroup\$

Pyth, 6 bytes

s*M{yP

Try it here!

Pyth doesn't have a built-in for divisors, so I think this is reasonable.

Explanation

s*M{yP    - Full program with implicit input.

     P    - The prime factors of the input.
    y     - The powerset of its prime factors.
   {      - Deduplicate.
 *M       - Map with multiplication.
s         - Sum.
          - Implicitly display the result.

Given 20, for instance, this is what our program does after each instruction:

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

\$\endgroup\$
2
\$\begingroup\$

Java (OpenJDK 8), 53 51 bytes

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

Try it online!

\$\endgroup\$
1
  • 1
    \$\begingroup\$ @corsiKa Only class fields. In a local scope they're unitialized. \$\endgroup\$
    – shooqie
    Commented Sep 9, 2017 at 9:03
2
\$\begingroup\$

Jelly, 2 bytes

Æs

Try it online!

Built-in that does exactly as wanted.

\$\endgroup\$
4
  • \$\begingroup\$ Jelly seems so beautiful! Where can i find some stuff to study about it? \$\endgroup\$ Commented Sep 8, 2017 at 0:41
  • \$\begingroup\$ @KevinHalley You can check out the Tutorial page on Github, or you can visit the official Jelly chatroom once you have 20 reputation, or the Jelly training chatroom, also at 20 reputation, which you'll need to request permission to train in \$\endgroup\$
    – hyper-neutrino
    Commented Sep 8, 2017 at 0:42
  • 4
    \$\begingroup\$ I desperately want to upvote this because you suggested not upvoting trivial solutions. \$\endgroup\$ Commented Sep 8, 2017 at 6:01
  • \$\begingroup\$ @CodyGray Yeah, maybe there's no point putting that there :P \$\endgroup\$
    – hyper-neutrino
    Commented Sep 8, 2017 at 12:00
2
\$\begingroup\$

Haskell, 30 bytes

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

Try it online!

\$\endgroup\$
2
\$\begingroup\$

MATL, 6 bytes

t:\~fs

Try it online!

-4 bytes thanks to @LuisMendo

10 bytes

My previous solution using a loop

:"G@\~@*vs

Try it online!

3 bytes

Using built-in

Z\s

Try it online!

\$\endgroup\$
0
2
\$\begingroup\$

Javascript, 54 44 bytes

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

Saved 10 bytes thanks to Shaggy

Try it online!

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

\$\endgroup\$
0
2
\$\begingroup\$

Brain-Flak, 96 bytes

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

Try it online!

Explanation:

Now outdated by improvements.

The heart of the algorithm is this:

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

That is a modification on mod that will give us M if it is a factor of N and 0 otherwise. Full code is below.

((({})<>) 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
\$\endgroup\$
2
  • \$\begingroup\$ Do you have an explanation? \$\endgroup\$
    – Wheat Wizard
    Commented Sep 19, 2017 at 2:33
  • \$\begingroup\$ @FunkyComputerMan I got one now! \$\endgroup\$
    – MegaTom
    Commented Sep 21, 2017 at 19:56
2
\$\begingroup\$

R, 31 26 bytes

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

Try it online!

Returns a 1x1 matrix.

Computes !N%%x maps elements d of 1:N by: d->(1 if d divides N, 0 otherwise)

Then x%*%x!N%%x is the matrix product of 1:N which results in the sum of x where !N%%x is 1. Neat! Technically a port of Luis Mendo's Octave answer but I only saw that after I thought of this.

R+ numbers, 14 bytes

numbers::Sigma

Try it online!

\$\endgroup\$
5
  • \$\begingroup\$ For the first one you can save 2 bytes with N=scan(); \$\endgroup\$
    – gstats
    Commented Sep 8, 2017 at 12:07
  • \$\begingroup\$ @gstats yes, but then I should get +4 bytes per meta discussion. If you have a strong opinion you can weigh in on Jarko's answer but as nobody has suggested an alternative, that stands in my mind. \$\endgroup\$
    – Giuseppe
    Commented Sep 8, 2017 at 12:18
  • \$\begingroup\$ Shouldn't the second be numbers::Sigma(N)? Like this it outputs the source code of function Sigma. \$\endgroup\$ Commented Sep 8, 2017 at 15:58
  • \$\begingroup\$ @RuiBarradas a function is a perfectly good submission. to test it, you obviously have to call it as I do in the first submission. \$\endgroup\$
    – Giuseppe
    Commented Sep 8, 2017 at 15:59
  • \$\begingroup\$ Note: that anonymous functions in the later versions of R now can now use the syntax \(x) instead of function(x). So you can save quite a few characters there. \$\endgroup\$ Commented Sep 26, 2022 at 11:32
2
\$\begingroup\$

TI-Basic, 16 bytes

sum(seq(Inot(fPart(Ans/I)),I,1,Ans

Takes input in Ans. Output is stored in Ans and displayed.

\$\endgroup\$
2
\$\begingroup\$

Vyxal s, 1 byte

K

Try it Online!

K∑ flagless. K just gets the divisors of a number.

\$\endgroup\$
2
\$\begingroup\$

Husk, 2 bytes

ΣḊ

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ wow that's pretty good \$\endgroup\$
    – scpchicken
    Commented Jan 5, 2022 at 2:51
2
\$\begingroup\$

Raku, 25 23 22 bytes

thanks ovs for 2 byte improvement
also JoKing for 1 byte improvement

{sum grep $_%%*,1..$_}
declare anonymous block ($_ implicitly declared)
filter (grep) numbers from 1 to $_ inclusive using the whatever variable (*) that are divisible by $_
get the sum of that list

Try it online!

\$\endgroup\$
3
  • \$\begingroup\$ {grep($_%%*,1..$_).sum} works for 23 \$\endgroup\$
    – ovs
    Commented Jan 5, 2022 at 7:35
  • \$\begingroup\$ that that is very smart \$\endgroup\$
    – scpchicken
    Commented Jan 5, 2022 at 16:35
  • \$\begingroup\$ you can move sum to the start to save one on the brackets, Try it online! \$\endgroup\$
    – Jo King
    Commented Jan 30, 2022 at 12:38
2
\$\begingroup\$

Excel VBA, 41 Bytes

Anonymous VBE immediate window function that takes input from [A1] and outputs to the VBE immediate window

For i=1To[A1]:s=s-i*([A1]mod i=0):Next:?s

Excel, 41 Bytes

Worksheet formula that takes input from [A1] and outputs to the caller

Requires MS Excel Version 16.0 or later for access to Let(...) function

=LET(a,SEQUENCE(A1),SUM((MOD(A1,a)=0)*a))
\$\endgroup\$
2
  • 2
    \$\begingroup\$ For i=1To[A1]:s=s-([A1]mod i=0)*i:Next:?s is 41 bytes. The minus is because VBA seems to convert True to -1. \$\endgroup\$
    – Axuary
    Commented Dec 8, 2021 at 2:27
  • \$\begingroup\$ @Axuary - thanks for having me take a look at this one again - It was fun to make the worksheet formula solution for this \$\endgroup\$ Commented Jan 5, 2022 at 1:23
2
\$\begingroup\$

tinylisp, 74 73 bytes

(load library
(d D(q((K N)(i K(a(i(mod N K)0 K)(D(s K 1)N))0
(q((N)(D N N

Try it online!

-1 byte thanks to DLosc.

And without library just for fun:

tinylisp, 97 90 bytes

(d D(q((N K)(i(l N K)N(D(s N K)K
(d F(q((K N)(i K(a(i(D N K)0 K)(F(s K 1)N))0
(q((N)(F N N

Try it online!

-7 bytes thanks to DLosc.

\$\endgroup\$
2
  • \$\begingroup\$ @DLosc thanks! I should probably rename D to M since now it's just a mod function. \$\endgroup\$
    – Giuseppe
    Commented Feb 28, 2022 at 20:11
  • \$\begingroup\$ Huh--I didn't notice that, lol. \$\endgroup\$
    – DLosc
    Commented Feb 28, 2022 at 23:27
1
\$\begingroup\$

JavaScript, 31 bytes

f=(n,i=n)=>i&&!(n%i)*i+f(n,i-1)
\$\endgroup\$
1
\$\begingroup\$

Bash + GNU utilities, 36

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

Try it online.


Pure Bash, 41

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

Try it online.

I first tried a fancy bash expansion answer, but it ended up being longer than the simple loop above:

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

Python 2, 41 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
8
  • \$\begingroup\$ This answer is invalid as it is a collection of snippets that cannot be run as a single unit as stands. To make this valid you will need to convert this to a subroutine or an anonymous VBE immediate window function. \$\endgroup\$ Commented Sep 17, 2017 at 19:44
  • \$\begingroup\$ I am not very familiar in what you had said. Can you help me a bit more? \$\endgroup\$
    – remoel
    Commented Sep 18, 2017 at 4:43
  • \$\begingroup\$ To make this post valid you would have to convert it into one of the following formats, 1 - Subroutine, 2 - Function, 3 - Anonymous VBE immediate window function (a single line that can be executed in the Immediate window); For your implementation, the simplest implementation of this would be to convert to a subroutine by wrapping with Sub Y...End Sub to get the 85 Byte solution Sub y A=Cells(1,1) x=1 While x<=A If A Mod x=0 Then b=b+x x=x+1 Wend MsgBox b End Sub \$\endgroup\$ Commented Sep 20, 2017 at 0:32
  • \$\begingroup\$ That however can be optimized quite heavily down to the 72 byte solution Sub y While x<=[A1] x=x+1 If [A1]Mod x=0Then b=b+x Wend Debug.?b End Sub which assumes that it is run in a clean module (x = default int value, 0) and outputs to the VBE immediate window (? autoformats to Print ) \$\endgroup\$ Commented Sep 20, 2017 at 0:34
  • \$\begingroup\$ Beyond this, and recognizing that your solution does not take input via the subroutine call, this can then be converted to a VBE immediate window function for 50 Bytes While x<=[A1]:x=x+1:b=IIf([A1]Mod x,b,b+x):Wend:?b which assumes that x,b are the default value of 0 and outputs to the VBE immediate window (from the VBE immediate window ? is equivalent to Debug.Print ) \$\endgroup\$ Commented Sep 20, 2017 at 0:38

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.