Sum of divisors: Difference between revisions

Content added Content deleted

Inline

Latest revision as of 22:24, 17 February 2024

Given a positive integer, sum its positive divisors.

Task

Show the result for the first 100 positive integers.

11l

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]

Action!

PROC PrintNum(BYTE x)
  Put(32)
  IF x<10 THEN Put(32) FI
  IF x<100 THEN Put(32) FI
  PrintB(x)
RETURN

PROC Main()
  DEFINE MAX="100"
  BYTE ARRAY div(MAX+1)
  BYTE i,j,LMARGIN=$52,oldLMARGIN

  oldLMARGIN=LMARGIN
  LMARGIN=0 ;remove left margin on the screen
  Put(125) PutE() ;clear the screen

  SetBlock(div,MAX+1,1)
  FOR i=2 TO MAX
  DO
    FOR j=i TO MAX STEP i
    DO
      div(j)==+i
    OD
  OD

  FOR i=1 TO MAX
  DO
    PrintNum(div(i))
  OD

  LMARGIN=oldLMARGIN ;restore left margin on the screen
RETURN

Output:

Screenshot from Atari 8-bit computer

  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 68

Translation of: C++

...via Algol W

BEGIN # sum the divisors of the first 100 positive integers                  #

    # computes the sum of the divisors of v using the prime factorisation    #
    PROC divisor sum = ( INT v )INT:
         BEGIN
            INT total := 1, power := 2, n := v;
            WHILE NOT ODD n DO                 # Deal with powers of 2 first #
                total +:= power;
                power *:= 2;
                n  OVERAB 2
            OD;
            INT p := 3;            # Odd prime factors up to the square root #
            WHILE ( p * p ) <= n DO
                INT sum := 1;
                power   := p;
                WHILE n MOD p = 0 DO
                    sum   +:= power;
                    power *:= p;
                    n  OVERAB p
                OD;
                p     +:= 2;
                total *:= sum
            OD;
            IF n > 1 THEN total *:= n + 1 FI;     # If n > 1 then it's prime #
            total
        END # divisor sum # ;
    BEGIN                                  # show the first 100 divisor sums #
        INT limit = 100;
        print( ( "Sum of divisors for the first ", whole( limit, 0 ), " positive integers:" ) );
        FOR n TO limit DO
            IF n MOD 10 = 1 THEN print( ( newline ) ) FI;
            print( ( " ", whole( divisor sum( n ), -4 ) ) )
        OD
    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

ALGOL-M

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

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

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

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

Arturo

loop split.every:10 map 1..100 'x -> sum factors x 'row [
    print map row 'r -> pad to :string r 4
]

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

# 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

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

BASIC256

print 1; chr(9);
for n = 2 to 100
	p = 1 + n
	for i = 2 to n / 2
		if n mod i = 0 then p += i
	next i
	print p; chr(9);
next n
end

PureBasic

OpenConsole()
Print("1")
For n.i = 2 To 100
  p = 1 + n
  For i.i = 2 To n / 2
    If Mod(n, i) = 0 : p + i : EndIf
  Next i
  Print(#TAB$ + Str(p))
Next n
Input()
CloseConsole()

QBasic

Works with: QBasic version 1.1

Works with: QuickBasic version 4.5

PRINT 1,
FOR n = 2 TO 100
    p = 1 + n
    FOR i = 2 TO n / 2
        IF n MOD i = 0 THEN p = p + i
    NEXT i
    PRINT p,
NEXT n
END

True BASIC

PRINT 1,
FOR n = 2 To 100
    LET p = 1 + n
    FOR i = 2 To n / 2
        IF MOD(n, i) = 0 Then LET p = p + i
    NEXT i
    PRINT p,
NEXT n
END

Yabasic

print 1,
for n = 2 to 100
    p = 1 + n
    for i = 2 to n / 2
        if mod(n, i) = 0 then p = p + i : fi
    next i
    print p,
next n
end

BCPL

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

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

#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

Clojure

Translation of: Raku

(require '[clojure.string :refer [join]])
(require '[clojure.pprint :refer [cl-format]])

(defn divisors [n] (filter #(zero? (rem n %)) (range 1 (inc n))))

(defn display-results [label per-line width nums]
   (doall (map println (cons (str "\n" label ":") (list 
   (join "\n" (map #(join " " %)
                       (partition-all per-line
                                      (map #(cl-format nil "~v:d" width %) nums)))))))))

(display-results "Tau function - first 100" 20 3
                 (take 100 (map (comp count divisors) (drop 1 (range)))))

(display-results "Tau numbers – first 100" 10 5
                 (take 100 (filter #(zero? (rem % (count (divisors %)))) (drop 1 (range)))))

(display-results "Divisor sums – first 100" 20 4
                 (take 100 (map #(reduce + (divisors %)) (drop 1 (range)))))

(display-results "Divisor products – first 100" 5 16
                 (take 100 (map #(reduce * (divisors %)) (drop 1 (range)))))

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

CLU

% Calculate sum of divisors of positive integers up to and including N
div_sums = proc (n: int) returns (array[int]) 
    % Every number is at least divisible by 1
    ds: array[int] := array[int]$fill(1, n, 1)
    
    for i: int in int$from_to(2, n) do
        for j: int in int$from_to_by(i, n, i) do
            ds[j] := ds[j] + i  % every multiple of i is divisible by i
        end
    end
    return (ds)
end div_sums

% Print sum of divisors from 1 to 100
start_up = proc ()
    po: stream := stream$primary_output()
    
    col: int := 0
    for i: int in array[int]$elements(div_sums(100)) do
        stream$putright(po, int$unparse(i), 5)
        col := col + 1
        if col // 10 = 0 then stream$putc(po, '\n') end
    end
end start_up

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

Comal

0010 max#:=100
0020 //
0030 DIM divsum#(max#)
0040 FOR i#:=1 TO max# DO divsum#(i#):=1
0050 FOR i#:=2 TO max# DO FOR j#:=i# TO max# STEP i# DO divsum#(j#):+i#
0060 //
0070 ZONE 5
0080 FOR i#:=1 TO max# DO
0090   PRINT divsum#(i#),
0100   IF i# MOD 10=0 THEN PRINT
0110 ENDFOR i#
0120 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

Common Lisp

(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

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

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

Library: System.SysUtils

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.

EasyLang

Translation of: BASIC256

write 1 & " "
for n = 2 to 100
   p = 1 + n
   for i = 2 to n div 2
      if n mod i = 0
         p += i
      .
   .
   write p & " "
.

F#

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

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

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

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

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

       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

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

Frink

for n = 1 to 100
   print[sum[allFactors[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æ 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.

In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.

Solution

Test case 1. Show the result for the first 100 positive integers

Test case 2. Char

Go

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

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

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

J

Brute force:

   spd=: {{+/I.0=y|~i.1+y}}"0
   spd 1+i.10 10
  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

Of course, there are other alternatives.

Java

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

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

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

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

Lua

Translation of: C++

...via Algol 68

do -- sum the divisors of the first 100 positive integers

    -- computes the sum of the divisors of v using the prime factorisation
    function divisor_sum( v )
        local total, power, n = 1, 2, v
            while n % 2 == 0 do                       -- Deal with powers of 2 first
                total = total + power
                power = power * 2
                n     = math.floor( n / 2 )
            end
            local p = 3                   -- Odd prime factors up to the square root
            while ( p * p ) <= n do
                local sum = 1
                power     = p
                while n % p == 0 do
                    sum   = sum + power
                    power = power * p
                    n     = math.floor( n / p )
                end
                p     = p + 2
                total = total * sum
            end
            if n > 1 then total = total * ( n + 1 ) end  -- If n > 1 then it's prime
            return total
        end

    -- show the first 100 divisor sums
    local limit = 100
    io.write( "Sum of divisors for the first ", limit, " positive integers:\n" )
    for n = 1, limit do
        io.write( string.format( " %4d", divisor_sum( n ) ) )
        if n % 10 == 0 then io.write( "\n" ) end
    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

MAD

            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

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}

MiniScript

divisorSum = function(n)
	ans = 0
	i = 1
	while i * i <= n
		if n % i == 0 then
			ans += i
			j = floor(n / i)
			if j != i then ans += j
		end if
		i += 1
	end while
	return ans
end function

sums = []
for n in range(1, 100)
	sums.push(divisorSum(n))
end for

print sums.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

Nim

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

Free Pascal

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

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

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

imperative

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

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

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

(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

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

Using prime factorization

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

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

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

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

This only takes one line.

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

Racket

#lang racket/base

(require math/number-theory)

(define (sum-of-divisors n) (apply + (divisors n)))

(displayln (for/list ((n (in-range 1 101))) (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)

Raku

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

/*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

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

RPL

Translation of: Python

Works with: Halcyon Calc version 4.2.8

RPL code

Comment

≪ → n 
  ≪ 0
     1 n √ FOR ii
        IF n ii MOD NOT THEN 
           ii + 
           n ii / FLOOR 
           IF DUP ii ≠ 
           THEN + ELSE DROP END 
     END NEXT
≫ ≫ '∑DIV' STO

∑DIV ( n -- sum_of_divisors ) 
ans = 0
while i*i <= n:
  if 0 == n%i:
    ans += i
    j = n//i
    if j != i:
       ans += j
    i += 1
return ans

Input:

≪ { } 1 100 FOR j j ∑DIV + NEXT ≫ EVAL

Output:

1: { 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

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

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

    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

Verilog

module main;
  integer n, p, i;
  
  initial begin
      $write("1");
      for(n=2; n<=100; n=n+1) begin
    	p = 1 + n;
    	for(i=2; i<=n/2; i=i+1) if(n % i == 0) p = p + i;
    	$write(p);
      end
      $finish ;
    end
endmodule

VTL-2

10 C=0
20 M=100
30 I=1
40 :I)=0
50 I=I+1
60 #=M>I*40
70 I=1
80 J=I
90 :J)=:J)+I
100 J=J+I
110 #=M>J*90
120 ?=:I)
130 $=9
140 C=C+1
150 #=C/10*0+0<%*170
160 ?=""
170 I=I+1
180 #=M>I*80

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

Wren

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

XPL0

func SumDiv(N);         \Return sum of divisors of N
int  N, Sum, Div;
[Sum:= 0;
for Div:= 1 to N do
    if rem(N/Div) = 0 then
        Sum:= Sum + Div;
return Sum;
];

int C, N;
[C:= 0;
for N:= 1 to 100 do
    [IntOut(0, SumDiv(N));
    C:= C+1;
    if rem(C/10) then ChOut(0, 9\tab\) else CrLf(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