Sum of divisors: Difference between revisions
(Realize in F#) |
|||
Line 483: | Line 483: | ||
8281 778688 8649 8836 9025 |
8281 778688 8649 8836 9025 |
||
782757789696 97 941192 970299 1000000000</pre> |
782757789696 97 941192 970299 1000000000</pre> |
||
=={{header|Java}}== |
|||
{{trans|C++}} |
|||
<lang java>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(); |
|||
} |
|||
} |
|||
} |
|||
}</lang> |
|||
{{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|Julia}}== |
=={{header|Julia}}== |
Revision as of 23:35, 19 March 2021
Given a positive integer, sum its positive divisors.
- Task
Show the result for the first 100 positive integers.
ALGOL W
<lang algolw>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.</lang>
- 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
AppleScript
<lang 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()</lang>
- 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
<lang 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)
} </lang>
- 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
C++
<lang cpp>#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'; }
}</lang>
- 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
F#
This task uses Extensible Prime Generator (F#).
<lang fsharp>
// 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 "" </lang>
- 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
<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.</lang>
- 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
Forth
<lang forth>: 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</lang>
- 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
FreeBASIC
<lang 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</lang>
- 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
Go
<lang 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() } }
}</lang>
- 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
<lang gwbasic> 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</lang>
- 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
<lang 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 <>)</lang>
- Output:
Sums of divisors of [1..100]: 1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42 32 36 24 60 31 42 40 56 30 72 32 63 48 54 48 91 38 60 56 90 42 96 44 84 78 72 48 124 57 93 72 98 54 120 72 120 80 90 60 168 62 96 104 127 84 144 68 126 96 144 72 195 74 114 124 140 96 168 80 186 121 126 84 224 108 132 120 180 90 234 112 168 128 144 120 252 98 171 156 217 Products of divisors of [1..100]: 1 2 3 8 5 36 7 64 27 100 11 1728 13 196 225 1024 17 5832 19 8000 441 484 23 331776 125 676 729 21952 29 810000 31 32768 1089 1156 1225 10077696 37 1444 1521 2560000 41 3111696 43 85184 91125 2116 47 254803968 343 125000 2601 140608 53 8503056 3025 9834496 3249 3364 59 46656000000 61 3844 250047 2097152 4225 18974736 67 314432 4761 24010000 71 139314069504 73 5476 421875 438976 5929 37015056 79 3276800000 59049 6724 83 351298031616 7225 7396 7569 59969536 89 531441000000 8281 778688 8649 8836 9025 782757789696 97 941192 970299 1000000000
Java
<lang java>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(); } } }
}</lang>
- 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
Julia
<lang 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
</lang>
- 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
<lang scala>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() } }
}</lang>
- 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
Perl
<lang perl>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);</lang>
- 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
<lang Phix>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</lang>
- 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 <lang Phix>sequence r = apply(apply(true,factors,{tagset(100),{1}}),sum) puts(1,join_by(apply(true,sprintf,{{"%4d"},r}),1,10,""))</lang>
inline assembly
just to show it can be done, not that many would want to, same output <lang Phix> 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</lang>
Python
Using prime factorization
<lang Python>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)])</lang>
Finding divisors efficiently
<lang Python>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)])</lang>
- 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.
<lang python>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()</lang>
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.
<lang perl6>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</lang>
- 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
<lang rexx>/*REXX program displays the first N sum of divisors (shown in a columnar format). */ parse arg n . /*obtain optional argument from the CL.*/ if n== | n=="," then n= 100 /*Not specified? Then use the default.*/ say 'the sums of divisors for ' n " integers:"; say /*show what output is being shown*/ say '─index─' center(" sum of divisors ",70,'─') /*display a title for the tau numbers. */ w= max(7, length(n) ) /*W: used to align 1st output column. */ $= /*$: the output list, shown ten/line. */
do j=1 for N /*process N positive integers. */ $= $ || right( commas(sigma(j)), 7) /*add a sigma (sum) to the output list.*/ if j//10\==0 then iterate /*Not a multiple of 10? Don't display.*/ say right(commas(j-9), 6)' ' $ /*display partial list to the terminal.*/ $= /*start with a blank line for next line*/ end /*j*/
if j<=10 then j= 2 /handle case if this is the 1st display*/ if $\== then say right(j-1, 6)' ' $ /*any residuals sums left to display? */ 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 ? /*──────────────────────────────────────────────────────────────────────────────────────*/ iSqrt: procedure; parse arg x; q= 1; r= 0; do while q<=x; q= q*4; end
do while q>1; q=q%4; _=x-r-q; r=r%2; if _>=0 then do;x=_;r=r+q; end; end; return r
/*──────────────────────────────────────────────────────────────────────────────────────*/ 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. */</lang>
- output when using the default input:
the sums of divisors for 100 integers: ─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
<lang 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 </lang> Output:
the sums of divisors for 100 integers: 1 3 4 7 6 12 8 15 13 18 12 28 14 24 24 31 18 39 20 42 32 36 24 60 31 42 40 56 30 72 32 63 48 54 48 91 38 60 56 90 42 96 44 84 78 72 48 124 57 93 72 98 54 120 72 120 80 90 60 168 62 96 104 127 84 144 68 126 96 144 72 195 74 114 124 140 96 168 80 186 121 126 84 224 108 132 120 180 90 234 112 168 128 144 120 252 98 171 156 217
Ruby
<lang ruby>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</lang>
- 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
Tiny BASIC
<lang tinybasic>
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</lang>
Wren
<lang ecmascript>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()
}</lang>
- 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