Rosetta Code

Product of divisors: Difference between revisions

Page Discussion

Product of divisors (view source)

Revision as of 11:24, 28 August 2022

1,599 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(J)
m (syntax highlighting fixup automation)
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|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. PRODUCT-OF-DIVISORS.
 
Line 592:
DISPLAY OUT-LINE,
MOVE SPACES TO OUT-LINE,
MOVE 1 TO LINE-PTR.</langsyntaxhighlight>
{{out}}
<pre> 1 2 3 8 5
Line 606:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub divprod(n: uint32): (prod: uint32) is
Line 631:
end if;
n := n + 1;
end loop;</langsyntaxhighlight>
 
{{out}}
Line 648:
=={{header|D}}==
{{trans|C++}}
<langsyntaxhighlight lang="d">import std.math;
import std.stdio;
 
Line 686:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50positive integers:
Line 702:
=={{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:
 
=={{header|Fortran}}==
<langsyntaxhighlight lang="fortran"> program divprod
implicit none
integer divis(50), i, j
Line 734:
write (*,'(I10)',advance='no') divis(i)
30 if (i/5 .ne. (i-1)/5) write (*,*)
end program</langsyntaxhighlight>
 
{{out}}
Line 748:
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:
print p,
next n
</syntaxhighlight>
</lang>
{{out}}
<pre>1 2 3 8 5 36
Line 768:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 800:
}
}
}</langsyntaxhighlight>
 
{{out}}
Line 818:
 
=={{header|GW-BASIC}}==
<langsyntaxhighlight lang="gwbasic">
10 FOR N = 1 TO 50
20 P# = N
Line 825:
50 NEXT I
60 PRINT P#,
70 NEXT N</langsyntaxhighlight>
{{out}}
<pre>
Line 835:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List.Split (chunksOf)
 
------------------------- DIVISORS -----------------------
Line 872:
 
justifyRight :: Int -> Char -> String -> String
justifyRight n c = (drop . length) <*> (replicate n c <>)</langsyntaxhighlight>
{{Out}}
<pre>Sums of divisors of [1..100]:
Line 919:
 
=={{header|J}}==
<langsyntaxhighlight Jlang="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</langsyntaxhighlight>
=={{header|Java}}==
{{trans|C++}}
<langsyntaxhighlight lang="java">public class ProductOfDivisors {
private static long divisorCount(long n) {
long total = 1;
Line 963:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 985:
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,008:
# 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,067:
</pre>
'''Example illustrating the use of gojq'''
<langsyntaxhighlight lang="jq">1234567890 | [., product_of_divisors]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,075:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Primes
 
function proddivisors(n)
Line 1,088:
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,097:
</pre>
One-liner version:
<langsyntaxhighlight lang="julia">proddivisors_oneliner(n) = prod(n%i==0 ? i : 1 for i in 1:n)</langsyntaxhighlight>
 
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">import kotlin.math.pow
 
private fun divisorCount(n: Long): Long {
Line 1,142:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 1,157:
 
=={{header|MAD}}==
<langsyntaxhighlight MADlang="mad"> NORMAL MODE IS INTEGER
DIMENSION D(50)
THROUGH INIT, FOR I=1, 1, I.G.50
Line 1,167:
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,181:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Divisors/*Apply[Times] /@ Range[50]</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>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import math, strutils
 
func divisors(n: Positive): seq[int] =
Line 1,198:
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,214:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Product_of_divisors
Line 1,224:
$n % $_ or $products[$n] *= $_ for 1 .. $n;
}
printf '' . (('%11d' x 5) . "\n") x 10, @products[1 .. 50];</langsyntaxhighlight>
{{out}}
<pre>
Line 1,241:
=={{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,262:
=== 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,298:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 1,317:
=={{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,330:
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,344:
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,378:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
 
=={{header|Quackery}}==
Line 1,384:
<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,391:
witheach [ number$ nested join ]
75 wrap$
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,401:
=={{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,423:
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,474:
 
=={{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,503:
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,522:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
limit = 50
row = 0
Line 1,543:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,562:
=={{header|Ruby}}==
{{trans|C++}}
<langsyntaxhighlight lang="ruby">def divisor_count(n)
total = 1
# Deal with powers of 2 first
Line 1,598:
print "\n"
end
end</langsyntaxhighlight>
{{out}}
<pre>Product of divisors for the first 50 positive integers:
Line 1,614:
 
=={{header|Verilog}}==
<langsyntaxhighlight Veriloglang="verilog">module main;
integer p, n, i;
Line 1,626:
$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,658:
350 #=I/5*0+%=0=0*370
360 ?=""
370 #=I<M*230</langsyntaxhighlight>
{{out}}
<pre>
Line 1,670:
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang="ecmascript">import "/math" for Int, Nums
import "/fmt" for Fmt
 
Line 1,677:
Fmt.write("$9d ", Nums.prod(Int.divisors(i)))
if (i % 5 == 0) System.print()
}</langsyntaxhighlight>
 
{{out}}
Line 1,695:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func ProdDiv(N); \Return product of divisors of N
int N, Prod, Div;
[Prod:= 1;
Line 1,711:
C:= C+1;
if rem(C/5) = 0 then CrLf(0)];
]</langsyntaxhighlight>
 
{{out}}
Thundergnat
10,333

edits

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