Rosetta Code

Product of divisors: Difference between revisions

Page Discussion

Product of divisors (view source)

Revision as of 10:25, 29 January 2024

10,286 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
m (→‎{{header|Wren}}: Minor tidy)
 
(11 intermediate revisions by 9 users not shown)
Line 11:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F product_of_divisors(n)
V ans = 1
V i = 1
Line 24:
R ans
 
print((1..50).map(n -> product_of_divisors(n)))</langsyntaxhighlight>
 
{{out}}
Line 33:
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<langsyntaxhighlight Actionlang="action!">INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
 
PROC ProdOfDivisors(INT n REAL POINTER prod)
Line 66:
PrintR(prod) Put(32)
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Product_of_divisors.png Screenshot from Atari 8-bit computer]
Line 77:
=={{header|ALGOL 68}}==
{{Trans|Fortran}}
<langsyntaxhighlight lang="algol68">BEGIN # product of divisors - transaltion of the Fortran sample #
[ 1 : 50 ]INT divis;
FOR i TO UPB divis DO divis[ i ] := 1 OD;
Line 89:
IF i MOD 5 = 0 THEN print( ( newline ) ) FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 105:
 
{{Trans|C++}}
<langsyntaxhighlight lang="algol68">BEGIN # find the product of the divisors of the first 100 positive integers #
# calculates the number of divisors of v #
PROC divisor count = ( INT v )INT:
Line 146:
OD
END
END</langsyntaxhighlight>
{{out}}
<pre>
Line 164:
=={{header|ALGOL W}}==
{{Trans|Fortran}}
<langsyntaxhighlight lang="algolw">begin % product of divisors - transaltion of the Fortran sample %
integer array divis ( 1 :: 50 );
for i := 1 until 50 do divis( i ) := 1;
Line 174:
if i rem 5 = 0 then write()
end for_i
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 190:
 
{{Trans|C++}}
<langsyntaxhighlight lang="algolw">begin % find the product of the divisors of the first 100 positive integers %
% calculates the number of divisors of v %
integer procedure divisor_count( integer value v ) ; begin
Line 234:
end for_n
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 251:
 
=={{header|APL}}==
<langsyntaxhighlight APLlang="apl">divprod ← ×/(⍸0=⍳|⊢)
10 5 ⍴ divprod¨ ⍳50</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 8 5
Line 267:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">loop split.every:5 to [:string] map 1..50 => [product factors &] 'line [
print map line 'i -> pad i 10
]</langsyntaxhighlight>
 
{{out}}
Line 285:
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f PRODUCT_OF_DIVISORS.AWK
# converted from Go
Line 315:
return(ans)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 327:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="basic">10 N = 50
20 DIM D(N)
30 FOR I=1 TO N: D(I)=1: NEXT
Line 335:
70 NEXT J
80 NEXT I
90 FOR I=1 TO N: PRINT D(I),: NEXT</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 8 5
Line 350:
 
==={{header|BASIC256}}===
<langsyntaxhighlight BASIC256lang="basic256">for n = 1 to 50
p = n
for i = 2 to n/2
Line 358:
print p; chr(9);
next n
end</langsyntaxhighlight>
 
==={{header|PureBasic}}===
<langsyntaxhighlight PureBasiclang="purebasic">OpenConsole()
For n.i = 1 To 50
p = n
Line 371:
Next n
Input()
CloseConsole()</langsyntaxhighlight>
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<langsyntaxhighlight QBasiclang="qbasic">FOR n = 1 TO 50
p = n
FOR i = 2 TO n / 2
Line 384:
PRINT USING "###########"; p;
NEXT n
END</langsyntaxhighlight>
 
==={{header|True BASIC}}===
<langsyntaxhighlight lang="qbasic">FOR n = 1 TO 50
LET p = n
FOR i = 2 TO n/2
Line 395:
PRINT p,
NEXT n
END</langsyntaxhighlight>
 
==={{header|Yabasic}}===
<langsyntaxhighlight lang="yabasic">for n = 1 to 50
p = n
for i = 2 to n/2
Line 406:
print p using "###########";
next n
end</langsyntaxhighlight>
 
=={{header|BQN}}==
<langsyntaxhighlight lang="bqn">(⊢(×´⊢/˜ 0=|˜ )1+↕)¨∘‿5⥊1+↕50</langsyntaxhighlight>
{{out}}
<pre>┌─
Line 425:
=={{header|C}}==
{{trans|C++}}
<langsyntaxhighlight lang="c">#include <math.h>
#include <stdio.h>
 
Line 470:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 485:
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <cmath>
#include <iomanip>
#include <iostream>
Line 521:
std::cout << '\n';
}
}</langsyntaxhighlight>
 
{{out}}
Line 539:
 
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">
<lang Lisp>
(format t "~{~a ~}~%"
(loop for a from 1 to 100 collect
Line 545:
when (zerop (rem a b)) do (setf z (* z b))
finally (return z))))
</syntaxhighlight>
</lang>
{{out}}
<pre>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 </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|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. PRODUCT-OF-DIVISORS.
 
Line 592 ⟶ 666:
DISPLAY OUT-LINE,
MOVE SPACES TO OUT-LINE,
MOVE 1 TO LINE-PTR.</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 8 5
Line 606 ⟶ 680:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub divprod(n: uint32): (prod: uint32) is
Line 631 ⟶ 705:
end if;
n := n + 1;
end loop;</langsyntaxhighlight>
 
{{out}}
Line 648 ⟶ 722:
=={{header|D}}==
{{trans|C++}}
<langsyntaxhighlight lang="d">import std.math;
import std.stdio;
 
Line 686 ⟶ 760:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50positive integers:
Line 699 ⟶ 773:
41 3111696 43 85184 91125
2116 47 254803968 343 125000</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
This is anohter example of building hierarchial libraries of subroutines. Rather than pack all the code inside a single block of code, this code is broken into subroutines that can be reused, saving time designing and test code.
 
<syntaxhighlight lang="Delphi">
{These subroutines would normally be in a library, but they are shown here for clarity.}
 
 
function GetAllProperDivisors(N: Integer;var IA: TIntegerDynArray): integer;
{Make a list of all the "proper dividers" for N}
{Proper dividers are the of numbers the divide evenly into N}
var I: integer;
begin
SetLength(IA,0);
for I:=1 to N-1 do
if (N mod I)=0 then
begin
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=I;
end;
Result:=Length(IA);
end;
 
 
function GetAllDivisors(N: Integer;var IA: TIntegerDynArray): integer;
{Make a list of all the "proper dividers" for N, Plus N itself}
begin
Result:=GetAllProperDivisors(N,IA)+1;
SetLength(IA,Length(IA)+1);
IA[High(IA)]:=N;
end;
 
 
 
procedure ProductOfDivisors(Memo: TMemo);
var I,J,P: integer;
var IA: TIntegerDynArray;
var S: string;
begin
S:='';
for I:=1 to 50 do
begin
GetAllDivisors(I,IA);
P:=1;
for J:=0 to High(IA) do P:=P * IA[J];
S:=S+Format('%12D',[P]);
If (I mod 5)=0 then S:=S+CRLF;
end;
Memo.Lines.Add(S);
end;
 
</syntaxhighlight>
{{out}}
<pre>
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
Elapsed Time: 1.418 ms.
</pre>
 
 
=={{header|Factor}}==
{{works with|Factor|0.99 2020-08-14}}
<langsyntaxhighlight lang="factor">USING: grouping io math.primes.factors math.ranges prettyprint
sequences ;
 
"Product of divisors for the first 50 positive integers:" print
50 [1,b] [ divisors product ] map 5 group simple-table.</langsyntaxhighlight>
{{out}}
<pre>
Line 723 ⟶ 866:
 
=={{header|Fortran}}==
<langsyntaxhighlight lang="fortran"> program divprod
implicit none
integer divis(50), i, j
Line 734 ⟶ 877:
write (*,'(I10)',advance='no') divis(i)
30 if (i/5 .ne. (i-1)/5) write (*,*)
end program</langsyntaxhighlight>
 
{{out}}
Line 748 ⟶ 891:
2116 47 254803968 343 125000</pre>
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">dim p as ulongint
for n as uinteger = 1 to 50
p = n
Line 756 ⟶ 899:
print p,
next n
</syntaxhighlight>
</lang>
{{out}}
<pre>1 2 3 8 5 36
Line 768 ⟶ 911:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 800 ⟶ 943:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 818 ⟶ 961:
 
=={{header|GW-BASIC}}==
<langsyntaxhighlight lang="gwbasic">
10 FOR N = 1 TO 50
20 P# = N
Line 825 ⟶ 968:
50 NEXT I
60 PRINT P#,
70 NEXT N</langsyntaxhighlight>
{{out}}
<pre>
Line 835 ⟶ 978:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List.Split (chunksOf)
 
------------------------- DIVISORS -----------------------
Line 872 ⟶ 1,015:
 
justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)</langsyntaxhighlight>
{{Out}}
<pre>Sums of divisors of [1..100]:
Line 918 ⟶ 1,061:
782757789696 97 941192 970299 1000000000</pre>
 
=={{header|J}}==
<syntaxhighlight lang="j"> {{ */ */@>,{ (^ i.@>:)&.>/ __ q: y }}@>:i.5 10x
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</syntaxhighlight>
=={{header|Java}}==
{{trans|C++}}
<langsyntaxhighlight lang="java">public class ProductOfDivisors {
private static long divisorCount(long n) {
long total = 1;
Line 956 ⟶ 1,106:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 978 ⟶ 1,128:
Since a `divisors` function is more likely to be generally useful than a "product of divisors"
function, this entry implements the latter in terms of the former, without any appreciable cost because a streaming approach is used.
<langsyntaxhighlight lang="jq"># divisors as an unsorted stream
def divisors:
if . == 1 then 1
Line 1,001 ⟶ 1,151:
# For pretty-printing
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
</syntaxhighlight>
</lang>
'''Example'''
<langsyntaxhighlight lang="jq">"n product of divisors",
(range(1; 51) | "\(lpad(3)) \(product_of_divisors|lpad(15))")</langsyntaxhighlight>
{{out}}
<pre>
Line 1,060 ⟶ 1,210:
</pre>
'''Example illustrating the use of gojq'''
<langsyntaxhighlight lang="jq">1234567890 | [., product_of_divisors]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,068 ⟶ 1,218:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function proddivisors(n)
Line 1,081 ⟶ 1,231:
print(lpad(proddivisors(i), 10), i % 10 == 0 ? " \n" : "")
end
</langsyntaxhighlight>{{out}}
<pre>
1 2 3 8 5 36 7 64 27 100
Line 1,090 ⟶ 1,240:
</pre>
One-liner version:
<langsyntaxhighlight lang="julia">proddivisors_oneliner(n) = prod(n%i==0 ? i : 1 for i in 1:n)</syntaxhighlight>
 
for i in 1:50
print(lpad(proddivisors_oneliner(i), 10), i % 10 == 0 ? " \n" : "")
end</lang>{{out}}
<pre>
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
</pre>
 
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">import kotlin.math.pow
 
private fun divisorCount(n: Long): Long {
Line 1,146 ⟶ 1,285:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 1,161 ⟶ 1,300:
 
=={{header|MAD}}==
<langsyntaxhighlight MADlang="mad"> NORMAL MODE IS INTEGER
DIMENSION D(50)
THROUGH INIT, FOR I=1, 1, I.G.50
Line 1,171 ⟶ 1,310:
SHOW PRINT FORMAT F5, D(I), D(I+1), D(I+2), D(I+3), D(I+4)
VECTOR VALUES F5 = $5(I10)*$
END OF PROGRAM </langsyntaxhighlight>
{{out}}
<pre> 1 2 3 8 5
Line 1,183 ⟶ 1,322:
41 3111696 43 85184 91125
2116 47 254803968 343 125000</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Divisors/*Apply[Times] /@ Range[50]</syntaxhighlight>
{{out}}
<pre>{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}</pre>
 
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">
divisorProduct = function(n)
ans = 1
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
 
products = []
for n in range(1,50)
products.push(divisorProduct(n))
end for
 
print products.join(", ")
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import math, strutils
 
func divisors(n: Positive): seq[int] =
Line 1,197 ⟶ 1,369:
echo "Product of divisors for the first 50 positive numbers:"
for n in 1..50:
stdout.write ($prod(n.divisors)).align(10), if n mod 5 == 0: '\n' else: ' '</langsyntaxhighlight>
 
{{out}}
Line 1,213 ⟶ 1,385:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Product_of_divisors
Line 1,223 ⟶ 1,395:
$n % $_ or $products[$n] *= $_ for 1 .. $n;
}
printf '' . (('%11d' x 5) . "\n") x 10, @products[1 .. 50];</langsyntaxhighlight>
{{out}}
<pre>
Line 1,240 ⟶ 1,412:
=={{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;">50</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;">"%,12d"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">product</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;">5</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,261 ⟶ 1,433:
=== functional ===
same output
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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;">50</span><span style="color: #0000FF;">),{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}}),</span><span style="color: #7060A8;">product</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;">"%,12d"</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;">5</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
 
=={{header|Pike}}==
{{trans|Python}}
 
<langsyntaxhighlight Pikelang="pike">int product_of_divisors(int n) {
int ans, i, j;
ans = i = j = 1;
Line 1,297 ⟶ 1,469:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 1,316 ⟶ 1,488:
=={{header|Python}}==
===Finding divisors efficiently===
<langsyntaxhighlight Pythonlang="python">def product_of_divisors(n):
assert(isinstance(n, int) and 0 < n)
ans = i = j = 1
Line 1,329 ⟶ 1,501:
if __name__ == "__main__":
print([product_of_divisors(n) for n in range(1,51)])</langsyntaxhighlight>
{{out}}
<pre>[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]</pre>
Line 1,343 ⟶ 1,515:
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,377 ⟶ 1,549:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
 
=={{header|Quackery}}==
Line 1,383 ⟶ 1,555:
<code>factors</code> is defined at [[Factors of an integer#Quackery]].
 
<langsyntaxhighlight Quackerylang="quackery"> [ 1 swap factors witheach * ] is product-of-divisors ( n --> n )
[] []
Line 1,390 ⟶ 1,562:
witheach [ number$ nested join ]
75 wrap$
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,400 ⟶ 1,572:
=={{header|R}}==
This only takes one line.
<langsyntaxhighlight lang="rsplus">sapply(1:50, function(n) prod(c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))</langsyntaxhighlight>
 
=={{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,422 ⟶ 1,594:
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,473 ⟶ 1,645:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX program displays the first N product of divisors (shown in a columnar format).*/
numeric digits 20 /*ensure enough decimal digit precision*/
parse arg n cols . /*obtain optional argument from the CL.*/
Line 1,502 ⟶ 1,674:
end /*k*/ /* [↑] % is the REXX integer division*/
if k*k==x then return p * k /*Was X a square? If so, add √ x */
return p /*return (sigma) sum of the divisors. */</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 1,521 ⟶ 1,693:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
limit = 50
row = 0
Line 1,542 ⟶ 1,714:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,557 ⟶ 1,729:
2116 47 254803968 343 125000
done...
</pre>
 
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪
DUP 1 1 ROT √ '''FOR''' k
OVER k
'''IF''' DUP2 MOD '''NOT'''
'''THEN''' DUP2 SQ ≠ ROT ROT '''IFTE''' *
'''ELSE''' DROP2 '''END'''
'''NEXT''' SWAP DROP
≫ ‘<span style="color:blue">PRODIV</span>’ STO
|
''( n -- div1 *..*divn )''
Initialize result and loop
Put n and k in stack
if k divides n then
multiply by n or k, depending on n ≠ k²
otherwise drop both n and k
get rid of n
|}
The following line of command delivers what is required:
≪ {} 1 50 '''FOR''' j j <span style="color:blue">PRODIV</span> + '''NEXT''' ≫ EVAL
{{out}}
<pre>
1: { 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 }
</pre>
 
=={{header|Ruby}}==
{{trans|C++}}
<langsyntaxhighlight lang="ruby">def divisor_count(n)
total = 1
# Deal with powers of 2 first
Line 1,597 ⟶ 1,801:
print "\n"
end
end</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 1,611 ⟶ 1,815:
2116 47 254803968 343 125000</pre>
 
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">1..50 -> map { .divisors.prod }.say # simple
1..50 -> map {|n| isqrt(n**tau(n)) }.say # more efficient</syntaxhighlight>
{{out}}
<pre>
[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]
</pre>
 
=={{header|Verilog}}==
<langsyntaxhighlight Veriloglang="verilog">module main;
integer p, n, i;
Line 1,625 ⟶ 1,836:
$finish ;
end
endmodule</langsyntaxhighlight>
 
=={{header|VTL-2}}==
This sample only shows the divisor products of the first 20 numbers as (the original) VTL-2 only handles numbers in the range 0-65535. The divisor product of 24 would overflow.<br>
Note, all VTL-2 operators are single characters, however though the "<" operator does a lexx-than test, the ">" operator tests greater-than-or-equal.<br>
<langsyntaxhighlight VTL2lang="vtl2">100 M=20
110 I=0
120 I=I+1
Line 1,657 ⟶ 1,868:
350 #=I/5*0+%=0=0*370
360 ?=""
370 #=I<M*230</langsyntaxhighlight>
{{out}}
<pre>
Line 1,669 ⟶ 1,880:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./math" for Int, Nums
import "./fmt" for Fmt
 
System.print("The products of positive divisors for the first 50 positive integers are:")
Line 1,676 ⟶ 1,887:
Fmt.write("$9d ", Nums.prod(Int.divisors(i)))
if (i % 5 == 0) System.print()
}</langsyntaxhighlight>
 
{{out}}
Line 1,694 ⟶ 1,905:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func ProdDiv(N); \Return product of divisors of N
int N, Prod, Div;
[Prod:= 1;
Line 1,710 ⟶ 1,921:
C:= C+1;
if rem(C/5) = 0 then CrLf(0)];
]</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/305807...354454"