I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Sum of divisors

From Rosetta Code
Sum of divisors is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Given a positive integer, sum its positive divisors.


Task

Show the result for the first 100 positive integers.



11l[edit]

Translation of: Python
F sum_of_divisors(n)
V ans = 0
V i = 1
V j = 1
L i * i <= n
I 0 == n % i
ans += i
j = n I/ i
I j != i
ans += j
i++
R ans
 
print((1..100).map(n -> sum_of_divisors(n)))
Output:
[1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, 42, 32, 36, 24, 60, 31, 42, 40, 56, 30, 72, 32, 63, 48, 54, 48, 91, 38, 60, 56, 90, 42, 96, 44, 84, 78, 72, 48, 124, 57, 93, 72, 98, 54, 120, 72, 120, 80, 90, 60, 168, 62, 96, 104, 127, 84, 144, 68, 126, 96, 144, 72, 195, 74, 114, 124, 140, 96, 168, 80, 186, 121, 126, 84, 224, 108, 132, 120, 180, 90, 234, 112, 168, 128, 144, 120, 252, 98, 171, 156, 217]

ALGOL-M[edit]

begin
integer N;
N := 100;
begin
integer array div[1:N];
integer i, j, col;
for i := 1 step 1 until N do div[i] := 1;
for i := 2 step 1 until N do
for j := i step i until N do
div[j] := div[j] + i;
 
col := 0;
for i := 1 step 1 until N do begin
if (col-1)/10 <> col/10 then
write(div[i])
else
writeon(div[i]);
col := col + 1;
end;
end;
end
Output:
     1     3     4     7     6    12     8    15    13    18
    12    28    14    24    24    31    18    39    20    42
    32    36    24    60    31    42    40    56    30    72
    32    63    48    54    48    91    38    60    56    90
    42    96    44    84    78    72    48   124    57    93
    72    98    54   120    72   120    80    90    60   168
    62    96   104   127    84   144    68   126    96   144
    72   195    74   114   124   140    96   168    80   186
   121   126    84   224   108   132   120   180    90   234
   112   168   128   144   120   252    98   171   156   217

ALGOL W[edit]

Translation of: C++
begin % sum the divisors of the first 100 positive integers %
 % computes the sum of the divisors of n using the prime %
 % factorisation  %
integer procedure divisor_sum( integer value v ) ; begin
integer total, power, n, p;
total := 1; power := 2; n := v;
 % Deal with powers of 2 first %
while not odd( n ) do begin
total := total + power;
power := power * 2;
n  := n div 2
end while_not_odd_n ;
 % Odd prime factors up to the square root %
p := 3;
while ( p * p ) <= n do begin
integer sum;
sum  := 1;
power := p;
while n rem p = 0 do begin
sum  := sum + power;
power := power * p;
n  := n div p
end while_n_rem_p_eq_0 ;
p  := p + 2;
total := total * sum
end while_p_x_p_le_n ;
 % If n > 1 then it's prime %
if n > 1 then total := total * ( n + 1 );
total
end divisor_sum ;
begin
integer limit;
limit := 100;
write( i_w := 1, s_w := 0, "Sum of divisors for the first ", limit, " positive integers:" );
for n := 1 until limit do begin
if n rem 10 = 1 then write();
writeon( i_w := 4, s_w := 1, divisor_sum( n ) )
end for_n
end
end.
Output:
Sum of divisors for the first 100 positive integers:
   1    3    4    7    6   12    8   15   13   18
  12   28   14   24   24   31   18   39   20   42
  32   36   24   60   31   42   40   56   30   72
  32   63   48   54   48   91   38   60   56   90
  42   96   44   84   78   72   48  124   57   93
  72   98   54  120   72  120   80   90   60  168
  62   96  104  127   84  144   68  126   96  144
  72  195   74  114  124  140   96  168   80  186
 121  126   84  224  108  132  120  180   90  234
 112  168  128  144  120  252   98  171  156  217

APL[edit]

Works with: Dyalog APL
10 10 ⍴ +/∘(⍸0=⍳|⊢)¨⍳100
Output:
  1   3   4   7   6  12   8  15  13  18
 12  28  14  24  24  31  18  39  20  42
 32  36  24  60  31  42  40  56  30  72
 32  63  48  54  48  91  38  60  56  90
 42  96  44  84  78  72  48 124  57  93
 72  98  54 120  72 120  80  90  60 168
 62  96 104 127  84 144  68 126  96 144
 72 195  74 114 124 140  96 168  80 186
121 126  84 224 108 132 120 180  90 234
112 168 128 144 120 252  98 171 156 217

AppleScript[edit]

on sumOfDivisors(n)
if (n < 1) then return 0
set sum to 0
set sqrt to n ^ 0.5
set limit to sqrt div 1
if (limit = sqrt) then
set sum to sum + limit
set limit to limit - 1
end if
repeat with i from 1 to limit
if (n mod i is 0) then set sum to sum + i + n div i
end repeat
 
return sum
end sumOfDivisors
 
on task()
set output to {}
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ""
repeat with i from 0 to 80 by 20
set thisLine to {}
repeat with j from 1 to 20
set end of thisLine to text -4 thru -1 of (" " & sumOfDivisors(i + j))
end repeat
set end of output to thisLine as text
end repeat
set AppleScript's text item delimiters to linefeed
set output to output as text
set AppleScript's text item delimiters to astid
 
return output
end task
 
return task()
Output:
   1   3   4   7   6  12   8  15  13  18  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234 112 168 128 144 120 252  98 171 156 217

AWK[edit]

 
# syntax: GAWK -f SUM_OF_DIVISORS.AWK
# converted from Go
BEGIN {
limit = 100
printf("The sums of positive divisors for the first %d positive integers are:\n",limit)
for (i=1; i<=limit; i++) {
printf("%3d ",sum_divisors(i))
if (i % 10 == 0) {
printf("\n")
}
}
exit(0)
}
function sum_divisors(n, ans,i,j,k) {
ans = 0
i = 1
k = (n % 2 == 0) ? 1 : 2
while (i*i <= n) {
if (n % i == 0) {
ans += i
j = n / i
if (j != i) {
ans += j
}
}
i += k
}
return(ans)
}
 
Output:
The sums of positive divisors for the first 100 positive integers are:
  1   3   4   7   6  12   8  15  13  18
 12  28  14  24  24  31  18  39  20  42
 32  36  24  60  31  42  40  56  30  72
 32  63  48  54  48  91  38  60  56  90
 42  96  44  84  78  72  48 124  57  93
 72  98  54 120  72 120  80  90  60 168
 62  96 104 127  84 144  68 126  96 144
 72 195  74 114 124 140  96 168  80 186
121 126  84 224 108 132 120 180  90 234
112 168 128 144 120 252  98 171 156 217

BASIC[edit]

10 DEFINT A-Z: DATA 100
20 READ M
30 DIM D(M)
40 FOR I=1 TO M
50 FOR J=I TO M STEP I: D(J)=D(J)+I: NEXT
60 PRINT D(I),
70 NEXT
Output:
 1             3             4             7             6
 12            8             15            13            18
 12            28            14            24            24
 31            18            39            20            42
 32            36            24            60            31
 42            40            56            30            72
 32            63            48            54            48
 91            38            60            56            90
 42            96            44            84            78
 72            48            124           57            93
 72            98            54            120           72
 120           80            90            60            168
 62            96            104           127           84
 144           68            126           96            144
 72            195           74            114           124
 140           96            168           80            186
 121           126           84            224           108
 132           120           180           90            234
 112           168           128           144           120
 252           98            171           156           217

BCPL[edit]

get "libhdr"
 
manifest $( MAXIMUM = 100 $)
 
// Calculate sum of divisors of positive integers up to N inclusive
let sumdivs(v, n) be
$( for i=1 to n do v!i := 1 // All numbers are divisible by 1
for i=2 to n do
$( let j = i
while j<=n do
$( v!j := v!j + i // Every multiple of i is divisible by i
j := j + i
$)
$)
$)
 
// Print sum of divisors from 1 to MAXIMUM
let start() be
$( let divsum = vec MAXIMUM
let col = 0
 
sumdivs(divsum, MAXIMUM)
 
for i = 1 to MAXIMUM do
$( writed(divsum!i, 5)
col := col + 1
if col rem 10 = 0 then wrch('*N')
$)
$)
Output:
    1    3    4    7    6   12    8   15   13   18
   12   28   14   24   24   31   18   39   20   42
   32   36   24   60   31   42   40   56   30   72
   32   63   48   54   48   91   38   60   56   90
   42   96   44   84   78   72   48  124   57   93
   72   98   54  120   72  120   80   90   60  168
   62   96  104  127   84  144   68  126   96  144
   72  195   74  114  124  140   96  168   80  186
  121  126   84  224  108  132  120  180   90  234
  112  168  128  144  120  252   98  171  156  217

C[edit]

Translation of: C++
#include <stdio.h>
 
// See https://en.wikipedia.org/wiki/Divisor_function
unsigned int divisor_sum(unsigned int n) {
unsigned int total = 1, power = 2;
unsigned int p;
// Deal with powers of 2 first
for (; (n & 1) == 0; power <<= 1, n >>= 1) {
total += power;
}
// Odd prime factors up to the square root
for (p = 3; p * p <= n; p += 2) {
unsigned int sum = 1;
for (power = p; n % p == 0; power *= p, n /= p) {
sum += power;
}
total *= sum;
}
// If n > 1 then it's prime
if (n > 1) {
total *= n + 1;
}
return total;
}
 
int main() {
const unsigned int limit = 100;
unsigned int n;
printf("Sum of divisors for the first %d positive integers:\n", limit);
for (n = 1; n <= limit; ++n) {
printf("%4d", divisor_sum(n));
if (n % 10 == 0) {
printf("\n");
}
}
return 0;
}
Output:
Sum of divisors for the first 100 positive integers:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

C++[edit]

#include <iomanip>
#include <iostream>
 
// See https://en.wikipedia.org/wiki/Divisor_function
unsigned int divisor_sum(unsigned int n) {
unsigned int total = 1, power = 2;
// Deal with powers of 2 first
for (; (n & 1) == 0; power <<= 1, n >>= 1)
total += power;
// Odd prime factors up to the square root
for (unsigned int p = 3; p * p <= n; p += 2) {
unsigned int sum = 1;
for (power = p; n % p == 0; power *= p, n /= p)
sum += power;
total *= sum;
}
// If n > 1 then it's prime
if (n > 1)
total *= n + 1;
return total;
}
 
int main() {
const unsigned int limit = 100;
std::cout << "Sum of divisors for the first " << limit << " positive integers:\n";
for (unsigned int n = 1; n <= limit; ++n) {
std::cout << std::setw(4) << divisor_sum(n);
if (n % 10 == 0)
std::cout << '\n';
}
}
Output:
Sum of divisors for the first 100 positive integers:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

Common Lisp[edit]

 
(format t "~{~a ~}~%"
(loop for a from 1 to 100 collect
(loop for b from 1 to a
when (zerop (rem a b))
sum b)))
 
Output:
1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42 32 36 24 60 31 42 40 56 30 72 32 63 48 54 48 91 38 60 56 90 42 96 44 84 78 72 48 124 57 93 72 98 54 120 72 120 80 90 60 168 62 96 104 127 84 144 68 126 96 144 72 195 74 114 124 140 96 168 80 186 121 126 84 224 108 132 120 180 90 234 112 168 128 144 120 252 98 171 156 217 

Cowgol[edit]

include "cowgol.coh";
 
const MAXIMUM := 100;
typedef N is int(0, MAXIMUM+1);
 
sub print_col(n: N, colsize: uint8) is
var buf: uint8[32];
var nsize := UIToA(n as uint32, 10, &buf[0]) - &buf[0];
while colsize > nsize as uint8 loop
print_char(' ');
colsize := colsize - 1;
end loop;
print(&buf[0]);
end sub;
 
var divsum: N[MAXIMUM+1];
var i: N := 1;
 
while i <= MAXIMUM loop
divsum[i] := 1;
i := i + 1;
end loop;
 
i := 2;
while i <= MAXIMUM loop
var j := i;
while j <= MAXIMUM loop
divsum[j] := divsum[j] + i;
j := j + i;
end loop;
i := i + 1;
end loop;
 
var col: uint8 := 0;
i := 1;
while i <= MAXIMUM loop
print_col(divsum[i], 5);
col := col + 1;
if col == 10 then
print_nl();
col := 0;
end if;
i := i + 1;
end loop;
Output:
    1    3    4    7    6   12    8   15   13   18
   12   28   14   24   24   31   18   39   20   42
   32   36   24   60   31   42   40   56   30   72
   32   63   48   54   48   91   38   60   56   90
   42   96   44   84   78   72   48  124   57   93
   72   98   54  120   72  120   80   90   60  168
   62   96  104  127   84  144   68  126   96  144
   72  195   74  114  124  140   96  168   80  186
  121  126   84  224  108  132  120  180   90  234
  112  168  128  144  120  252   98  171  156  217

D[edit]

Translation of: C
import std.stdio;
 
// See https://en.wikipedia.org/wiki/Divisor_function
uint divisor_sum(uint n) {
uint total = 1, power = 2;
// Deal with powers of 2 first
for (; (n & 1) == 0; power <<= 1, n >>= 1) {
total += power;
}
// Odd prime factors up to the square root
for (uint p = 3; p * p <= n; p += 2) {
uint sum = 1;
for (power = p; n % p == 0; power *= p, n /= p) {
sum += power;
}
total *= sum;
}
// If n > 1 then it's prime
if (n > 1) {
total *= n + 1;
}
return total;
}
 
void main() {
immutable limit = 100;
writeln("Sum of divisors for the first ", limit," positive integers:");
for (uint n = 1; n <= limit; ++n) {
writef("%4d", divisor_sum(n));
if (n % 10 == 0) {
writeln;
}
}
}
Output:
Sum of divisors for the first 100 positive integers:
   1   3   4   7   6  12   8  15  13  18      
  12  28  14  24  24  31  18  39  20  42      
  32  36  24  60  31  42  40  56  30  72      
  32  63  48  54  48  91  38  60  56  90      
  42  96  44  84  78  72  48 124  57  93      
  72  98  54 120  72 120  80  90  60 168      
  62  96 104 127  84 144  68 126  96 144      
  72 195  74 114 124 140  96 168  80 186      
 121 126  84 224 108 132 120 180  90 234      
 112 168 128 144 120 252  98 171 156 217      

Delphi[edit]

Translation of: Java
 
program Sum_of_divisors;
 
{$APPTYPE CONSOLE}
 
uses
System.SysUtils;
 
function DivisorSum(n: Cardinal): Cardinal;
var
total, power, p, sum: Cardinal;
begin
total := 1;
power := 2;
 
// Deal with powers of 2 first
 
while (n and 1 = 0) do
begin
inc(total, power);
power := power shl 1;
n := n shr 1;
end;
 
// Odd prime factors up to the square root
p := 3;
while p * p <= n do
begin
sum := 1;
power := p;
while n mod p = 0 do
begin
inc(sum, power);
power := power * p;
n := n div p;
end;
total := total * sum;
inc(p, 2);
end;
 
// If n > 1 then it's prime
if n > 1 then
total := total * (n + 1);
Result := total;
end;
 
begin
const limit = 100;
writeln('Sum of divisors for the first ', limit, ' positive integers:');
for var n := 1 to limit do
begin
Write(divisorSum(n): 8);
if n mod 10 = 0 then
writeln;
end;
 
{$IFNDEF UNIX} readln; {$ENDIF}
end.

F#[edit]

This task uses Extensible Prime Generator (F#).

 
// Sum of divisors. Nigel Galloway: March 9th., 2021
let sod u=let P=primes32()
let rec fN g=match u%g with 0->g |_->fN(Seq.head P)
let rec fG n i g e l=match n=u,u%l with (true,_)->e*g |(_,0)->fG (n*i) i g (e+l)(l*i) |_->let q=fN(Seq.head P) in fG n q (g*e) 1 q
let n=Seq.head P in fG 1 n 1 1 n
[1..100]|>Seq.iter(sod>>printf "%d "); printfn ""
 
Output:
1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42 32 36 24 60 31 42 40 56 30 72 32 63 48 54 48 91 38 60 56 90 42 96 44 84 78 72 48 124 57 93 72 98 54 120 72 120 80 90 60 168 62 96 104 127 84 144 68 126 96 144 72 195 74 114 124 140 96 168 80 186 121 126 84 224 108 132 120 180 90 234 112 168 128 144 120 252 98 171 156 217

Factor[edit]

Works with: Factor version 0.99 2020-08-14
USING: grouping io math.primes.factors math.ranges prettyprint
sequences ;
 
"Sum of divisors for the first 100 positive integers:" print
100 [1,b] [ divisors sum ] map 10 group simple-table.
Output:
Sum of divisors for the first 100 positive integers:
1   3   4   7   6   12  8   15  13  18
12  28  14  24  24  31  18  39  20  42
32  36  24  60  31  42  40  56  30  72
32  63  48  54  48  91  38  60  56  90
42  96  44  84  78  72  48  124 57  93
72  98  54  120 72  120 80  90  60  168
62  96  104 127 84  144 68  126 96  144
72  195 74  114 124 140 96  168 80  186
121 126 84  224 108 132 120 180 90  234
112 168 128 144 120 252 98  171 156 217

Fermat[edit]

Func Sumdiv(n)=sm:=0;for i=1 to n do if Divides(i,n) then sm:=sm+i fi od; sm.
for i=1 to 100 do !!Sumdiv(i) od

FOCAL[edit]

01.10 S C=0
01.20 F I=1,100;S D(I)=1
01.30 F I=2,100;F J=I,I,100;S D(J)=D(J)+I
01.40 F I=1,100;D 2
01.50 Q
 
02.10 T %4,D(I)
02.20 S C=C+1
02.30 I (9-C)2.4;R
02.40 T !
02.50 S C=0
Output:
=    1=    3=    4=    7=    6=   12=    8=   15=   13=   18
=   12=   28=   14=   24=   24=   31=   18=   39=   20=   42
=   32=   36=   24=   60=   31=   42=   40=   56=   30=   72
=   32=   63=   48=   54=   48=   91=   38=   60=   56=   90
=   42=   96=   44=   84=   78=   72=   48=  124=   57=   93
=   72=   98=   54=  120=   72=  120=   80=   90=   60=  168
=   62=   96=  104=  127=   84=  144=   68=  126=   96=  144
=   72=  195=   74=  114=  124=  140=   96=  168=   80=  186
=  121=  126=   84=  224=  108=  132=  120=  180=   90=  234
=  112=  168=  128=  144=  120=  252=   98=  171=  156=  217

Forth[edit]

Translation of: C++
: divisor_sum ( n -- n )
1 >r
2
begin
over 2 mod 0=
while
dup r> + >r
2*
swap 2/ swap
repeat
drop
3
begin
2dup dup * >=
while
dup
1 >r
begin
2 pick 2 pick mod 0=
while
dup r> + >r
over * >r
tuck / swap
r>
repeat
2r> * >r
drop
2 +
repeat
drop
dup 1 > if 1+ r> * else drop r> then ;
 
: print_divisor_sums ( n -- )
." Sum of divisors for the first " dup . ." positive integers:" cr
1+ 1 do
i divisor_sum 4 .r
i 10 mod 0= if cr else space then
loop ;
 
100 print_divisor_sums
bye
Output:
Sum of divisors for the first 100 positive integers:
   1    3    4    7    6   12    8   15   13   18
  12   28   14   24   24   31   18   39   20   42
  32   36   24   60   31   42   40   56   30   72
  32   63   48   54   48   91   38   60   56   90
  42   96   44   84   78   72   48  124   57   93
  72   98   54  120   72  120   80   90   60  168
  62   96  104  127   84  144   68  126   96  144
  72  195   74  114  124  140   96  168   80  186
 121  126   84  224  108  132  120  180   90  234
 112  168  128  144  120  252   98  171  156  217

Fortran[edit]

       program DivSum
implicit none
integer i, j, col, divs(100)
 
do 10 i=1, 100, 1
10 divs(i) = 1
 
do 20 i=2, 100, 1
do 20 j=i, 100, i
20 divs(j) = divs(j) + i
 
col = 0
do 30 i=1, 100, 1
write (*,'(I4)',advance='no') divs(i)
col = col + 1
if (col .eq. 10) then
col = 0
write (*,*)
end if
30 continue
end program
Output:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

FreeBASIC[edit]

dim p as ulongint
print 1,
for n as uinteger = 2 to 100
p = 1+n
for i as uinteger = 2 to n/2
if n mod i = 0 then p += i
next i
print p,
next n
Output:
  1            3             4             7             6             12
8             15            13            18            12            28
14            24            24            31            18            39
20            42            32            36            24            60
31            42            40            56            30            72
32            63            48            54            48            91
38            60            56            90            42            96
44            84            78            72            48            124
57            93            72            98            54            120
72            120           80            90            60            168
62            96            104           127           84            144
68            126           96            144           72            195
74            114           124           140           96            168
80            186           121           126           84            224
108           132           120           180           90            234
112           168           128           144           120           252
98            171           156           217 

Fōrmulæ[edit]

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

Go[edit]

package main
 
import "fmt"
 
func sumDivisors(n int) int {
sum := 0
i := 1
k := 2
if n%2 == 0 {
k = 1
}
for i*i <= n {
if n%i == 0 {
sum += i
j := n / i
if j != i {
sum += j
}
}
i += k
}
return sum
}
 
func main() {
fmt.Println("The sums of positive divisors for the first 100 positive integers are:")
for i := 1; i <= 100; i++ {
fmt.Printf("%3d ", sumDivisors(i))
if i%10 == 0 {
fmt.Println()
}
}
}
Output:
The sums of positive divisors for the first 100 positive integers are:
  1     3     4     7     6    12     8    15    13    18   
 12    28    14    24    24    31    18    39    20    42   
 32    36    24    60    31    42    40    56    30    72   
 32    63    48    54    48    91    38    60    56    90   
 42    96    44    84    78    72    48   124    57    93   
 72    98    54   120    72   120    80    90    60   168   
 62    96   104   127    84   144    68   126    96   144   
 72   195    74   114   124   140    96   168    80   186   
121   126    84   224   108   132   120   180    90   234   
112   168   128   144   120   252    98   171   156   217   

GW-BASIC[edit]

 
5 PRINT 1,
10 FOR N = 2 TO 100
20 P = 1 + N
30 FOR I = 2 TO INT(N/2)
40 IF N MOD I = 0 THEN P = P + I
50 NEXT I
60 PRINT P,
70 NEXT N
Output:

1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42 32 36 24 60 31 42 40 56 30 72 32 63 48 54 48 91 38 60 56 90 42 96 44 84 78 72 48 124 57 93 72 98 54 120 72 120 80 90 60 168 62 96 104 127 84 144 68 126 96 144 72 195 74 114 124 140 96 168 80 186 121 126 84 224 108 132 120 180 90 234 112 168 128 144 120 252 98 171 156

217

Haskell[edit]

import Data.List.Split (chunksOf)
 
------------------------- DIVISORS -----------------------
divisors
:: Integral a
=> a -> [a]
divisors n =
((<>) <*> (rest . reverse . fmap (quot n))) $
filter ((0 ==) . rem n) [1 .. root]
where
root = (floor . sqrt . fromIntegral) n
rest
| n == root * root = tail
| otherwise = id
 
-------------- SUMS AND PRODUCTS OF DIVISORS -------------
main :: IO ()
main =
mapM_
putStrLn
[ "Sums of divisors of [1..100]:"
, test sum
, "Products of divisors of [1..100]:"
, test product
]
 
test
:: (Show a, Integral a)
=> ([a] -> a) -> String
test f =
let xs = show . f . divisors <$> [1 .. 100]
w = maximum $ length <$> xs
in unlines $ unwords <$> fmap (fmap (justifyRight w ' ')) (chunksOf 5 xs)
 
justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)
Output:
Sums of divisors of [1..100]:
  1   3   4   7   6
 12   8  15  13  18
 12  28  14  24  24
 31  18  39  20  42
 32  36  24  60  31
 42  40  56  30  72
 32  63  48  54  48
 91  38  60  56  90
 42  96  44  84  78
 72  48 124  57  93
 72  98  54 120  72
120  80  90  60 168
 62  96 104 127  84
144  68 126  96 144
 72 195  74 114 124
140  96 168  80 186
121 126  84 224 108
132 120 180  90 234
112 168 128 144 120
252  98 171 156 217

Products of divisors of [1..100]:
           1            2            3            8            5
          36            7           64           27          100
          11         1728           13          196          225
        1024           17         5832           19         8000
         441          484           23       331776          125
         676          729        21952           29       810000
          31        32768         1089         1156         1225
    10077696           37         1444         1521      2560000
          41      3111696           43        85184        91125
        2116           47    254803968          343       125000
        2601       140608           53      8503056         3025
     9834496         3249         3364           59  46656000000
          61         3844       250047      2097152         4225
    18974736           67       314432         4761     24010000
          71 139314069504           73         5476       421875
      438976         5929     37015056           79   3276800000
       59049         6724           83 351298031616         7225
        7396         7569     59969536           89 531441000000
        8281       778688         8649         8836         9025
782757789696           97       941192       970299   1000000000

Java[edit]

Translation of: C++
public class DivisorSum {
private static long divisorSum(long n) {
var total = 1L;
var power = 2L;
// Deal with powers of 2 first
for (; (n & 1) == 0; power <<= 1, n >>= 1) {
total += power;
}
// Odd prime factors up to the square root
for (long p = 3; p * p <= n; p += 2) {
long sum = 1;
for (power = p; n % p == 0; power *= p, n /= p) {
sum += power;
}
total *= sum;
}
// If n > 1 then it's prime
if (n > 1) {
total *= n + 1;
}
return total;
}
 
public static void main(String[] args) {
final long limit = 100;
System.out.printf("Sum of divisors for the first %d positive integers:%n", limit);
for (long n = 1; n <= limit; ++n) {
System.out.printf("%4d", divisorSum(n));
if (n % 10 == 0) {
System.out.println();
}
}
}
}
Output:
Sum of divisors for the first 100 positive integers:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

jq[edit]

Works with: jq

Works with gojq, the Go implementation of jq

Since a "divisors" function is more likely to be generally useful than a "sum of divisors" function, this entry implements the latter in terms of the former.

 
# divisors as an unsorted stream
def divisors:
if . == 1 then 1
else . as $n
| label $out
| range(1; $n) as $i
| ($i * $i) as $i2
| if $i2 > $n then break $out
else if $i2 == $n then $i
elif ($n % $i) == 0 then $i, ($n/$i)
else empty
end
end
end;
 
def add(s): reduce s as $x (null; .+$x);
 
def sum_of_divisors: add(divisors);
 
# For pretty-printing
def nwise($n):
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
n;
 
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
 
# The task:
[range(1; 101) | sum_of_divisors] | nwise(10) | map(lpad(4)) | join("")
Output:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

Julia[edit]

using Primes
 
function sumdivisors(n)
f = [one(n)]
for (p, e) in factor(n)
f = reduce(vcat, [f * p^j for j in 1:e], init = f)
end
return sum(f)
end
 
for i in 1:100
print(rpad(sumdivisors(i), 5), i % 25 == 0 ? " \n" : "")
end
 
Output:
1    3    4    7    6    12   8    15   13   18   12   28   14   24   24   31   18   39   20   42   32   36   24   60   31    
42   40   56   30   72   32   63   48   54   48   91   38   60   56   90   42   96   44   84   78   72   48   124  57   93
72   98   54   120  72   120  80   90   60   168  62   96   104  127  84   144  68   126  96   144  72   195  74   114  124
140  96   168  80   186  121  126  84   224  108  132  120  180  90   234  112  168  128  144  120  252  98   171  156  217

Kotlin[edit]

Translation of: C++
fun divisorSum(n: Long): Long {
var nn = n
var total = 1L
var power = 2L
// Deal with powers of 2 first
while ((nn and 1) == 0L) {
total += power
 
power = power shl 1
nn = nn shr 1
}
// Odd prime factors up to the square root
var p = 3L
while (p * p <= nn) {
var sum = 1L
power = p
while (nn % p == 0L) {
sum += power
 
power *= p
nn /= p
}
total *= sum
 
p += 2
}
// If n > 1 then it's prime
if (nn > 1) {
total *= nn + 1
}
return total
}
 
fun main() {
val limit = 100L
println("Sum of divisors for the first $limit positive integers:")
for (n in 1..limit) {
print("%4d".format(divisorSum(n)))
if (n % 10 == 0L) {
println()
}
}
}
Output:
Sum of divisors for the first 100 positive integers:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

MAD[edit]

            NORMAL MODE IS INTEGER
DIMENSION DIVSUM(100)
 
THROUGH INIT, FOR I=1, 1, I.G.100
INIT DIVSUM(I) = 1
 
THROUGH CALC, FOR D=2, 1, D.G.100
THROUGH CALC, FOR M=D, D, M.G.100
CALC DIVSUM(M) = DIVSUM(M) + D
 
THROUGH SHOW, FOR I=1, 10, I.G.100
SHOW PRINT FORMAT F, DIVSUM(I), DIVSUM(I+1),
0 DIVSUM(I+2), DIVSUM(I+3), DIVSUM(I+4),
1 DIVSUM(I+5), DIVSUM(I+6), DIVSUM(I+7),
2 DIVSUM(I+8), DIVSUM(I+9)
 
VECTOR VALUES F = $10(I4)*$
END OF PROGRAM
Output:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

Mathematica/Wolfram Language[edit]

DivisorSigma[1, Range[100]]
Output:
{1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, 42, 32, 36, 24, 60, 31, 42, 40, 56, 30, 72, 32, 63, 48, 54, 48, 91, 38, 60, 56, 90, 42, 96, 44, 84, 78, 72, 48, 124, 57, 93, 72, 98, 54, 120, 72, 120, 80, 90, 60, 168, 62, 96, 104, 127, 84, 144, 68, 126, 96, 144, 72, 195, 74, 114, 124, 140, 96, 168, 80, 186, 121, 126, 84, 224, 108, 132, 120, 180, 90, 234, 112, 168, 128, 144, 120, 252, 98, 171, 156, 217}

Nim[edit]

import math, strutils
 
proc divisors(n: Positive): seq[int] =
for d in 1..sqrt(n.toFloat).int:
if n mod d == 0:
result.add d
if n div d != d:
result.add n div d
 
for n in 1..100:
stdout.write ($sum(n.divisors)).align(3), if (n + 1) mod 10 == 0: '\n' else: ' '
Output:
  1   3   4   7   6  12   8  15  13
 18  12  28  14  24  24  31  18  39  20
 42  32  36  24  60  31  42  40  56  30
 72  32  63  48  54  48  91  38  60  56
 90  42  96  44  84  78  72  48 124  57
 93  72  98  54 120  72 120  80  90  60
168  62  96 104 127  84 144  68 126  96
144  72 195  74 114 124 140  96 168  80
186 121 126  84 224 108 132 120 180  90
234 112 168 128 144 120 252  98 171 156

Pascal[edit]

Free Pascal[edit]

Brute force version.Checking all divisors up to sqrt(n). More clever is Sum_of_divisors#Delphi.But why not a different version.
Runs with gpc too.//cardinal is 32 or 64 bit depending on OS-System

 
program Sum_of_divisors;
{$IFDEF WINDOWS}}
{$APPTYPE CONSOLE}
{$ENDIF}
{$IFDEF DELPHI}
uses
System.SysUtils;
{$ENDIF}
 
function DivisorSum(n: Cardinal): Cardinal;
//check up to i*i= n
var
i,quot,total: Cardinal;
begin
total :=n+1;
i := 2;
repeat
quot := n div i;
//i >= sqrt(n) reached
if quot <= i then
BREAK;
// n mod i = 0
if quot*i = n then
inc(total,i+quot);
inc(i);
until false;
if i*i = n then
inc(total,i);
DivisorSum := total;
end;
 
const
limit = 100;
var
res,
n : cardinal;
 
begin
writeln('Sum of divisors for the first ', limit, ' positive integers:');
for n := 1 to limit do
begin
res := divisorSum(n);
Write(res: 4);
if n mod 20 = 0 then
writeln;
end;
{$IFDEF WINDOWS}}
readln;
{$ENDIF}
end.
Output:
Sum of divisors for the first 100 positive integers:
   2   5   4   7   6  15   8  15  13  18  12  32  14  24  24  31  18  39  20  47
  32  36  24  60  31  42  40  56  30  78  32  63  48  54  48  91  38  60  56  90
  42 103  44  84  78  72  48 124  57  93  72  98  54 120  72 128  80  90  60 168
  62  96 104 127  84 144  68 126  96 144  72 204  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 244 112 168 128 144 120 252  98 171 156 217

Perl[edit]

Library: ntheory
use strict;
use warnings;
use feature 'say';
use ntheory 'divisor_sum';
 
my @x;
push @x, scalar divisor_sum($_) for 1..100;
 
say "Divisor sums - first 100:\n" .
((sprintf "@{['%4d' x 100]}", @x[0..100-1]) =~ s/(.{80})/$1\n/gr);
Output:
   1   3   4   7   6  12   8  15  13  18  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234 112 168 128 144 120 252  98 171 156 217

PARI/GP[edit]

vector(100,X,sigma(X))
Output:

[1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, 42, 32, 36, 24, 60, 31, 42, 40, 56, 30, 72, 32, 63, 48, 54, 48, 91, 38, 60, 56, 90, 42, 96, 44, 84, 78, 72, 48, 124, 57, 93, 72, 98, 54, 120, 72, 120, 80, 90, 60, 168, 62, 96, 104, 127, 84, 144, 68, 126, 96, 144, 72, 195, 74, 114, 124, 140, 96, 168, 80, 186, 121, 126, 84, 224, 108, 132, 120, 180, 90, 234, 112, 168, 128, 144, 120, 252, 98, 171, 156, 217]

Phix[edit]

imperative[edit]

for i=1 to 100 do
    printf(1,"%4d",{sum(factors(i,1))})
    if remainder(i,10)=0 then puts(1,"\n") end if
end for
Output:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

functional[edit]

same output

sequence r = apply(apply(true,factors,{tagset(100),{1}}),sum)
puts(1,join_by(apply(true,sprintf,{{"%4d"},r}),1,10,""))

inline assembly[edit]

just to show it can be done, not that many would want to, same output

without javascript_semantics
for i=1 to 100 do
    integer res
    #ilASM {mov edi,[i]
            mov ecx,1
            xor esi,esi
            cmp edi,ecx
            je done
         ::add_divisor
            add esi,ecx
         ::next_divisor
            add ecx,1
            mov eax,edi
            xor edx,edx
            div ecx
            cmp eax,ecx
            jb done
            je square_root
            test edx,edx
            jnz next_divisor
            add esi,eax
            jmp add_divisor
         ::square_root
            test edx,edx
            jnz done
            add esi,eax
         ::done
            add esi,edi
            mov [res],esi
           }
    printf(1,"%4d",res)
    if remainder(i,10)=0 then puts(1,"\n") end if
end for

PicoLisp[edit]

(de propdiv (N)
(let S 0
(for X N
(and (=0 (% N X)) (inc 'S X)) )
S ) )
(do 10
(do 10
(prin (align 4 (propdiv (inc (0))))) )
(prinl) )
Output:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

PL/M[edit]

100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
 
DECLARE LIMIT LITERALLY '100';
 
PRINT$NUMBER: PROCEDURE (N);
DECLARE S (7) BYTE INITIAL (' .....$');
DECLARE N ADDRESS, I BYTE;
I = 6;
DIGIT:
I = I - 1;
S(I) = N MOD 10 + '0';
N = N/10;
IF N>0 THEN GO TO DIGIT;
I = I - 1;
DO WHILE I > 0;
S(I) = ' ';
I = I - 1;
END;
CALL PRINT(.S);
END PRINT$NUMBER;
 
/* CALCULATE SUMS OF DIVISORS UP TO N INCLUSIVE */
CALC$DIVSUM: PROCEDURE (N, BUF);
DECLARE (I, J, N, BUF, D BASED BUF) ADDRESS;
DO I = 1 TO N;
D(I) = 1;
END;
DO I = 2 TO N;
DO J = I TO N BY I;
D(J) = D(J) + I;
END;
END;
END CALC$DIVSUM;
 
/* PRINT RESULTS */
DECLARE I ADDRESS;
DECLARE COL BYTE INITIAL (0);
DECLARE DIVS (LIMIT) ADDRESS;
 
CALL CALC$DIVSUM(LIMIT, .DIVS);
DO I = 1 TO LIMIT;
CALL PRINT$NUMBER(DIVS(I));
COL = COL + 1;
IF COL = 10 THEN DO;
CALL PRINT(.(13,10,'$'));
COL = 0;
END;
END;
CALL EXIT;
EOF
Output:
     1     3     4     7     6    12     8    15    13    18
    12    28    14    24    24    31    18    39    20    42
    32    36    24    60    31    42    40    56    30    72
    32    63    48    54    48    91    38    60    56    90
    42    96    44    84    78    72    48   124    57    93
    72    98    54   120    72   120    80    90    60   168
    62    96   104   127    84   144    68   126    96   144
    72   195    74   114   124   140    96   168    80   186
   121   126    84   224   108   132   120   180    90   234
   112   168   128   144   120   252    98   171   156   217

Python[edit]

Using prime factorization[edit]

def factorize(n):
assert(isinstance(n, int))
if n < 0:
n = -n
if n < 2:
return
k = 0
while 0 == n%2:
k += 1
n //= 2
if 0 < k:
yield (2,k)
p = 3
while p*p <= n:
k = 0
while 0 == n%p:
k += 1
n //= p
if 0 < k:
yield (p,k)
p += 2
if 1 < n:
yield (n,1)
 
def sum_of_divisors(n):
assert(n != 0)
ans = 1
for (p,k) in factorize(n):
ans *= (pow(p,k+1) - 1)//(p-1)
return ans
 
if __name__ == "__main__":
print([sum_of_divisors(n) for n in range(1,101)])

Finding divisors efficiently[edit]

def sum_of_divisors(n):
assert(isinstance(n, int) and 0 < n)
ans, i, j = 0, 1, 1
while i*i <= n:
if 0 == n%i:
ans += i
j = n//i
if j != i:
ans += j
i += 1
return ans
 
if __name__ == "__main__":
print([sum_of_divisors(n) for n in range(1,101)])
Output:
[1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, 42, 32, 36, 24, 60, 31, 42, 40, 56, 30, 72, 32, 63, 48, 54, 48, 91, 38, 60, 56, 90, 42, 96, 44, 84, 78, 72, 48, 124, 57, 93, 72, 98, 54, 120, 72, 120, 80, 90, 60, 168, 62, 96, 104, 127, 84, 144, 68, 126, 96, 144, 72, 195, 74, 114, 124, 140, 96, 168, 80, 186, 121, 126, 84, 224, 108, 132, 120, 180, 90, 234, 112, 168, 128, 144, 120, 252, 98, 171, 156, 217]

Choosing the right abstraction[edit]

This is really an exercise in defining a divisors function, and the only difference between the suggested Sum and Product draft tasks boils down to two trivial morphemes:

reduce(add, divisors(n), 0) vs reduce(mul, divisors(n), 1)

The goal of Rosetta code (see the landing page) is to provide contrastive insight (rather than comprehensive coverage of homework questions :-). Perhaps the scope for contrastive insight in the matter of divisors is already exhausted by the trivially different Proper divisors task.

'''Sums and products of divisors'''
 
from math import floor, sqrt
from functools import reduce
from operator import add, mul
 
 
# divisors :: Int -> [Int]
def divisors(n):
'''List of all divisors of n including n itself.
'''

root = floor(sqrt(n))
lows = [x for x in range(1, 1 + root) if 0 == n % x]
return lows + [n // x for x in reversed(lows)][
(1 if n == (root * root) else 0):
]
 
 
# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''Sums and products of divisors for each integer in range [1..50]
'''

print('Products of divisors:')
for n in range(1, 1 + 50):
print(n, '->', reduce(mul, divisors(n), 1))
 
print('Sums of divisors:')
for n in range(1, 1 + 100):
print(n, '->', reduce(add, divisors(n), 0))
 
 
# MAIN ---
if __name__ == '__main__':
main()

Quackery[edit]

factors is defined at Factors of an integer#Quackery.

  [ 0 swap factors witheach + ] is sum-of-divisors 
 
[] []
100 times
[ i^ 1+ sum-of-divisors join ]
witheach [ number$ nested join ]
72 wrap$
Output:
1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42 32 36 24 60 31 42
40 56 30 72 32 63 48 54 48 91 38 60 56 90 42 96 44 84 78 72 48 124 57 93
72 98 54 120 72 120 80 90 60 168 62 96 104 127 84 144 68 126 96 144 72
195 74 114 124 140 96 168 80 186 121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217

R[edit]

This only takes one line.

sapply(1:100, function(n) sum(c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))

Raku[edit]

Yet more tasks that are tiny variations of each other. Tau function, Tau number, Sum of divisors and Product of divisors all use code with minimal changes. What the heck, post 'em all.

use Prime::Factor:ver<0.3.0+>;
use Lingua::EN::Numbers;
 
say "\nTau function - first 100:\n", # ID
(1..*).map({ +.&divisors })[^100]\ # the task
.batch(20)».fmt("%3d").join("\n"); # display formatting
 
say "\nTau numbers - first 100:\n", # ID
(1..*).grep({ $_ %% +.&divisors })[^100]\ # the task
.batch(10)».&comma».fmt("%5s").join("\n"); # display formatting
 
say "\nDivisor sums - first 100:\n", # ID
(1..*).map({ [+] .&divisors })[^100]\ # the task
.batch(20)».fmt("%4d").join("\n"); # display formatting
 
say "\nDivisor products - first 100:\n", # ID
(1..*).map({ [×] .&divisors })[^100]\ # the task
.batch(5)».&comma».fmt("%16s").join("\n"); # display formatting
Output:
Tau function - first 100:
  1   2   2   3   2   4   2   4   3   4   2   6   2   4   4   5   2   6   2   6
  4   4   2   8   3   4   4   6   2   8   2   6   4   4   4   9   2   4   4   8
  2   8   2   6   6   4   2  10   3   6   4   6   2   8   4   8   4   4   2  12
  2   4   6   7   4   8   2   6   4   8   2  12   2   4   6   6   4   8   2  10
  5   4   2  12   4   4   4   8   2  12   4   6   4   4   4  12   2   6   6   9

Tau numbers - first 100:
    1     2     8     9    12    18    24    36    40    56
   60    72    80    84    88    96   104   108   128   132
  136   152   156   180   184   204   225   228   232   240
  248   252   276   288   296   328   344   348   360   372
  376   384   396   424   441   444   448   450   468   472
  480   488   492   504   516   536   560   564   568   584
  600   612   625   632   636   640   664   672   684   708
  712   720   732   776   792   804   808   824   828   852
  856   864   872   876   880   882   896   904   936   948
  972   996 1,016 1,040 1,044 1,048 1,056 1,068 1,089 1,096

Divisor sums - first 100:
   1    3    4    7    6   12    8   15   13   18   12   28   14   24   24   31   18   39   20   42
  32   36   24   60   31   42   40   56   30   72   32   63   48   54   48   91   38   60   56   90
  42   96   44   84   78   72   48  124   57   93   72   98   54  120   72  120   80   90   60  168
  62   96  104  127   84  144   68  126   96  144   72  195   74  114  124  140   96  168   80  186
 121  126   84  224  108  132  120  180   90  234  112  168  128  144  120  252   98  171  156  217

Divisor products - first 100:
               1                2                3                8                5
              36                7               64               27              100
              11            1,728               13              196              225
           1,024               17            5,832               19            8,000
             441              484               23          331,776              125
             676              729           21,952               29          810,000
              31           32,768            1,089            1,156            1,225
      10,077,696               37            1,444            1,521        2,560,000
              41        3,111,696               43           85,184           91,125
           2,116               47      254,803,968              343          125,000
           2,601          140,608               53        8,503,056            3,025
       9,834,496            3,249            3,364               59   46,656,000,000
              61            3,844          250,047        2,097,152            4,225
      18,974,736               67          314,432            4,761       24,010,000
              71  139,314,069,504               73            5,476          421,875
         438,976            5,929       37,015,056               79    3,276,800,000
          59,049            6,724               83  351,298,031,616            7,225
           7,396            7,569       59,969,536               89  531,441,000,000
           8,281          778,688            8,649            8,836            9,025
 782,757,789,696               97          941,192          970,299    1,000,000,000

REXX[edit]

/*REXX program displays the first   N   sum of divisors  (shown in a columnar format).  */
parse arg n cols . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n= 100 /*Not specified? Then use the default.*/
if cols=='' | cols=="," then cols= 10 /* " " " " " " */
say ' index │'center("sum of divisors", 102) /*display the title for the column #s. */
say '───────┼'center("" , 102,'─') /* " " separator for the title. */
w= 10 /*W: used to align 1st output column. */
$=; idx= 1 /*$: the output list, shown in columns*/
do j=1 for N /*process N positive integers. */
$= $ || right( commas( sigma(j) ), w) /*add a sigma (sum) to the output list.*/
if j//cols\==0 then iterate /*Not a multiple of cols? Don't display*/
say center(idx, 7)'│' $ /*display partial list to the terminal.*/
idx= idx + cols /*bump the index number for the output.*/
$= /*start with a blank line for next line*/
end /*j*/
 
if $\=='' then say center(idx, 7)'│' $ /*any residuals sums left to display? */
say '───────┴'center("" , 102,'─') /* " " foot separator for data. */
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?
/*──────────────────────────────────────────────────────────────────────────────────────*/
sigma: procedure; parse arg x; if x==1 then return 1; odd=x // 2 /* // ◄──remainder.*/
s= 1 + x /* [↓] only use EVEN or ODD integers.*/
do k=2+odd by 1+odd while k*k<x /*divide by all integers up to √x. */
if x//k==0 then s= s + k + x % k /*add the two divisors to (sigma) sum. */
end /*k*/ /* [↑]  % is the REXX integer division*/
if k*k==x then return s + k /*Was X a square? If so, add √ x */
return s /*return (sigma) sum of the divisors. */
output   when using the default input:
 index │                                           sum of divisors
───────┼──────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │          1         3         4         7         6        12         8        15        13        18
  11   │         12        28        14        24        24        31        18        39        20        42
  21   │         32        36        24        60        31        42        40        56        30        72
  31   │         32        63        48        54        48        91        38        60        56        90
  41   │         42        96        44        84        78        72        48       124        57        93
  51   │         72        98        54       120        72       120        80        90        60       168
  61   │         62        96       104       127        84       144        68       126        96       144
  71   │         72       195        74       114       124       140        96       168        80       186
  81   │        121       126        84       224       108       132       120       180        90       234
  91   │        112       168       128       144       120       252        98       171       156       217
───────┴──────────────────────────────────────────────────────────────────────────────────────────────────────

Ring[edit]

 
see "the sums of divisors for 100 integers:" + nl
num = 0
 
for n = 1 to 100
sum = 0
for m = 1 to n
if n%m = 0
sum = sum + m
ok
next
num = num + 1
if num%10 = 1
see nl
ok
see "" + sum + " "
next
 

Output:

the sums of divisors for  100  integers:

1 3 4 7 6 12 8 15 13 18 
12 28 14 24 24 31 18 39 20 42 
32 36 24 60 31 42 40 56 30 72 
32 63 48 54 48 91 38 60 56 90 
42 96 44 84 78 72 48 124 57 93 
72 98 54 120 72 120 80 90 60 168 
62 96 104 127 84 144 68 126 96 144 
72 195 74 114 124 140 96 168 80 186 
121 126 84 224 108 132 120 180 90 234 
112 168 128 144 120 252 98 171 156 217 

Ruby[edit]

Translation of: C++
def divisor_sum(n)
total = 1
power = 2
# Deal with powers of 2 first
while (n & 1) == 0
total = total + power
 
power = power << 1
n = n >> 1
end
# Odd prime factors up to the square root
p = 3
while p * p <= n
sum = 1
 
power = p
while n % p == 0
sum = sum + power
 
power = power * p
n = (n / p).floor
end
total = total * sum
 
p = p + 2
end
# If n > 1 then it's prime
if n > 1 then
total = total * (n + 1)
end
return total
end
 
LIMIT = 100
print "Sum of divisors for the first ", LIMIT, " positive integers:\n"
for n in 1 .. LIMIT
print "%4d" % [divisor_sum(n)]
if n % 10 == 0 then
print "\n"
end
end
Output:
Sum of divisors for the first 100 positive integers:
   1   3   4   7   6  12   8  15  13  18
  12  28  14  24  24  31  18  39  20  42
  32  36  24  60  31  42  40  56  30  72
  32  63  48  54  48  91  38  60  56  90
  42  96  44  84  78  72  48 124  57  93
  72  98  54 120  72 120  80  90  60 168
  62  96 104 127  84 144  68 126  96 144
  72 195  74 114 124 140  96 168  80 186
 121 126  84 224 108 132 120 180  90 234
 112 168 128 144 120 252  98 171 156 217

Sidef[edit]

1..100 -> map { .sigma }.say
Output:
[1, 3, 4, 7, 6, 12, 8, 15, 13, 18, 12, 28, 14, 24, 24, 31, 18, 39, 20, 42, 32, 36, 24, 60, 31, 42, 40, 56, 30, 72, 32, 63, 48, 54, 48, 91, 38, 60, 56, 90, 42, 96, 44, 84, 78, 72, 48, 124, 57, 93, 72, 98, 54, 120, 72, 120, 80, 90, 60, 168, 62, 96, 104, 127, 84, 144, 68, 126, 96, 144, 72, 195, 74, 114, 124, 140, 96, 168, 80, 186, 121, 126, 84, 224, 108, 132, 120, 180, 90, 234, 112, 168, 128, 144, 120, 252, 98, 171, 156, 217]

Tiny BASIC[edit]

 
PRINT 1
LET N = 1
10 LET N = N + 1
LET S = 1 + N
LET I = 1
20 LET I = I + 1
IF I > N/2 THEN GOTO 30
IF (N/I)*I = N THEN LET S = S + I
GOTO 20
30 PRINT S
IF N < 100 THEN GOTO 10
END

Wren[edit]

Library: Wren-math
Library: Wren-fmt
import "/math" for Int, Nums
import "/fmt" for Fmt
 
System.print("The sums of positive divisors for the first 100 positive integers are:")
for (i in 1..100) {
Fmt.write("$3d ", Nums.sum(Int.divisors(i)))
if (i % 10 == 0) System.print()
}
Output:
The sums of positive divisors for the first 100 positive integers are:
  1     3     4     7     6    12     8    15    13    18   
 12    28    14    24    24    31    18    39    20    42   
 32    36    24    60    31    42    40    56    30    72   
 32    63    48    54    48    91    38    60    56    90   
 42    96    44    84    78    72    48   124    57    93   
 72    98    54   120    72   120    80    90    60   168   
 62    96   104   127    84   144    68   126    96   144   
 72   195    74   114   124   140    96   168    80   186   
121   126    84   224   108   132   120   180    90   234   
112   168   128   144   120   252    98   171   156   217