Rosetta Code

Sum of divisors: Difference between revisions

Page Discussion

Sum of divisors (view source)

Revision as of 22:24, 17 February 2024

29,431 bytes added ,  3 months ago
Added Easylang
(Added Delphi example)
(Added Easylang)
 
(38 intermediate revisions by 26 users not shown)
Line 12:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F sum_of_divisors(n)
V ans = 0
V i = 1
Line 25:
R ans
 
print((1..100).map(n -> sum_of_divisors(n)))</langsyntaxhighlight>
 
{{out}}
<pre>
[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]
</pre>
 
=={{header|Action!}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_divisors.png Screenshot from Atari 8-bit computer]
<pre>
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
</pre>
 
=={{header|ALGOL 68}}==
{{Trans|C++}}...via Algol W
<syntaxhighlight lang="algol68">
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
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|ALGOL-M}}==
<langsyntaxhighlight lang="algolm">begin
integer N;
N := 100;
Line 53 ⟶ 155:
end;
end;
end</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 68 ⟶ 170:
=={{header|ALGOL W}}==
{{Trans|C++}}
<langsyntaxhighlight lang="algolw">begin % sum the divisors of the first 100 positive integers %
% computes the sum of the divisors of n using the prime %
% factorisation %
Line 107 ⟶ 209:
end for_n
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 125 ⟶ 227:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">10 10 ⍴ +/∘(⍸0=⍳|⊢)¨⍳100</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 140 ⟶ 242:
=={{header|AppleScript}}==
 
<langsyntaxhighlight lang="applescript">on sumOfDivisors(n)
if (n < 1) then return 0
set sum to 0
Line 174 ⟶ 276:
end task
 
return task()</langsyntaxhighlight>
 
{{output}}
Line 182 ⟶ 284:
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</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">loop split.every:10 map 1..100 'x -> sum factors x 'row [
print map row 'r -> pad to :string r 4
]</syntaxhighlight>
 
{{out}}
 
<pre> 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</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SUM_OF_DIVISORS.AWK
# converted from Go
Line 214 ⟶ 335:
return(ans)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 231 ⟶ 352:
 
=={{header|BASIC}}==
<langsyntaxhighlight BASIClang="basic">10 DEFINT A-Z: DATA 100
20 READ M
30 DIM D(M)
Line 237 ⟶ 358:
50 FOR J=I TO M STEP I: D(J)=D(J)+I: NEXT
60 PRINT D(I),
70 NEXT</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6
Line 259 ⟶ 380:
112 168 128 144 120
252 98 171 156 217</pre>
 
 
==={{header|BASIC256}}===
<syntaxhighlight lang="freebasic">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</syntaxhighlight>
 
==={{header|PureBasic}}===
<syntaxhighlight lang="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()</syntaxhighlight>
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
 
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">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</syntaxhighlight>
 
==={{header|Yabasic}}===
<syntaxhighlight lang="freebasic">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</syntaxhighlight>
 
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
manifest $( MAXIMUM = 100 $)
Line 289 ⟶ 471:
if col rem 10 = 0 then wrch('*N')
$)
$)</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 304 ⟶ 486:
=={{header|C}}==
{{trans|C++}}
<langsyntaxhighlight Clang="c">#include <stdio.h>
 
// See https://en.wikipedia.org/wiki/Divisor_function
Line 340 ⟶ 522:
}
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>Sum of divisors for the first 100 positive integers:
Line 355 ⟶ 537:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iomanip>
#include <iostream>
 
Line 385 ⟶ 567:
std::cout << '\n';
}
}</langsyntaxhighlight>
 
{{out}}
Line 401 ⟶ 583:
112 168 128 144 120 252 98 171 156 217
</pre>
 
=={{header|Clojure}}==
{{trans|Raku}}
<syntaxhighlight lang="clojure>(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)))))
</syntaxhighlight>
{{Out}}
<pre>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</pre>
 
=={{header|CLU}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre> 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</pre>
 
=={{header|Comal}}==
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>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</pre>
 
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
<lang Lisp>
(format t "~{~a ~}~%"
(loop for a from 1 to 100 collect
Line 409 ⟶ 727:
when (zerop (rem a b))
sum b)))
</syntaxhighlight>
</lang>
{{out}}
<pre>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 </pre>
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
const MAXIMUM := 100;
Line 457 ⟶ 775:
end if;
i := i + 1;
end loop;</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 469 ⟶ 787:
121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217</pre>
 
=={{header|D}}==
{{trans|C}}
<syntaxhighlight lang="d">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;
}
}
}</syntaxhighlight>
{{out}}
<pre>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 </pre>
 
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|Java}}
<syntaxhighlight lang="delphi">
<lang Delphi>
program Sum_of_divisors;
 
Line 530 ⟶ 897:
 
{$IFNDEF UNIX} readln; {$ENDIF}
end.</langsyntaxhighlight>
 
=={{header|EasyLang}}==
{{trans|BASIC256}}
<syntaxhighlight>
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 & " "
.
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>
<langsyntaxhighlight lang="fsharp">
// Sum of divisors. Nigel Galloway: March 9th., 2021
let sod u=let P=primes32()
Line 541 ⟶ 923:
let n=Seq.head P in fG 1 n 1 1 n
[1..100]|>Seq.iter(sod>>printf "%d "); printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 549 ⟶ 931:
=={{header|Factor}}==
{{works with|Factor|0.99 2020-08-14}}
<langsyntaxhighlight lang="factor">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.</langsyntaxhighlight>
{{out}}
<pre>
Line 568 ⟶ 950:
112 168 128 144 120 252 98 171 156 217
</pre>
 
=={{header|Fermat}}==
<syntaxhighlight lang="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</syntaxhighlight>
 
=={{header|FOCAL}}==
<langsyntaxhighlight FOCALlang="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
Line 580 ⟶ 966:
02.30 I (9-C)2.4;R
02.40 T !
02.50 S C=0</langsyntaxhighlight>
{{out}}
<pre>= 1= 3= 4= 7= 6= 12= 8= 15= 13= 18
Line 595 ⟶ 981:
=={{header|Forth}}==
{{trans|C++}}
<langsyntaxhighlight lang="forth">: divisor_sum ( n -- n )
1 >r
2
Line 635 ⟶ 1,021:
 
100 print_divisor_sums
bye</langsyntaxhighlight>
 
{{out}}
Line 653 ⟶ 1,039:
 
=={{header|Fortran}}==
<langsyntaxhighlight lang="fortran"> program DivSum
implicit none
integer i, j, col, divs(100)
Line 673 ⟶ 1,059:
end if
30 continue
end program </langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 687 ⟶ 1,073:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">dim p as ulongint
print 1,
for n as uinteger = 2 to 100
Line 695 ⟶ 1,081:
next i
print p,
next n</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12
Line 714 ⟶ 1,100:
112 168 128 144 120 252
98 171 156 217 </pre>
 
=={{header|Frink}}==
<syntaxhighlight lang="frink">for n = 1 to 100
print[sum[allFactors[n]] + " "]</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sum_of_divisors}}
 
'''Solution'''
 
[[File:Fōrmulæ - Sum of divisors 01.png]]
 
'''Test case 1. Show the result for the first 100 positive integers'''
 
[[File:Fōrmulæ - Sum of divisors 02.png]]
 
[[File:Fōrmulæ - Sum of divisors 03.png]]
 
'''Test case 2. Char'''
 
[[File:Fōrmulæ - Sum of divisors 04.png]]
 
[[File:Fōrmulæ - Sum of divisors 05.png]]
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 748 ⟶ 1,162:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 766 ⟶ 1,180:
 
=={{header|GW-BASIC}}==
<langsyntaxhighlight lang="gwbasic">
5 PRINT 1,
10 FOR N = 2 TO 100
Line 774 ⟶ 1,188:
50 NEXT I
60 PRINT P,
70 NEXT N</langsyntaxhighlight>
{{out}}<pre>
1 3 4 7 6 12 8 15 13 18 12
Line 788 ⟶ 1,202:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List.Split (chunksOf)
 
------------------------- DIVISORS -----------------------
Line 823 ⟶ 1,237:
 
justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)</langsyntaxhighlight>
{{Out}}
<pre>Sums of divisors of [1..100]:
Line 868 ⟶ 1,282:
8281 778688 8649 8836 9025
782757789696 97 941192 970299 1000000000</pre>
 
=={{header|J}}==
Brute force:
<syntaxhighlight lang=J> 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
</syntaxhighlight>
 
Of course, there are [[j:Essays/Divisors#Sum_of_Divisors|other alternatives]].
 
=={{header|Java}}==
{{trans|C++}}
<langsyntaxhighlight lang="java">public class DivisorSum {
private static long divisorSum(long n) {
var total = 1L;
Line 904 ⟶ 1,336:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Sum of divisors for the first 100 positive integers:
Line 917 ⟶ 1,349:
121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217</pre>
 
=={{header|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.
<syntaxhighlight lang="jq">
# 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("")</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function sumdivisors(n)
Line 932 ⟶ 1,413:
print(rpad(sumdivisors(i), 5), i % 25 == 0 ? " \n" : "")
end
</langsyntaxhighlight>{{out}}
<pre>
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
Line 942 ⟶ 1,423:
=={{header|Kotlin}}==
{{trans|C++}}
<langsyntaxhighlight lang="scala">fun divisorSum(n: Long): Long {
var nn = n
var total = 1L
Line 984 ⟶ 1,465:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Sum of divisors for the first 100 positive integers:
Line 997 ⟶ 1,478:
121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217</pre>
 
=={{header|Lua}}==
{{Trans|C++}}...via Algol 68
<syntaxhighlight lang="lua">
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
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|MAD}}==
<langsyntaxhighlight MADlang="mad"> NORMAL MODE IS INTEGER
DIMENSION DIVSUM(100)
Line 1,016 ⟶ 1,551:
 
VECTOR VALUES F = $10(I4)*$
END OF PROGRAM </langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 1,029 ⟶ 1,564:
112 168 128 144 120 252 98 171 156 217</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">DivisorSigma[1, Range[100]]</syntaxhighlight>
{{out}}
<pre>{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}</pre>
 
=={{header|MiniScript}}==
<syntaxhighlight lang="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(", ")
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|Nim}}==
<syntaxhighlight lang="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: ' '</syntaxhighlight>
 
{{out}}
<pre> 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</pre>
 
=={{header|Pascal}}==
==={{header|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.<BR>
Runs with gpc too.//cardinal is 32 or 64 bit depending on OS-System
<syntaxhighlight lang="pascal">
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.</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,040 ⟶ 1,697:
 
say "Divisor sums - first 100:\n" .
((sprintf "@{['%4d' x 100]}", @x[0..100-1]) =~ s/(.{80})/$1\n/gr);</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42
Line 1,049 ⟶ 1,706:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang="parigp">vector(100,X,sigma(X))</langsyntaxhighlight>
{{out}}<pre>
[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]</pre>
Line 1,055 ⟶ 1,712:
=={{header|Phix}}==
=== imperative ===
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%4d"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">))})</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,076 ⟶ 1,733:
=== functional ===
same output
<!--<langsyntaxhighlight Phixlang="phix">-->
<span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">),{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}}),</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%4d"</span><span style="color: #0000FF;">},</span><span style="color: #000000;">r</span><span style="color: #0000FF;">}),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
=== inline assembly ===
just to show it can be done, not that many would want to, same output
<!--<langsyntaxhighlight Phixlang="phix">-->
<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span>
Line 1,116 ⟶ 1,773:
<span style="color: #008080;">if</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
 
=={{header|PicoLisp}}==
<syntaxhighlight lang="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) )</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="plm">100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
Line 1,171 ⟶ 1,852:
END;
CALL EXIT;
EOF</langsyntaxhighlight>
{{out}}
<pre> 1 3 4 7 6 12 8 15 13 18
Line 1,186 ⟶ 1,867:
=={{header|Python}}==
===Using prime factorization===
<langsyntaxhighlight Pythonlang="python">def factorize(n):
assert(isinstance(n, int))
if n < 0:
Line 1,218 ⟶ 1,899:
if __name__ == "__main__":
print([sum_of_divisors(n) for n in range(1,101)])</langsyntaxhighlight>
 
===Finding divisors efficiently===
<langsyntaxhighlight Pythonlang="python">def sum_of_divisors(n):
assert(isinstance(n, int) and 0 < n)
ans, i, j = 0, 1, 1
Line 1,234 ⟶ 1,915:
if __name__ == "__main__":
print([sum_of_divisors(n) for n in range(1,101)])</langsyntaxhighlight>
{{out}}
<pre>[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]</pre>
Line 1,248 ⟶ 1,929:
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.
 
<langsyntaxhighlight lang="python">'''Sums and products of divisors'''
 
from math import floor, sqrt
Line 1,282 ⟶ 1,963:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
 
=={{header|Quackery}}==
 
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
 
<syntaxhighlight lang="quackery"> [ 0 swap factors witheach + ] is sum-of-divisors
 
[] []
100 times
[ i^ 1+ sum-of-divisors join ]
witheach [ number$ nested join ]
72 wrap$ </syntaxhighlight>
 
{{out}}
 
<pre>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
</pre>
 
=={{header|R}}==
This only takes one line.
<syntaxhighlight lang="rsplus">sapply(1:100, function(n) sum(c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))</syntaxhighlight>
 
=={{header|Racket}}==
 
<syntaxhighlight lang="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)))</syntaxhighlight>
 
{{out}}
 
<pre>(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)</pre>
 
=={{header|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.
 
<syntaxhighlight lang="raku" perl6line>use Prime::Factor:ver<0.3.0+>;
use Lingua::EN::Numbers;
 
Line 1,304 ⟶ 2,024:
say "\nDivisor products - first 100:\n", # ID
(1..*).map({ [×] .&divisors })[^100]\ # the task
.batch(5)».&comma».fmt("%16s").join("\n"); # display formatting</langsyntaxhighlight>
{{out}}
<pre>Tau function - first 100:
Line 1,355 ⟶ 2,075:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="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.*/
Line 1,372 ⟶ 2,092:
 
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. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
Line 1,382 ⟶ 2,103:
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. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 1,397 ⟶ 2,118:
81 │ 121 126 84 224 108 132 120 180 90 234
91 │ 112 168 128 144 120 252 98 171 156 217
───────┴──────────────────────────────────────────────────────────────────────────────────────────────────────
</pre>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
see "the sums of divisors for 100 integers:" + nl
num = 0
Line 1,417 ⟶ 2,139:
see "" + sum + " "
next
</syntaxhighlight>
</lang>
Output:
<pre>
Line 1,432 ⟶ 2,154:
121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217
</pre>
 
=={{header|RPL}}==
{{trans|Python}}
{{works with|Halcyon Calc|4.2.8}}
{| class="wikitable"
! 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
|}
{{in}}
<pre>
≪ { } 1 100 FOR j j ∑DIV + NEXT ≫ EVAL
</pre>
{{out}}
<pre>
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 }
</pre>
 
=={{header|Ruby}}==
{{trans|C++}}
<langsyntaxhighlight lang="ruby">def divisor_sum(n)
total = 1
power = 2
Line 1,476 ⟶ 2,237:
print "\n"
end
end</langsyntaxhighlight>
{{out}}
<pre>Sum of divisors for the first 100 positive integers:
Line 1,489 ⟶ 2,250:
121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">1..100 -> map { .sigma }.say</syntaxhighlight>
{{out}}
<pre>
[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]
</pre>
 
=={{header|Tiny BASIC}}==
<langsyntaxhighlight lang="tinybasic">
PRINT 1
LET N = 1
Line 1,503 ⟶ 2,271:
30 PRINT S
IF N < 100 THEN GOTO 10
END</langsyntaxhighlight>
 
=={{header|Verilog}}==
<syntaxhighlight lang="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</syntaxhighlight>
 
=={{header|VTL-2}}==
<syntaxhighlight lang="vtl2">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</syntaxhighlight>
{{out}}
<pre>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</pre>
 
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int, Nums
import "./fmt" for Fmt
 
System.print("The sums of positive divisors for the first 100 positive integers are:")
Line 1,515 ⟶ 2,329:
Fmt.write("$3d ", Nums.sum(Int.divisors(i)))
if (i % 10 == 0) System.print()
}</langsyntaxhighlight>
 
{{out}}
Line 1,530 ⟶ 2,344:
121 126 84 224 108 132 120 180 90 234
112 168 128 144 120 252 98 171 156 217
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="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)];
]</syntaxhighlight>
 
{{out}}
<pre>
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
</pre>
Chkas
1,983

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/305712...354451"