Product of divisors: Difference between revisions

Line 11:

<~~lang~~ 11l>F product_of_divisors(n)

<syntaxhighlight 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)))</~~lang~~>

print((1..50).map(n -> product_of_divisors(n)))</syntaxhighlight>

Line 33:

=={{header|Action!}}==

<~~lang~~ ~~Action~~!>INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

<syntaxhighlight lang="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</~~lang~~>

RETURN</syntaxhighlight>

[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}}==

<~~lang~~ algol68>BEGIN # product of divisors - transaltion of the Fortran sample #

<syntaxhighlight 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</~~lang~~>

END</syntaxhighlight>

<pre>

Line 105:

<~~lang~~ algol68>BEGIN # find the product of the divisors of the first 100 positive integers #

<syntaxhighlight 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</~~lang~~>

END</syntaxhighlight>

<pre>

Line 164:

=={{header|ALGOL W}}==

<~~lang~~ algolw>begin % product of divisors - transaltion of the Fortran sample %

<syntaxhighlight 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.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 190:

<~~lang~~ algolw>begin % find the product of the divisors of the first 100 positive integers %

<syntaxhighlight 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.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 251:

=={{header|APL}}==

<~~lang~~ ~~APL~~>divprod ← ×/(⍸0=⍳|⊢)

<syntaxhighlight lang="apl">divprod ← ×/(⍸0=⍳|⊢)

10 5 ⍴ divprod¨ ⍳50</~~lang~~>

10 5 ⍴ divprod¨ ⍳50</syntaxhighlight>

<pre> 1 2 3 8 5

Line 267:

=={{header|Arturo}}==

<~~lang~~ rebol>loop split.every:5 to [:string] map 1..50 => [product factors &] 'line [

<syntaxhighlight lang="rebol">loop split.every:5 to [:string] map 1..50 => [product factors &] 'line [

print map line 'i -> pad i 10

]</~~lang~~>

]</syntaxhighlight>

Line 285:

=={{header|AWK}}==

# syntax: GAWK -f PRODUCT_OF_DIVISORS.AWK

# converted from Go

Line 315:

return(ans)

}

</syntaxhighlight>

</lang>

<pre>

Line 327:

=={{header|BASIC}}==

<~~lang~~ basic>10 N = 50

<syntaxhighlight 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</~~lang~~>

90 FOR I=1 TO N: PRINT D(I),: NEXT</syntaxhighlight>

<pre> 1 2 3 8 5

Line 350:

==={{header|BASIC256}}===

<~~lang~~ ~~BASIC256~~>for n = 1 to 50

<syntaxhighlight lang="basic256">for n = 1 to 50

p = n

for i = 2 to n/2

Line 358:

print p; chr(9);

next n

end</~~lang~~>

end</syntaxhighlight>

==={{header|PureBasic}}===

<~~lang~~ ~~PureBasic~~>OpenConsole()

<syntaxhighlight lang="purebasic">OpenConsole()

For n.i = 1 To 50

p = n

Line 371:

Next n

Input()

CloseConsole()</~~lang~~>

CloseConsole()</syntaxhighlight>

==={{header|QBasic}}===

<~~lang~~ ~~QBasic~~>FOR n = 1 TO 50

<syntaxhighlight lang="qbasic">FOR n = 1 TO 50

p = n

FOR i = 2 TO n / 2

Line 384:

PRINT USING "###########"; p;

NEXT n

END</~~lang~~>

END</syntaxhighlight>

==={{header|True BASIC}}===

<~~lang~~ qbasic>FOR n = 1 TO 50

<syntaxhighlight lang="qbasic">FOR n = 1 TO 50

LET p = n

FOR i = 2 TO n/2

Line 395:

PRINT p,

NEXT n

END</~~lang~~>

END</syntaxhighlight>

==={{header|Yabasic}}===

<~~lang~~ yabasic>for n = 1 to 50

<syntaxhighlight lang="yabasic">for n = 1 to 50

p = n

for i = 2 to n/2

Line 406:

print p using "###########";

next n

end</~~lang~~>

end</syntaxhighlight>

=={{header|BQN}}==

<~~lang~~ bqn>(⊢(×´⊢/˜ 0=|˜ )1+↕)¨∘‿5⥊1+↕50</~~lang~~>

<pre>┌─

Line 425:

=={{header|C}}==

<~~lang~~ c>#include <math.h>

<syntaxhighlight lang="c">#include <math.h>

#include <stdio.h>

Line 470:

return 0;

}</~~lang~~>

}</syntaxhighlight>

<pre>Product of divisors for the first 50 positive integers:

Line 485:

=={{header|C++}}==

<~~lang~~ cpp>#include <cmath>

<syntaxhighlight lang="cpp">#include <cmath>

#include <iomanip>

#include <iostream>

Line 521:

std::cout << '\n';

}

}</~~lang~~>

}</syntaxhighlight>

Line 539:

=={{header|Common 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>

=={{header|COBOL}}==

<~~lang~~ cobol> IDENTIFICATION DIVISION.

<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.

PROGRAM-ID. PRODUCT-OF-DIVISORS.

Line 592:

DISPLAY OUT-LINE,

MOVE SPACES TO OUT-LINE,

MOVE 1 TO LINE-PTR.</~~lang~~>

MOVE 1 TO LINE-PTR.</syntaxhighlight>

<pre> 1 2 3 8 5

Line 606:

=={{header|Cowgol}}==

<~~lang~~ cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

sub divprod(n: uint32): (prod: uint32) is

Line 631:

end if;

n := n + 1;

end loop;</~~lang~~>

end loop;</syntaxhighlight>

Line 648:

=={{header|D}}==

<~~lang~~ d>import std.math;

<syntaxhighlight lang="d">import std.math;

import std.stdio;

Line 686:

}

}</~~lang~~>

}</syntaxhighlight>

<pre>Product of divisors for the first 50positive integers:

Line 702:

=={{header|Factor}}==

<~~lang~~ factor>USING: grouping io math.primes.factors math.ranges prettyprint

<syntaxhighlight 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.</~~lang~~>

50 [1,b] [ divisors product ] map 5 group simple-table.</syntaxhighlight>

<pre>

Line 723:

=={{header|Fortran}}==

<~~lang~~ fortran> program divprod

<syntaxhighlight 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</~~lang~~>

end program</syntaxhighlight>

Line 748:

2116 47 254803968 343 125000</pre>

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>dim p as ulongint

<syntaxhighlight lang="freebasic">dim p as ulongint

for n as uinteger = 1 to 50

p = n

Line 756:

print p,

next n

</syntaxhighlight>

</lang>

<pre>1 2 3 8 5 36

Line 768:

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 800:

}

}</~~lang~~>

}</syntaxhighlight>

Line 818:

=={{header|GW-BASIC}}==

<~~lang~~ gwbasic>

10 FOR N = 1 TO 50

20 P# = N

Line 825:

50 NEXT I

60 PRINT P#,

70 NEXT N</~~lang~~>

70 NEXT N</syntaxhighlight>

<pre>

Line 835:

=={{header|Haskell}}==

<~~lang~~ haskell>import Data.List.Split (chunksOf)

<syntaxhighlight lang="haskell">import Data.List.Split (chunksOf)

------------------------- DIVISORS -----------------------

Line 872:

justifyRight :: Int -> Char -> String -> String

justifyRight n c = (drop . length) <*> (replicate n c <>)</~~lang~~>

justifyRight n c = (drop . length) <*> (replicate n c <>)</syntaxhighlight>

<pre>Sums of divisors of [1..100]:

Line 919:

=={{header|J}}==

<~~lang~~ J> {{ */ */@>,{ (^ i.@>:)&.>/ __ q: y }}@>:i.5 10x

<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</~~lang~~>

41 3111696 43 85184 91125 2116 47 254803968 343 125000</syntaxhighlight>

=={{header|Java}}==

<~~lang~~ java>public class ProductOfDivisors {

<syntaxhighlight lang="java">public class ProductOfDivisors {

private static long divisorCount(long n) {

long total = 1;

Line 963:

}

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ jq># divisors as an unsorted stream

<syntaxhighlight 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'''

<~~lang~~ jq>"n product of divisors",

<syntaxhighlight lang="jq">"n product of divisors",

(range(1; 51) | "\(lpad(3)) \(product_of_divisors|lpad(15))")</~~lang~~>

(range(1; 51) | "\(lpad(3)) \(product_of_divisors|lpad(15))")</syntaxhighlight>

<pre>

Line 1,067:

</pre>

'''Example illustrating the use of gojq'''

<~~lang~~ jq>1234567890 | [., product_of_divisors]

<syntaxhighlight lang="jq">1234567890 | [., product_of_divisors]

</syntaxhighlight>

</lang>

<pre>

Line 1,075:

=={{header|Julia}}==

<~~lang~~ julia>using Primes

<syntaxhighlight lang="julia">using Primes

function proddivisors(n)

Line 1,088:

print(lpad(proddivisors(i), 10), i % 10 == 0 ? " \n" : "")

end

</~~lang~~>{{out}}

</syntaxhighlight>{{out}}

<pre>

1 2 3 8 5 36 7 64 27 100

Line 1,097:

</pre>

One-liner version:

<~~lang~~ julia>proddivisors_oneliner(n) = prod(n%i==0 ? i : 1 for i in 1:n)</~~lang~~>

<syntaxhighlight lang="julia">proddivisors_oneliner(n) = prod(n%i==0 ? i : 1 for i in 1:n)</syntaxhighlight>

=={{header|Kotlin}}==

<~~lang~~ scala>import kotlin.math.pow

<syntaxhighlight lang="scala">import kotlin.math.pow

private fun divisorCount(n: Long): Long {

Line 1,142:

}

}</~~lang~~>

}</syntaxhighlight>

<pre>Product of divisors for the first 50 positive integers:

Line 1,157:

=={{header|MAD}}==

<~~lang~~ ~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="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 </~~lang~~>

END OF PROGRAM </syntaxhighlight>

<pre> 1 2 3 8 5

Line 1,181:

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<~~lang~~ ~~Mathematica~~>Divisors/*Apply[Times] /@ Range[50]</~~lang~~>

<syntaxhighlight lang="mathematica">Divisors/*Apply[Times] /@ Range[50]</syntaxhighlight>

=={{header|Nim}}==

<~~lang~~ ~~Nim~~>import math, strutils

<syntaxhighlight lang="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: ' '</~~lang~~>

stdout.write ($prod(n.divisors)).align(10), if n mod 5 == 0: '\n' else: ' '</syntaxhighlight>

Line 1,214:

=={{header|Perl}}==

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight 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];</~~lang~~>

printf '' . (('%11d' x 5) . "\n") x 10, @products[1 .. 50];</syntaxhighlight>

<pre>

Line 1,241:

=={{header|Phix}}==

=== imperative ===

for i=1 to 50 do

printf(1,"%,12d",{product(factors(i,1))})

if remainder(i,5)=0 then puts(1,"\n") end if

end for

<pre>

Line 1,262:

=== functional ===

same output

sequence r = apply(apply(true,factors,{tagset(50),{1}}),product)

puts(1,join_by(apply(true,sprintf,{{"%,12d"},r}),1,5,""))

=={{header|Pike}}==

<~~lang~~ ~~Pike~~>int product_of_divisors(int n) {

<syntaxhighlight lang="pike">int product_of_divisors(int n) {

int ans, i, j;

ans = i = j = 1;

Line 1,298:

}

return 0;

}</~~lang~~>

}</syntaxhighlight>

Line 1,317:

=={{header|Python}}==

===Finding divisors efficiently===

<~~lang~~ ~~Python~~>def product_of_divisors(n):

<syntaxhighlight lang="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)])</~~lang~~>

print([product_of_divisors(n) for n in range(1,51)])</syntaxhighlight>

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.

<~~lang~~ python>'''Sums and products of divisors'''

<syntaxhighlight lang="python">'''Sums and products of divisors'''

from math import floor, sqrt

Line 1,378:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

=={{header|Quackery}}==

Line 1,384:

<code>factors</code> is defined at [[Factors of an integer#Quackery]].

<~~lang~~ ~~Quackery~~> [ 1 swap factors witheach * ] is product-of-divisors ( n --> n )

<syntaxhighlight lang="quackery"> [ 1 swap factors witheach * ] is product-of-divisors ( n --> n )

[] []

Line 1,391:

witheach [ number$ nested join ]

75 wrap$

</syntaxhighlight>

</lang>

Line 1,401:

=={{header|R}}==

This only takes one line.

<~~lang~~ rsplus>sapply(1:50, function(n) prod(c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))</~~lang~~>

<syntaxhighlight lang="rsplus">sapply(1:50, function(n) prod(c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))</syntaxhighlight>

=={{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.

<lang ~~perl6~~>use Prime::Factor:ver<0.3.0+>;

<syntaxhighlight lang="raku" line>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</~~lang~~>

.batch(5)».&comma».fmt("%16s").join("\n"); # display formatting</syntaxhighlight>

<pre>Tau function - first 100:

Line 1,474:

=={{header|REXX}}==

<~~lang~~ rexx>/*REXX program displays the first N product of divisors (shown in a columnar format).*/

<syntaxhighlight 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. */</~~lang~~>

return p /*return (sigma) sum of the divisors. */</syntaxhighlight>

<pre>

Line 1,522:

=={{header|Ring}}==

<~~lang~~ ring>

limit = 50

row = 0

Line 1,543:

see "done..." + nl

</syntaxhighlight>

</lang>

<pre>

Line 1,562:

=={{header|Ruby}}==

<~~lang~~ ruby>def divisor_count(n)

<syntaxhighlight lang="ruby">def divisor_count(n)

total = 1

# Deal with powers of 2 first

Line 1,598:

print "\n"

end

end</~~lang~~>

end</syntaxhighlight>

<pre>Product of divisors for the first 50 positive integers:

Line 1,614:

=={{header|Verilog}}==

<~~lang~~ ~~Verilog~~>module main;

<syntaxhighlight lang="verilog">module main;

integer p, n, i;

Line 1,626:

$finish ;

end

endmodule</~~lang~~>

endmodule</syntaxhighlight>

=={{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.

Note, all VTL-2 operators are single characters, however though the "<" operator does a lexx-than test, the ">" operator tests greater-than-or-equal.

<~~lang~~ ~~VTL2~~>100 M=20

<syntaxhighlight lang="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</~~lang~~>

370 #=I<M*230</syntaxhighlight>

<pre>

Line 1,670:

<~~lang~~ ecmascript>import "/math" for Int, Nums

<syntaxhighlight 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()

}</~~lang~~>

}</syntaxhighlight>

Line 1,695:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>func ProdDiv(N); \Return product of divisors of N

<syntaxhighlight lang="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)];

]</~~lang~~>

]</syntaxhighlight>