Tau function: Difference between revisions
Not a robot (talk | contribs) (Add PL/I) |
(Added C# example) |
||
(38 intermediate revisions by 22 users not shown) | |||
Line 16:
{{trans|Python}}
<
V ans = 0
V i = 1
Line 29:
R ans
print((1..100).map(n -> tau(n)))</
{{out}}
<pre>
[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]
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */
/* program taufunction64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ MAXI, 100
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .asciz " @ "
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
mov x0,#1 // factor number one
bl displayResult
mov x0,#2 // factor number two
bl displayResult
mov x2,#3 // begin number three
1: // begin loop
mov x5,#2 // divisor counter
mov x4,#2 // first divisor 1
2:
udiv x0,x2,x4 // compute divisor 2
msub x3,x0,x4,x2 // remainder
cmp x3,#0
bne 3f // remainder = 0 ?
cmp x0,x4 // same divisor ?
add x3,x5,1
add x6,x5,2
csel x5,x3,x6,eq
3:
add x4,x4,#1 // increment divisor
cmp x4,x0 // divisor 1 < divisor 2
blt 2b // yes -> loop
mov x0,x5 // equal -> display
bl displayResult
add x2,x2,1
cmp x2,MAXI // end ?
bls 1b // no -> loop
ldr x0,qAdrszCarriageReturn
bl affichageMess
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
/***************************************************/
/* display message number */
/***************************************************/
/* x0 contains the number */
displayResult:
stp x1,lr,[sp,-16]! // save registres
ldr x1,qAdrsZoneConv
bl conversion10 // call décimal conversion
strb wzr,[x1,x0]
ldr x0,qAdrsMessResult
ldr x1,qAdrsZoneConv // insert conversion in message
bl strInsertAtCharInc
bl affichageMess // display message
ldp x1,lr,[sp],16 // restaur des 2 registres
ret
qAdrsMessResult: .quad sMessResult
qAdrsZoneConv: .quad sZoneConv
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
<pre>
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
</pre>
=={{header|Action!}}==
<
CARD result,p,count
Line 74 ⟶ 171:
PrintC(divCount) Put(32)
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Tau_function.png Screenshot from Atari 8-bit computer]
Line 84 ⟶ 181:
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
</pre>
=={{header|ALGOL 68}}==
{{Trans|ALGOL W}}{{Trans|C++}}
<syntaxhighlight lang="algol68">BEGIN # find the count of the divisors of the first 100 positive integers #
# calculates the number of divisors of v #
PROC divisor count = ( INT v )INT:
BEGIN
INT total := 1, n := v;
# Deal with powers of 2 first #
WHILE NOT ODD n DO
total +:= 1;
n OVERAB 2
OD;
# Odd prime factors up to the square root #
FOR p FROM 3 BY 2 WHILE ( p * p ) <= n DO
INT count := 1;
WHILE n MOD p = 0 DO
count +:= 1;
n OVERAB p
OD;
total *:= count
OD;
# If n > 1 then it's prime #
IF n > 1 THEN total *:= 2 FI;
total
END # divisor_count # ;
BEGIN
INT limit = 100;
print( ( "Count of divisors for the first ", whole( limit, 0 ), " positive integers:" ) );
FOR n TO limit DO
IF n MOD 20 = 1 THEN print( ( newline ) ) FI;
print( ( whole( divisor count( n ), -4 ) ) )
OD
END
END</syntaxhighlight>
{{out}}
<pre>
Count of divisors for the first 100 positive integers:
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
</pre>
=={{header|ALGOL-M}}==
<syntaxhighlight lang="ALGOL">
begin
% return the value of n mod m %
integer function mod(n, m);
integer n, m;
begin
mod := n - m * (n / m);
end;
% return the tau value (i.e, number of divisors) of n %
integer function tau(n);
integer n;
begin
integer i, t, limit;
if n < 3 then
t := n
else
begin
t := 2;
limit := (n + 1) / 2;
for i := 2 step 1 until limit do
begin
if mod(n, i) = 0 then t := t + 1;
end;
end;
tau := t;
end;
% test by printing the tau value of the first 100 numbers %
integer i;
write("Count of divisors for first 100 numbers:");
write("");
for i := 1 step 1 until 100 do
begin
writeon(tau(i));
if mod(i,10) = 0 then write(""); % print 10 across %
end;
end
</syntaxhighlight>
{{out}}
<pre>
Count of divisors for first 100 numbers:
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
</pre>
=={{header|ALGOL W}}==
{{Trans|C++}}
<
% calculates the number of divisors of v %
integer procedure divisor_count( integer value v ) ; begin
Line 109 ⟶ 308:
total := total * count
end while_p_x_p_le_n ;
% If n > 1 then it
if n > 1 then total := total * 2;
total
Line 122 ⟶ 321:
end for_n
end
end.</
{{out}}
<pre>
Line 135 ⟶ 334:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
tau¨ 5 20⍴⍳100</
{{out}}
<pre>1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 145 ⟶ 344:
=={{header|AppleScript}}==
<
if (n < 1) then return 0
set counter to 2
Line 168 ⟶ 367:
set output to output as text
set AppleScript's text item delimiters to astid
return output</
{{output}}
<
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"</
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
/* program taufunction.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
.equ MAXI, 100
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .asciz " @ "
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
mov r0,#1 @ factor number one
bl displayResult
mov r0,#2 @ factor number two
bl displayResult
mov r2,#3 @ begin number three
1: @ begin loop
mov r5,#2 @ divisor counter
mov r4,#2 @ first divisor 1
2:
udiv r0,r2,r4 @ compute divisor 2
mls r3,r0,r4,r2 @ remainder
cmp r3,#0
bne 3f @ remainder = 0 ?
cmp r0,r4 @ same divisor ?
addeq r5,r5,#1 @ yes increment one
addne r5,r5,#2 @ no increment two
3:
add r4,r4,#1 @ increment divisor
cmp r4,r0 @ divisor 1 < divisor 2
blt 2b @ yes -> loop
mov r0,r5 @ equal -> display
bl displayResult
add r2,#1 @
cmp r2,#MAXI @ end ?
bls 1b @ no -> loop
ldr r0,iAdrszCarriageReturn
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
/***************************************************/
/* display message number */
/***************************************************/
/* r0 contains the number */
displayResult:
push {r1,r2,lr} @ save registers
ldr r1,iAdrsZoneConv
bl conversion10 @ call décimal conversion
mov r2,#0
strb r2,[r1,r0]
ldr r0,iAdrsMessResult
ldr r1,iAdrsZoneConv @ insert conversion in message
bl strInsertAtCharInc
bl affichageMess @ display message
pop {r1,r2,pc} @ restaur des registres
iAdrsMessResult: .int sMessResult
iAdrsZoneConv: .int sZoneConv
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
<pre>
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
</pre>
=={{header|Arturo}}==
<
loop split.every:20 1..100 => [
print map & => [pad to :string tau & 3]
]</
{{out}}
Line 193 ⟶ 490:
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</pre>
=={{header|Asymptote}}==
<syntaxhighlight lang="Asymptote">write("The tau functions for the first 100 positive integers are:");
for (int N = 1; N <= 100; ++N) {
int T;
if (N < 3) {
T = N;
} else {
T = 2;
for (int A = 2; A <= (N + 1) / 2; ++A) {
if (N % A == 0) T = T + 1;
}
}
write(format("%3d", T), suffix=none);
if (N % 10 == 0) write("");
}</syntaxhighlight>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">loop 100
result .= SubStr(" " Tau(A_Index), -3) . (Mod(A_Index, 10) ? " " : "`n")
MsgBox % result
return
Tau(n){
return StrSplit(Factors(n), ",").Count()
}
Factors(n) {
Loop, % floor(sqrt(n))
v := A_Index = 1 ? 1 "," n : mod(n,A_Index) ? v : v "," A_Index "," n//A_Index
Sort, v, N U D,
Return, v
}</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f TAU_FUNCTION.AWK
BEGIN {
Line 215 ⟶ 555:
return(count)
}
</syntaxhighlight>
{{out}}
<pre>
Line 233 ⟶ 573:
=={{header|BASIC}}==
{{trans|C}}
<
20 FOR I=1 TO 100
30 N=I: GOSUB 100
Line 250 ⟶ 590:
180 IF P*P<=N GOTO 140
190 IF N>1 THEN T=T*2
200 RETURN</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 257 ⟶ 597:
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</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">print "The tau functions for the first 100 positive integers are:"
print
for N = 1 to 100
if N < 3 then
T = N
else
T = 2
for A = 2 to (N+1)\2
if N mod A = 0 then T += 1
next A
end if
print " "; T;
if N mod 10 = 0 then print
next N
end</syntaxhighlight>
==={{header|Gambas}}===
<syntaxhighlight lang="vbnet">Public Sub Main()
Print "The tau functions for the first 100 positive integers are:\n"
For i As Integer = 1 To 100
Print Format$(numdiv(i), "####");
If i Mod 10 = 0 Then Print
Next
End
Public Function numdiv(n As Integer) As Integer
Dim c As Integer = 1
For i As Integer = 1 To (n + 1) \ 2
If n Mod i = 0 Then c += 1
Next
If n = 1 Then c -= 1
Return c
End Function</syntaxhighlight>
{{out}}
<pre>Same as FreeBASIC entry.</pre>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
==={{header|MSX Basic}}===
{{works with|MSX BASIC|any}}
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.
==={{header|QBasic}}===
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">PRINT "The tau functions for the first 100 positive integers are:": PRINT
FOR N = 1 TO 100
IF N < 3 THEN
T = N
ELSE
T = 2
FOR A = 2 TO (N + 1) \ 2
IF N MOD A = 0 THEN T = T + 1
NEXT A
END IF
PRINT USING "###"; T;
IF N MOD 10 = 0 THEN PRINT
NEXT N
END</syntaxhighlight>
==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="vb">print "The tau functions for the first 100 positive integers are:"
print
for N = 1 to 100
if N < 3 then
T = N
else
T = 2
for A = 2 to int((N+1)/2)
if N mod A = 0 then T = T + 1
next A
end if
print using("####", T);
if N mod 10 = 0 then print
next N
end</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">PRINT "The tau functions for the first 100 positive integers are:"
PRINT
FOR N = 1 TO 100
IF N < 3 THEN
LET T = N
ELSE
LET T = 2
FOR A = 2 TO INT((N+1)/2)
IF REMAINDER (N, A) = 0 THEN LET T = T + 1
NEXT A
END IF
PRINT " "; T;
IF REMAINDER (N, 10) = 0 THEN PRINT
NEXT N
END</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM "Tau"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
DECLARE FUNCTION numdiv(n)
FUNCTION Entry ()
PRINT "The tau functions for the first 100 positive integers are:\n"
FOR i = 1 TO 100
PRINT FORMAT$("###", numdiv(i));
IF i MOD 10 = 0 THEN PRINT
NEXT i
END FUNCTION
FUNCTION numdiv(n)
c = 1
FOR i = 1 TO (n+1)\2
IF n MOD i = 0 THEN INC c
NEXT i
IF n = 1 THEN DEC c
RETURN c
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">print "The tau functions for the first 100 positive integers are:\n"
for N = 1 to 100
if N < 3 then
T = N
else
T = 2
for A = 2 to int((N+1)/2)
if mod(N, A) = 0 then T = T + 1 : fi
next A
end if
print T using "###";
if mod(N, 10) = 0 then print : fi
next N
end</syntaxhighlight>
=={{header|bc}}==
<syntaxhighlight lang="bc">define t(n) {
auto a, d, p
for (d = 1; n % 2 == 0; n /= 2) d += 1
for (p = 3; p * p <= n; p += 2) for (a = d; n % p == 0; n /= p) d += a
if (n != 1) d += d
return(d)
}
for (i = 1; i <= 100; ++i) t(i)</syntaxhighlight>
=={{header|BCPL}}==
<
let tau(n) = valof
Line 283 ⟶ 785:
$( writed(tau(n), 3)
if n rem 20 = 0 then wrch('*N')
$)</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 292 ⟶ 794:
=={{header|BQN}}==
<
Tau¨ 5‿20⥊1+↕100</
{{out}}
<pre>┌─
Line 305 ⟶ 807:
=={{header|C}}==
{{trans|C++}}
<
// See https://en.wikipedia.org/wiki/Divisor_function
Line 342 ⟶ 844:
return 0;
}</
{{out}}
<pre>Count of divisors for the first 100 positive integers:
Line 352 ⟶ 854:
=={{header|C++}}==
<
#include <iostream>
Line 382 ⟶ 884:
std::cout << '\n';
}
}</
{{out}}
Line 393 ⟶ 895:
5 4 2 12 4 4 4 8 2 12 4 6 4 4 4 12 2 6 6 9
</pre>
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">
internal class Program
{
private static void Main(string[] args)
{
long limit = 100;
Console.WriteLine($"Count of divisors for the first {limit} positive integers:");
long count = 0;
for (long n = 1; count < limit; ++n)
{
Console.Write($"{DivisorCount(n),3} ");
++count;
if (count % 20 == 0)
{
Console.WriteLine();
}
}
}
private static long DivisorCount(long n)
{
long total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1)
{
++total;
}
// Odd prime factors up to the square root
for (long p = 3; p * p <= n; p += 2)
{
long count = 1;
for (; n % p == 0; n /= p)
{
++count;
}
total *= count;
}
// If n > 1 then it's prime
if (n > 1)
{
total *= 2;
}
return total;
}
}
</syntaxhighlight>
{{out}}
<pre>
Count of divisors for the first 100 positive integers:
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
</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}}==
{{trans|C}}
<
total: int := 1
while n//2 = 0 do
Line 424 ⟶ 1,067:
if n//20=0 then stream$putl(po, "") end
end
end start_up</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 434 ⟶ 1,077:
=={{header|COBOL}}==
{{trans|C}}
<
PROGRAM-ID. TAU-FUNCTION.
Line 498 ⟶ 1,141:
ADD 1 TO F-COUNT,
GO TO ODD-FACTOR-LOOP.
MULTIPLY F-COUNT BY TOTAL.</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 508 ⟶ 1,151:
=={{header|Cowgol}}==
{{trans|C}}
<
typedef N is uint8;
Line 546 ⟶ 1,189:
if n % 20 == 0 then print_nl(); end if;
n := n + 1;
end loop;</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 556 ⟶ 1,199:
=={{header|D}}==
{{trans|C++}}
<
// See https://en.wikipedia.org/wiki/Divisor_function
Line 589 ⟶ 1,232:
}
}
}</
{{out}}
<pre>Count of divisors for the first 100 positive integers:
Line 597 ⟶ 1,240:
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</pre>
=={{header|Dart}}==
{{trans|C++}}
<syntaxhighlight lang="dart">int divisorCount(int n) {
int total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1) total++;
// Odd prime factors up to the square root
for (int p = 3; p * p <= n; p += 2) {
int count = 1;
for (; n % p == 0; n ~/= p) count++;
total *= count;
}
// If n > 1 then it's prime
if (n > 1) total *= 2;
return total;
}
void main() {
const int limit = 100;
print("Count of divisors for the first $limit positive integers:");
for (int n = 1; n <= limit; ++n) {
print(divisorCount(n).toString().padLeft(3));
}
}</syntaxhighlight>
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{Trans|Go}}
<syntaxhighlight lang="delphi">
program Tau_function;
Line 639 ⟶ 1,307:
end;
readln;
end.</
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc nonrec tau(word n) word:
word count, total, p;
total := 1;
while n & 1 = 0 do
total := total + 1;
n := n >> 1
od;
p := 3;
while p*p <= n do
count := 1;
while n % p = 0 do
count := count + 1;
n := n / p
od;
total := total * count;
p := p + 2
od;
if n>1
then total << 1
else total
fi
corp
proc nonrec main() void:
byte n;
for n from 1 upto 100 do
write(tau(n):3);
if n%20=0 then writeln() fi
od
corp</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|Dyalect}}==
Line 645 ⟶ 1,351:
{{trans|Swift}}
<
var n = number
var total = 1
Line 675 ⟶ 1,381:
print("Count of divisors for the first \(limit) positive integers:")
for n in 1..limit {
print(divisorCount(number: n).
print() when n % 20 == 0
}</
{{out}}
Line 687 ⟶ 1,393:
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 </pre>
=={{header|EasyLang}}==
<syntaxhighlight>
func cntdiv n .
i = 1
while i <= sqrt n
if n mod i = 0
cnt += 1
if i <> n div i
cnt += 1
.
.
i += 1
.
return cnt
.
for i to 100
write cntdiv i & " "
.
</syntaxhighlight>
=={{header|EMal}}==
{{trans|Java}}
<syntaxhighlight lang="emal">
fun divisorCount = int by int n
int total = 1
for ; (n & 1) == 0; n /= 2 do ++total end
for int p = 3; p * p <= n; p += 2
int count = 1
for ; n % p == 0; n /= p do ++count end
total *= count
end
if n > 1 do total *= 2 end
return total
end
int limit = 100
writeLine("Count of divisors for the first " + limit + " positive integers:")
for int n = 1; n <= limit; ++n
text value = text!divisorCount(n)
write((" " * (3 - value.length)) + value)
if n % 20 == 0 do writeLine() end
end
</syntaxhighlight>
{{out}}
<pre>
Count of divisors for the first 100 positive integers:
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
</pre>
=={{header|F_Sharp|F#}}==
This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>
<
// Tau function. Nigel Galloway: March 10th., 2021
let tau u=let P=primes32()
Line 697 ⟶ 1,455:
let n=Seq.head P in fG 1 n 1 1 n
[1..100]|>Seq.iter(tau>>printf "%d "); printfn ""
</syntaxhighlight>
{{out}}
<pre>
Line 705 ⟶ 1,463:
=={{header|Factor}}==
{{works with|Factor|0.99 2020-08-14}}
<
math.ranges sequences sequences.extras ;
Line 721 ⟶ 1,479:
[ "%2d |" printf ]
[ dup 10 + [a,b) [ tau "%4d" printf ] each nl ] bi
] each</
{{out}}
<pre>
Line 741 ⟶ 1,499:
=={{header|Fermat}}==
<syntaxhighlight lang="text">Func Tau(t) =
if t<3 then Return(t) else
numdiv:=2;
Line 753 ⟶ 1,511:
for i = 1 to 100 do
!(Tau(i),' ');
od;</
{{out}}<pre>
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</pre>
Line 759 ⟶ 1,517:
=={{header|Forth}}==
{{trans|C++}}
<
1 >r
begin
Line 791 ⟶ 1,549:
100 print_divisor_counts
bye</
{{out}}
Line 804 ⟶ 1,562:
=={{header|FreeBASIC}}==
<
dim as uinteger c = 1
for i as uinteger = 1 to (n+1)\2
Line 816 ⟶ 1,574:
print numdiv(i),
if i mod 10 = 0 then print
next i</
{{out}}
<pre>1 2 2 3 2 4 2 4 3 4
Line 828 ⟶ 1,586:
5 4 2 12 4 4 4 8 2 12
4 6 4 4 4 12 2 6 6 9</pre>
=={{header|Frink}}==
<syntaxhighlight lang="frink">tau[n] := length[allFactors[n]]
for n=1 to 100
print[tau[n] + " "]
println[]</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Go}}==
<
import "fmt"
Line 862 ⟶ 1,631:
}
}
}</
{{out}}
Line 875 ⟶ 1,644:
=={{header|GW-BASIC}}==
<
20 IF N < 3 THEN T=N: GOTO 70
30 T=2
Line 883 ⟶ 1,652:
70 PRINT T;
80 IF N MOD 10 = 0 THEN PRINT
90 NEXT N</
{{out}}
<pre>
Line 899 ⟶ 1,668:
=={{header|Haskell}}==
<
tau n | n <= 0 = error "Not a positive integer"
tau n = go 0 (1, 1)
Line 910 ⟶ 1,679:
| otherwise = go r (yo $ i + 1)
main = print $ map tau [1..100]</
{{out}}
<pre>[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]</pre>
Or using primeFactors from the Data.Numbers.Primes library:
<syntaxhighlight lang="haskell">import Data.Numbers.Primes
import Data.List (group, intercalate, transpose)
import Data.List.Split (chunksOf)
import Text.Printf
----------------------- OEISA000005 ----------------------
oeisA000005 :: [Int]
oeisA000005 = tau <$> [1..]
tau :: Integer -> Int
tau = product . fmap (succ . length) . group . primeFactors
--------------------------- TEST -------------------------
main :: IO ()
main = putStrLn $
(table " " . chunksOf 10 . fmap show . take 100)
oeisA000005
------------------------ FORMATTING ----------------------
table :: String -> [[String]] -> String
table gap rows =
let ws = maximum . fmap length <$> transpose rows
pw = printf . flip intercalate ["%", "s"] . show
in unlines $ intercalate gap . zipWith pw ws <$> rows</syntaxhighlight>
{{Out}}
<pre>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</pre>
=={{header|J}}==
<
echo tau"0 [5 20$>:i.100
exit ''</
{{out}}
<pre>1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 927 ⟶ 1,741:
=={{header|Java}}==
{{trans|D}}
<
private static long divisorCount(long n) {
long total = 1;
Line 959 ⟶ 1,773:
}
}
}</
{{out}}
<pre>Count of divisors for the first 100 positive integers:
Line 973 ⟶ 1,787:
'''Preliminaries'''
See https://rosettacode.org/wiki/Sum_of_divisors#jq for the definition of `divisors` used here.<
# For pretty-printing
Line 980 ⟶ 1,794:
n;
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;</
'''The task'''
<
| nwise(10) | map(lpad(4)) | join("")</
{{out}}
<pre>
Line 1,000 ⟶ 1,814:
=={{header|Julia}}==
Recycles code from http://www.rosettacode.org/wiki/Sequence:_smallest_number_greater_than_previous_term_with_exactly_n_divisors#Julia
<
function numfactors(n)
Line 1,013 ⟶ 1,827:
print(rpad(numfactors(i), 3), i % 25 == 0 ? " \n" : " ")
end
</
<pre>
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
Line 1,023 ⟶ 1,837:
=={{header|Lua}}==
{{trans|Java}}
<
local total = 1
-- Deal with powers of 2 first
Line 1,055 ⟶ 1,869:
print()
end
end</
{{out}}
<pre>Count of divisors for the first 100 positive integers:
Line 1,065 ⟶ 1,879:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{{out}}
<pre>{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}</pre>
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">
tau = function(n)
ans = 0
i = 1
while i * i <= n
if n % i == 0 then
ans += 1
j = floor(n / i)
if j != i then ans += 1
end if
i += 1
end while
return ans
end function
taus = []
for n in range(1, 100)
taus.push(tau(n))
end for
print taus.join(", ")
</syntaxhighlight>
{{out}}
<pre>
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
</pre>
=={{header|Modula-2}}==
{{trans|C}}
<
FROM InOut IMPORT WriteCard, WriteLn;
Line 1,103 ⟶ 1,945:
IF i MOD 20 = 0 THEN WriteLn END
END
END TauFunc.</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 1,112 ⟶ 1,954:
=={{header|Nim}}==
<
func divcount(n: Natural): Natural =
Line 1,123 ⟶ 1,965:
for i in 1..100:
stdout.write ($divcount(i)).align(3)
if i mod 20 == 0: echo()</
{{out}}
Line 1,134 ⟶ 1,976:
=={{header|PARI/GP}}==
<
{{out}}<pre>
[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]</pre>
Line 1,140 ⟶ 1,982:
=={{header|Pascal}}==
{{works with|Extended Pascal}}
<
type
Line 1,182 ⟶ 2,024:
writeLn(f:8, ') = ', tau(i):5)
end
end.</
==={{header|Free Pascal}}===
{{works with|Free Pascal}} and on TIO.RUN. Only test 0..99 for a nicer table.
<
{$IFDEF Windows} {$APPTYPE CONSOLE} {$ENDIF}
function CountDivisors(n: NativeUint): integer;
Line 1,240 ⟶ 2,082:
writeln;
{$Ifdef Windows}readln;{$ENDIF}
end.</
{{out|TIO.RUN}}
<pre>
Line 1,255 ⟶ 2,097:
8|10 5 4 2 12 4 4 4 8 2
9|12 4 6 4 4 4 12 2 6 6 </pre>
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
##
function DivisorsCount(n: integer) := Range(1,n).Count(i -> n.Divs(i));
Range(1,100).Select(n -> DivisorsCount(n)).Println
</syntaxhighlight>
{{out}}
<pre>
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</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use feature 'say';
Line 1,267 ⟶ 2,121:
say "Tau function - first 100:\n" .
((sprintf "@{['%4d' x 100]}", @x[0..100-1]) =~ s/(.{80})/$1\n/gr);</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 1,277 ⟶ 2,131:
=={{header|Phix}}==
=== imperative ===
<!--<
<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;">"%3d"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</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;">20</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>
<!--</
{{out}}
<pre>
Line 1,293 ⟶ 2,147:
=== functional ===
same output
<!--<
<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;">length</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;">"%3d"</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;">20</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))</span>
<!--</
=={{header|PL/I}}==
{{trans|C}}
<
tau: procedure(nn) returns(fixed);
declare (n, nn, tot, pf, cnt) fixed;
Line 1,322 ⟶ 2,176:
if mod(n,20)=0 then put skip;
end;
end taufunc;</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 1,330 ⟶ 2,184:
5 4 2 12 4 4 4 8 2 12 4 6 4 4 4 12 2 6 6 9</pre>
=={{header|PL/M}}==
{{trans|C}}
<syntaxhighlight lang="pli">100H:
/* CP/M BDOS FUNCTIONS */
BDOS: PROCEDURE(F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
PR$CHAR: PROCEDURE(C); DECLARE C BYTE; CALL BDOS(2,C); END PR$CHAR;
PR$STR: PROCEDURE(S); DECLARE S ADDRESS; CALL BDOS(9,S); END PR$STR;
/* PRINT BYTE IN A 3-CHAR COLUMN */
PRINT3: PROCEDURE(N);
DECLARE (N, M) BYTE;
M = 100;
DO WHILE M>0;
IF N>=M
THEN CALL PR$CHAR('0' + (N/M) MOD 10);
ELSE CALL PR$CHAR(' ');
M = M/10;
END;
END PRINT3;
/* TAU FUNCTION */
TAU: PROCEDURE(N) BYTE;
DECLARE (N, TOTAL, COUNT, P) BYTE;
TOTAL = 1;
DO WHILE NOT N;
N = SHR(N,1);
TOTAL = TOTAL + 1;
END;
P = 3;
DO WHILE P*P <= N;
COUNT = 1;
DO WHILE N MOD P = 0;
COUNT = COUNT + 1;
N = N / P;
END;
TOTAL = TOTAL * COUNT;
P = P + 2;
END;
IF N>1 THEN TOTAL = SHL(TOTAL, 1);
RETURN TOTAL;
END TAU;
/* PRINT TAU 1..100 */
DECLARE N BYTE;
DO N=1 TO 100;
CALL PRINT3(TAU(N));
IF N MOD 20=0 THEN CALL PR$STR(.(13,10,'$'));
END;
CALL EXIT;
EOF</syntaxhighlight>
{{out}}
<pre> 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</pre>
=={{header|PureBasic}}==
<
For i=1 To 100
If i<3 : Print(RSet(Str(i),4)) : Continue :EndIf
Line 1,342 ⟶ 2,255:
Input()
EndIf
End</
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4
Line 1,357 ⟶ 2,270:
=={{header|Python}}==
===Using prime factorization===
<
assert(isinstance(n, int))
if n < 0:
Line 1,389 ⟶ 2,302:
if __name__ == "__main__":
print(
===Finding divisors efficiently===
<
assert(isinstance(n, int) and 0 < n)
p
while p * p
while n % p
if n != 1:
t += t
return t
if __name__ == "__main__":
print(
{{out}}
<pre>
===Choosing the right abstraction===
Yet another exercise in defining a '''divisors''' function.
<
from itertools import count, islice
Line 1,497 ⟶ 2,413:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre> 1 2 2 3 2 4 2 4 3 4
Line 1,515 ⟶ 2,431:
<
[] []
Line 1,521 ⟶ 2,437:
witheach [ number$ nested join ]
70 wrap$
</syntaxhighlight>
{{out}}
Line 1,532 ⟶ 2,448:
=={{header|R}}==
This only takes one line.
<
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(define limit 100)
(define (divisor-count n)
(length (filter (λ (x) (zero? (remainder n x))) (range 1 (add1 n)))))
(printf "Count of divisors of the integers from 1 to ~a are~n" limit)
(for ([n (in-range 1 (add1 limit))])
(printf (~a (divisor-count n) #:width 5 #:align 'right))
(when (zero? (remainder n 10))
(newline)))
</syntaxhighlight>
{{out}}
<pre>
Count of divisors of the integers from 1 to 100 are
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
</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"
use Lingua::EN::Numbers;
Line 1,554 ⟶ 2,500:
say "\nDivisor products - first 100:\n", # ID
(1..*).map({ [×] .&divisors })[^100]\ # the task
.batch(5)».&comma».fmt("%16s").join("\n"); # display formatting</
{{out}}
<pre>Tau function - first 100:
Line 1,605 ⟶ 2,551:
=={{header|REXX}}==
simplified,
made ooRexx compatible,
corrected for tau of squares,
corrected for a range with fewer than cols numbers.
If lo=='' | lo==',' Then lo=1 /*Not specified? Then use the default.*/
If hi=='' | hi==',' Then hi=lo+100-1 /*Not specified? Then use the default.*/
If cols=='' Then cols=20
w=2+(hi>45359)
Say 'The number of divisors (tau) from' lo 'to' hi '(inclusive):'
Say ''
Say '-number' center(' tau (number of divisors) ',cols*(w+1)+1,'-')
line=''
c=0
index=lo
Do j=lo To hi
c=c+1
If c//cols=0 Then Do
Say center(index,7) line
line=''
cnt=0
Index=index+cols
End
End /*j*/
If line\=='' Then
Say center(index,7) line /*there any residuals left
Exit 0
/*---------------------------------------------------------------------------------*/
tau: Procedure
Parse Arg x
If x<6 Then /* some low numbers are handled special */
Return 2+(x==4)-(x==1)
tau=0
odd=x//2
Do j=1 by 1 While j*j<x
If odd & j//2=0 Then /* even j can't be a divisor of an odd x*/
Iterate
If x//j==0 Then /* if no remainder, then found a divisor*/
tau=tau+2 /* bump n of divisors */
End
If j*j=x Then /* x is a square */
tau=tau+1 /* its root is a divisor */
Return tau</syntaxhighlight>
{{out|output|text= when using the default input:}}
<pre>
The number of divisors
-number ----------------- tau (number of divisors) ------------------
1
21
41
61
81
</pre>
=={{header|Ring}}==
<
see "The tau functions for the first 100 positive integers are:" + nl
Line 1,674 ⟶ 2,634:
see "" + tau + " "
end
</syntaxhighlight>
Output:
<pre>
Line 1,690 ⟶ 2,650:
4 6 4 4 4 12 2 6 6 9
</pre>
=={{header|RPL}}==
{{trans|Python}}
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL Code
! Python code
|-
|
≪ → n
≪ 0 1
1 n √ '''FOR''' ii
'''IF''' n ii MOD NOT '''THEN'''
SWAP 1 + SWAP
DROP n ii / IP
'''IF''' DUP ii ≠
'''THEN''' SWAP 1 + SWAP '''END END'''
'''NEXT'''
DROP
≫ ≫ ‘TAU’ STO
|
''(n -- tau(n) )''
ans, j = 0, 1
while i*i <= n:
if 0 == n%i:
ans += 1
j = n//i
if j != i:
ans += 1
i += 1
return ans
.
|}
The following line of command delivers what is required:
≪ {} 1 100 '''FOR''' j j TAU + '''NEXT''' ≫ EVAL
{{out}}
<pre>
1: { 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 }
</pre>
===Optimized algorithm===
{| class="wikitable"
! RPL code
! Comment
|-
|
≪
DUP √ DUP FP 0 -1 '''IFTE'''
1 ROT '''FOR''' j
OVER j MOD NOT DUP + +
'''NEXT''' SWAP DROP
≫ ‘TAU’ STO
|
''( n -- tau(n) )''
counter set at -1 if n square, 0 otherwise
while j ≤ n²
add 2 to counter for each dividing j
forget n
|}
=={{header|Ruby}}==
<
def tau(n) = n.prime_division.inject(1){|res, (d, exp)| res *= exp + 1}
(1..100).map{|n| tau(n).to_s.rjust(3) }.each_slice(20){|ar| puts ar.join}
</syntaxhighlight>
{{out}}
<pre> 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6
Line 1,707 ⟶ 2,726:
=={{header|Rust}}==
<
// and n divided by that power of i
fn factor_exponent(n: i32, i: i32) -> (i32, i32) {
Line 1,732 ⟶ 2,751:
print!("{} ", tau(i));
}
}</
Output:
<pre>
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
</pre>
=={{header|S-BASIC}}==
<syntaxhighlight lang="BASIC">
rem - return the value of n mod m
function mod(n, m = integer) = integer
end = n - m * (n / m)
rem - return the tau value (number of divisors) of n
function tau(n = integer) = integer
var i, t, limit = integer
if n < 3 then
t = n
else
begin
t = 2
limit = (n + 1) / 2
for i = 2 to limit
if mod(n, i) = 0 then t = t + 1
next i
end
end = t
rem - test by printing the tau value of the first 100 numbers
var i = integer
print "Number of divisors for first 100 numbers:"
for i = 1 to 100
print using "## "; tau(i);
if mod(i, 10) = 0 then print
next i
end
</syntaxhighlight>
{{out}}
<pre>
Number of divisors for first 100 numbers:
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
</pre>
=={{header|Scala}}==
{{trans|Java}}
<syntaxhighlight lang="Scala">
object TauFunction {
private def divisorCount(n: Long): Long = {
var count = 1L
var number = n
// Deal with powers of 2 first
while ((number & 1L) == 0) {
count += 1
number >>= 1
}
// Odd prime factors up to the square root
var p = 3L
while (p * p <= number) {
var tempCount = 1L
while (number % p == 0) {
tempCount += 1
number /= p
}
count *= tempCount
p += 2
}
// If n > 1 then it's prime
if (number > 1) {
count *= 2
}
count
}
def main(args: Array[String]): Unit = {
val limit = 100
println(s"Count of divisors for the first $limit positive integers:")
for (n <- 1 to limit) {
print(f"${divisorCount(n)}%3d")
if (n % 20 == 0) println()
}
}
}
</syntaxhighlight>
{{out}}
<pre>
Count of divisors for the first 100 positive integers:
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
</pre>
=={{header|Sidef}}==
Built-in:
<
{{out}}
Line 1,748 ⟶ 2,871:
=={{header|Swift}}==
<
// See https://en.wikipedia.org/wiki/Divisor_function
Line 1,784 ⟶ 2,907:
print()
}
}</
{{out}}
Line 1,797 ⟶ 2,920:
=={{header|Tiny BASIC}}==
<
10 LET N = N + 1
IF N < 3 THEN GOTO 100
Line 1,809 ⟶ 2,932:
END
100 LET T = N
GOTO 30</
=={{header|Verilog}}==
<syntaxhighlight lang="verilog">module main;
integer N, T, A;
initial begin
$display("The tau functions for the first 100 positive integers are:\n");
for (N = 1; N <= 100; N=N+1) begin
if (N < 3) T = N;
else begin
T = 2;
for (A = 2; A <= (N+1)/2; A=A+1) begin
if (N % A == 0) T = T + 1;
end
end
$write(T);
if (N % 10 == 0) $display("");
end
$finish ;
end
endmodule</syntaxhighlight>
=={{header|Wren}}==
{{libheader|Wren-math}}
{{libheader|Wren-fmt}}
<
import "./fmt" for Fmt
System.print("The tau functions for the first 100 positive integers are:")
Line 1,821 ⟶ 2,967:
Fmt.write("$2d ", Int.divisors(i).count)
if (i % 20 == 0) System.print()
}</
{{out}}
Line 1,831 ⟶ 2,977:
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
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">int N, D, C;
[Format(3, 0);
for N:= 1 to 100 do
[C:= 0;
for D:= 1 to N do
if rem(N/D) = 0 then C:= C+1;
RlOut(0, float(C));
if rem(N/20) = 0 then CrLf(0);
];
]</syntaxhighlight>
{{out}}
<pre>
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
</pre>
|
Latest revision as of 03:13, 28 June 2024
You are encouraged to solve this task according to the task description, using any language you may know.
Given a positive integer, count the number of its positive divisors.
- Task
Show the result for the first 100 positive integers.
- Related task
11l
F tau(n)
V ans = 0
V i = 1
V j = 1
L i * i <= n
I 0 == n % i
ans++
j = n I/ i
I j != i
ans++
i++
R ans
print((1..100).map(n -> tau(n)))
- Output:
[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]
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */
/* program taufunction64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ MAXI, 100
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .asciz " @ "
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
mov x0,#1 // factor number one
bl displayResult
mov x0,#2 // factor number two
bl displayResult
mov x2,#3 // begin number three
1: // begin loop
mov x5,#2 // divisor counter
mov x4,#2 // first divisor 1
2:
udiv x0,x2,x4 // compute divisor 2
msub x3,x0,x4,x2 // remainder
cmp x3,#0
bne 3f // remainder = 0 ?
cmp x0,x4 // same divisor ?
add x3,x5,1
add x6,x5,2
csel x5,x3,x6,eq
3:
add x4,x4,#1 // increment divisor
cmp x4,x0 // divisor 1 < divisor 2
blt 2b // yes -> loop
mov x0,x5 // equal -> display
bl displayResult
add x2,x2,1
cmp x2,MAXI // end ?
bls 1b // no -> loop
ldr x0,qAdrszCarriageReturn
bl affichageMess
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
/***************************************************/
/* display message number */
/***************************************************/
/* x0 contains the number */
displayResult:
stp x1,lr,[sp,-16]! // save registres
ldr x1,qAdrsZoneConv
bl conversion10 // call décimal conversion
strb wzr,[x1,x0]
ldr x0,qAdrsMessResult
ldr x1,qAdrsZoneConv // insert conversion in message
bl strInsertAtCharInc
bl affichageMess // display message
ldp x1,lr,[sp],16 // restaur des 2 registres
ret
qAdrsMessResult: .quad sMessResult
qAdrsZoneConv: .quad sZoneConv
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
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
Action!
CARD FUNC DivisorCount(CARD n)
CARD result,p,count
result=1
WHILE (n&1)=0
DO
result==+1
n=n RSH 1
OD
p=3
WHILE p*p<=n
DO
count=1
WHILE n MOD p=0
DO
count==+1
n==/p
OD
result==*count
p==+2
OD
IF n>1 THEN
result==*2
FI
RETURN (result)
PROC Main()
CARD max=[100],n,divCount
PrintF("Tau function for the first %U numbers%E",max)
FOR n=1 TO max
DO
divCount=DivisorCount(n)
PrintC(divCount) Put(32)
OD
RETURN
- Output:
Screenshot from Atari 8-bit computer
Tau function for the first 100 numbers 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
ALGOL 68
BEGIN # find the count of the divisors of the first 100 positive integers #
# calculates the number of divisors of v #
PROC divisor count = ( INT v )INT:
BEGIN
INT total := 1, n := v;
# Deal with powers of 2 first #
WHILE NOT ODD n DO
total +:= 1;
n OVERAB 2
OD;
# Odd prime factors up to the square root #
FOR p FROM 3 BY 2 WHILE ( p * p ) <= n DO
INT count := 1;
WHILE n MOD p = 0 DO
count +:= 1;
n OVERAB p
OD;
total *:= count
OD;
# If n > 1 then it's prime #
IF n > 1 THEN total *:= 2 FI;
total
END # divisor_count # ;
BEGIN
INT limit = 100;
print( ( "Count of divisors for the first ", whole( limit, 0 ), " positive integers:" ) );
FOR n TO limit DO
IF n MOD 20 = 1 THEN print( ( newline ) ) FI;
print( ( whole( divisor count( n ), -4 ) ) )
OD
END
END
- Output:
Count of divisors for the first 100 positive integers: 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
ALGOL-M
begin
% return the value of n mod m %
integer function mod(n, m);
integer n, m;
begin
mod := n - m * (n / m);
end;
% return the tau value (i.e, number of divisors) of n %
integer function tau(n);
integer n;
begin
integer i, t, limit;
if n < 3 then
t := n
else
begin
t := 2;
limit := (n + 1) / 2;
for i := 2 step 1 until limit do
begin
if mod(n, i) = 0 then t := t + 1;
end;
end;
tau := t;
end;
% test by printing the tau value of the first 100 numbers %
integer i;
write("Count of divisors for first 100 numbers:");
write("");
for i := 1 step 1 until 100 do
begin
writeon(tau(i));
if mod(i,10) = 0 then write(""); % print 10 across %
end;
end
- Output:
Count of divisors for first 100 numbers: 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
ALGOL W
begin % find the count of the divisors of the first 100 positive integers %
% calculates the number of divisors of v %
integer procedure divisor_count( integer value v ) ; begin
integer total, n, p;
total := 1; n := v;
% Deal with powers of 2 first %
while not odd( n ) do begin
total := total + 1;
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 count;
count := 1;
while n rem p = 0 do begin
count := count + 1;
n := n div p
end while_n_rem_p_eq_0 ;
p := p + 2;
total := total * count
end while_p_x_p_le_n ;
% If n > 1 then it is prime %
if n > 1 then total := total * 2;
total
end divisor_count ;
begin
integer limit;
limit := 100;
write( i_w := 1, s_w := 0, "Count of divisors for the first ", limit, " positive integers:" );
for n := 1 until limit do begin
if n rem 20 = 1 then write();
writeon( i_w := 3, s_w := 1, divisor_count( n ) )
end for_n
end
end.
- Output:
Count of divisors for the first 100 positive integers: 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
APL
tau ← 0+.=⍳|⊢
tau¨ 5 20⍴⍳100
- Output:
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
AppleScript
on factorCount(n)
if (n < 1) then return 0
set counter to 2
set sqrt to n ^ 0.5
if (sqrt mod 1 = 0) then set counter to 1
repeat with i from (sqrt div 1) to 2 by -1
if (n mod i = 0) then set counter to counter + 2
end repeat
return counter
end factorCount
-- Task code:
local output, n, astid
set output to {"Positive divisor counts for integers 1 to 100:"}
repeat with n from 1 to 100
if (n mod 20 = 1) then set end of output to linefeed
set end of output to text -3 thru -1 of (" " & factorCount(n))
end repeat
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ""
set output to output as text
set AppleScript's text item delimiters to astid
return output
- Output:
"Positive divisor counts for integers 1 to 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"
ARM Assembly
/* ARM assembly Raspberry PI */
/* program taufunction.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
.equ MAXI, 100
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResult: .asciz " @ "
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
mov r0,#1 @ factor number one
bl displayResult
mov r0,#2 @ factor number two
bl displayResult
mov r2,#3 @ begin number three
1: @ begin loop
mov r5,#2 @ divisor counter
mov r4,#2 @ first divisor 1
2:
udiv r0,r2,r4 @ compute divisor 2
mls r3,r0,r4,r2 @ remainder
cmp r3,#0
bne 3f @ remainder = 0 ?
cmp r0,r4 @ same divisor ?
addeq r5,r5,#1 @ yes increment one
addne r5,r5,#2 @ no increment two
3:
add r4,r4,#1 @ increment divisor
cmp r4,r0 @ divisor 1 < divisor 2
blt 2b @ yes -> loop
mov r0,r5 @ equal -> display
bl displayResult
add r2,#1 @
cmp r2,#MAXI @ end ?
bls 1b @ no -> loop
ldr r0,iAdrszCarriageReturn
bl affichageMess
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
/***************************************************/
/* display message number */
/***************************************************/
/* r0 contains the number */
displayResult:
push {r1,r2,lr} @ save registers
ldr r1,iAdrsZoneConv
bl conversion10 @ call décimal conversion
mov r2,#0
strb r2,[r1,r0]
ldr r0,iAdrsMessResult
ldr r1,iAdrsZoneConv @ insert conversion in message
bl strInsertAtCharInc
bl affichageMess @ display message
pop {r1,r2,pc} @ restaur des registres
iAdrsMessResult: .int sMessResult
iAdrsZoneConv: .int sZoneConv
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
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
Arturo
tau: function [x] -> size factors x
loop split.every:20 1..100 => [
print map & => [pad to :string tau & 3]
]
- Output:
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
Asymptote
write("The tau functions for the first 100 positive integers are:");
for (int N = 1; N <= 100; ++N) {
int T;
if (N < 3) {
T = N;
} else {
T = 2;
for (int A = 2; A <= (N + 1) / 2; ++A) {
if (N % A == 0) T = T + 1;
}
}
write(format("%3d", T), suffix=none);
if (N % 10 == 0) write("");
}
AutoHotkey
loop 100
result .= SubStr(" " Tau(A_Index), -3) . (Mod(A_Index, 10) ? " " : "`n")
MsgBox % result
return
Tau(n){
return StrSplit(Factors(n), ",").Count()
}
Factors(n) {
Loop, % floor(sqrt(n))
v := A_Index = 1 ? 1 "," n : mod(n,A_Index) ? v : v "," A_Index "," n//A_Index
Sort, v, N U D,
Return, v
}
- Output:
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
AWK
# syntax: GAWK -f TAU_FUNCTION.AWK
BEGIN {
print("The tau functions for the first 100 positive integers:")
for (i=1; i<=100; i++) {
printf("%2d ",count_divisors(i))
if (i % 10 == 0) {
printf("\n")
}
}
exit(0)
}
function count_divisors(n, count,i) {
for (i=1; i*i<=n; i++) {
if (n % i == 0) {
count += (i == n / i) ? 1 : 2
}
}
return(count)
}
- Output:
The tau functions for the first 100 positive integers: 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
BASIC
10 DEFINT A-Z
20 FOR I=1 TO 100
30 N=I: GOSUB 100
40 PRINT USING " ##";T;
50 IF I MOD 20=0 THEN PRINT
60 NEXT
70 END
100 T=1
110 IF (N AND 1)=0 THEN N=N\2: T=T+1: GOTO 110
120 P=3
130 GOTO 180
140 C=1
150 IF N MOD P=0 THEN N=N\P: C=C+1: GOTO 150
160 T=T*C
170 P=P+2
180 IF P*P<=N GOTO 140
190 IF N>1 THEN T=T*2
200 RETURN
- Output:
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
BASIC256
print "The tau functions for the first 100 positive integers are:"
print
for N = 1 to 100
if N < 3 then
T = N
else
T = 2
for A = 2 to (N+1)\2
if N mod A = 0 then T += 1
next A
end if
print " "; T;
if N mod 10 = 0 then print
next N
end
Gambas
Public Sub Main()
Print "The tau functions for the first 100 positive integers are:\n"
For i As Integer = 1 To 100
Print Format$(numdiv(i), "####");
If i Mod 10 = 0 Then Print
Next
End
Public Function numdiv(n As Integer) As Integer
Dim c As Integer = 1
For i As Integer = 1 To (n + 1) \ 2
If n Mod i = 0 Then c += 1
Next
If n = 1 Then c -= 1
Return c
End Function
- Output:
Same as FreeBASIC entry.
Chipmunk Basic
The GW-BASIC solution works without any changes.
MSX Basic
The GW-BASIC solution works without any changes.
QBasic
PRINT "The tau functions for the first 100 positive integers are:": PRINT
FOR N = 1 TO 100
IF N < 3 THEN
T = N
ELSE
T = 2
FOR A = 2 TO (N + 1) \ 2
IF N MOD A = 0 THEN T = T + 1
NEXT A
END IF
PRINT USING "###"; T;
IF N MOD 10 = 0 THEN PRINT
NEXT N
END
Run BASIC
print "The tau functions for the first 100 positive integers are:"
print
for N = 1 to 100
if N < 3 then
T = N
else
T = 2
for A = 2 to int((N+1)/2)
if N mod A = 0 then T = T + 1
next A
end if
print using("####", T);
if N mod 10 = 0 then print
next N
end
True BASIC
PRINT "The tau functions for the first 100 positive integers are:"
PRINT
FOR N = 1 TO 100
IF N < 3 THEN
LET T = N
ELSE
LET T = 2
FOR A = 2 TO INT((N+1)/2)
IF REMAINDER (N, A) = 0 THEN LET T = T + 1
NEXT A
END IF
PRINT " "; T;
IF REMAINDER (N, 10) = 0 THEN PRINT
NEXT N
END
XBasic
PROGRAM "Tau"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
DECLARE FUNCTION numdiv(n)
FUNCTION Entry ()
PRINT "The tau functions for the first 100 positive integers are:\n"
FOR i = 1 TO 100
PRINT FORMAT$("###", numdiv(i));
IF i MOD 10 = 0 THEN PRINT
NEXT i
END FUNCTION
FUNCTION numdiv(n)
c = 1
FOR i = 1 TO (n+1)\2
IF n MOD i = 0 THEN INC c
NEXT i
IF n = 1 THEN DEC c
RETURN c
END FUNCTION
END PROGRAM
Yabasic
print "The tau functions for the first 100 positive integers are:\n"
for N = 1 to 100
if N < 3 then
T = N
else
T = 2
for A = 2 to int((N+1)/2)
if mod(N, A) = 0 then T = T + 1 : fi
next A
end if
print T using "###";
if mod(N, 10) = 0 then print : fi
next N
end
bc
define t(n) {
auto a, d, p
for (d = 1; n % 2 == 0; n /= 2) d += 1
for (p = 3; p * p <= n; p += 2) for (a = d; n % p == 0; n /= p) d += a
if (n != 1) d += d
return(d)
}
for (i = 1; i <= 100; ++i) t(i)
BCPL
get "libhdr"
let tau(n) = valof
$( let total = 1 and p = 3
while (n & 1) = 0
$( total := total + 1
n := n >> 1
$)
while p*p <= n
$( let count = 1
while n rem p = 0
$( count := count + 1
n := n / p
$)
total := total * count
p := p + 2
$)
if n>1 then total := total * 2
resultis total
$)
let start() be
for n=1 to 100
$( writed(tau(n), 3)
if n rem 20 = 0 then wrch('*N')
$)
- Output:
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
BQN
Tau ← +´0=(1+↕)|⊢
Tau¨ 5‿20⥊1+↕100
- Output:
┌─ ╵ 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 ┘
C
#include <stdio.h>
// See https://en.wikipedia.org/wiki/Divisor_function
unsigned int divisor_count(unsigned int n) {
unsigned int total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1) {
++total;
}
// Odd prime factors up to the square root
for (unsigned int p = 3; p * p <= n; p += 2) {
unsigned int count = 1;
for (; n % p == 0; n /= p) {
++count;
}
total *= count;
}
// If n > 1 then it's prime
if (n > 1) {
total *= 2;
}
return total;
}
int main() {
const unsigned int limit = 100;
unsigned int n;
printf("Count of divisors for the first %d positive integers:\n", limit);
for (n = 1; n <= limit; ++n) {
printf("%3d", divisor_count(n));
if (n % 20 == 0) {
printf("\n");
}
}
return 0;
}
- Output:
Count of divisors for the first 100 positive integers: 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
C++
#include <iomanip>
#include <iostream>
// See https://en.wikipedia.org/wiki/Divisor_function
unsigned int divisor_count(unsigned int n) {
unsigned int total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1)
++total;
// Odd prime factors up to the square root
for (unsigned int p = 3; p * p <= n; p += 2) {
unsigned int count = 1;
for (; n % p == 0; n /= p)
++count;
total *= count;
}
// If n > 1 then it's prime
if (n > 1)
total *= 2;
return total;
}
int main() {
const unsigned int limit = 100;
std::cout << "Count of divisors for the first " << limit << " positive integers:\n";
for (unsigned int n = 1; n <= limit; ++n) {
std::cout << std::setw(3) << divisor_count(n);
if (n % 20 == 0)
std::cout << '\n';
}
}
- Output:
Count of divisors for the first 100 positive integers: 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
C#
internal class Program
{
private static void Main(string[] args)
{
long limit = 100;
Console.WriteLine($"Count of divisors for the first {limit} positive integers:");
long count = 0;
for (long n = 1; count < limit; ++n)
{
Console.Write($"{DivisorCount(n),3} ");
++count;
if (count % 20 == 0)
{
Console.WriteLine();
}
}
}
private static long DivisorCount(long n)
{
long total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1)
{
++total;
}
// Odd prime factors up to the square root
for (long p = 3; p * p <= n; p += 2)
{
long count = 1;
for (; n % p == 0; n /= p)
{
++count;
}
total *= count;
}
// If n > 1 then it's prime
if (n > 1)
{
total *= 2;
}
return total;
}
}
- Output:
Count of divisors for the first 100 positive integers: 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
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)))))
- 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
CLU
tau = proc (n: int) returns (int)
total: int := 1
while n//2 = 0 do
total := total + 1
n := n/2
end
p: int := 3
while p*p <= n do
count: int := 1
while n//p = 0 do
count := count + 1
n := n/p
end
total := total * count
p := p+2
end
if n>1 then
total := total * 2
end
return(total)
end tau
start_up = proc ()
po: stream := stream$primary_output()
for n: int in int$from_to(1, 100) do
stream$putright(po, int$unparse(tau(n)), 3)
if n//20=0 then stream$putl(po, "") end
end
end start_up
- Output:
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
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. TAU-FUNCTION.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 TAU-VARS.
03 TOTAL PIC 999.
03 N PIC 999.
03 FILLER REDEFINES N.
05 FILLER PIC 99.
05 FILLER PIC 9.
88 N-EVEN VALUES 0, 2, 4, 6, 8.
03 P PIC 999.
03 P-SQUARED PIC 999.
03 N-DIV-P PIC 999V999.
03 FILLER REDEFINES N-DIV-P.
05 NEXT-N PIC 999.
05 FILLER PIC 999.
88 DIVISIBLE VALUE ZERO.
03 F-COUNT PIC 999.
01 CONTROL-VARS.
03 I PIC 999.
01 OUT-VARS.
03 OUT-ITM PIC ZZ9.
03 OUT-STR PIC X(80) VALUE SPACES.
03 OUT-PTR PIC 99 VALUE 1.
PROCEDURE DIVISION.
BEGIN.
PERFORM SHOW-TAU VARYING I FROM 1 BY 1
UNTIL I IS GREATER THAN 100.
STOP RUN.
SHOW-TAU.
MOVE I TO N.
PERFORM TAU.
MOVE TOTAL TO OUT-ITM.
STRING OUT-ITM DELIMITED BY SIZE INTO OUT-STR
WITH POINTER OUT-PTR.
IF OUT-PTR IS EQUAL TO 61,
DISPLAY OUT-STR,
MOVE 1 TO OUT-PTR.
TAU.
MOVE 1 TO TOTAL.
PERFORM POWER-OF-2 UNTIL NOT N-EVEN.
MOVE ZERO TO P-SQUARED.
PERFORM ODD-FACTOR THRU ODD-FACTOR-LOOP
VARYING P FROM 3 BY 2
UNTIL P-SQUARED IS GREATER THAN N.
IF N IS GREATER THAN 1,
MULTIPLY 2 BY TOTAL.
POWER-OF-2.
ADD 1 TO TOTAL.
DIVIDE 2 INTO N.
ODD-FACTOR.
MULTIPLY P BY P GIVING P-SQUARED.
MOVE 1 TO F-COUNT.
ODD-FACTOR-LOOP.
DIVIDE N BY P GIVING N-DIV-P.
IF DIVISIBLE,
MOVE NEXT-N TO N,
ADD 1 TO F-COUNT,
GO TO ODD-FACTOR-LOOP.
MULTIPLY F-COUNT BY TOTAL.
- Output:
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
Cowgol
include "cowgol.coh";
typedef N is uint8;
sub tau(n: N): (total: N) is
total := 1;
while n & 1 == 0 loop
total := total + 1;
n := n >> 1;
end loop;
var p: N := 3;
while p*p <= n loop
var count: N := 1;
while n%p == 0 loop
count := count + 1;
n := n / p;
end loop;
total := total * count;
p := p + 2;
end loop;
if n>1 then
total := total << 1;
end if;
end sub;
sub print2(n: uint8) is
print_char(' ');
if n<10
then print_char(' ');
else print_i8(n/10);
end if;
print_i8(n%10);
end sub;
var n: N := 1;
while n <= 100 loop
print2(tau(n));
if n % 20 == 0 then print_nl(); end if;
n := n + 1;
end loop;
- Output:
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
D
import std.stdio;
// See https://en.wikipedia.org/wiki/Divisor_function
uint divisor_count(uint n) {
uint total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1) {
++total;
}
// Odd prime factors up to the square root
for (uint p = 3; p * p <= n; p += 2) {
uint count = 1;
for (; n % p == 0; n /= p) {
++count;
}
total *= count;
}
// If n > 1 then it's prime
if (n > 1) {
total *= 2;
}
return total;
}
void main() {
immutable limit = 100;
writeln("Count of divisors for the first ", limit, " positive integers:");
for (uint n = 1; n <= limit; ++n) {
writef("%3d", divisor_count(n));
if (n % 20 == 0) {
writeln;
}
}
}
- Output:
Count of divisors for the first 100 positive integers: 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
Dart
int divisorCount(int n) {
int total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1) total++;
// Odd prime factors up to the square root
for (int p = 3; p * p <= n; p += 2) {
int count = 1;
for (; n % p == 0; n ~/= p) count++;
total *= count;
}
// If n > 1 then it's prime
if (n > 1) total *= 2;
return total;
}
void main() {
const int limit = 100;
print("Count of divisors for the first $limit positive integers:");
for (int n = 1; n <= limit; ++n) {
print(divisorCount(n).toString().padLeft(3));
}
}
Delphi
program Tau_function;
{$APPTYPE CONSOLE}
uses
System.SysUtils;
function CountDivisors(n: Integer): Integer;
begin
Result := 0;
var i := 1;
var k := 2;
if (n mod 2) = 0 then
k := 1;
while i * i <= n do
begin
if (n mod i) = 0 then
begin
inc(Result);
var j := n div i;
if j <> i then
inc(Result);
end;
inc(i, k);
end;
end;
begin
writeln('The tau functions for the first 100 positive integers are:');
for var i := 1 to 100 do
begin
write(CountDivisors(i): 2, ' ');
if (i mod 20) = 0 then
writeln;
end;
readln;
end.
Draco
proc nonrec tau(word n) word:
word count, total, p;
total := 1;
while n & 1 = 0 do
total := total + 1;
n := n >> 1
od;
p := 3;
while p*p <= n do
count := 1;
while n % p = 0 do
count := count + 1;
n := n / p
od;
total := total * count;
p := p + 2
od;
if n>1
then total << 1
else total
fi
corp
proc nonrec main() void:
byte n;
for n from 1 upto 100 do
write(tau(n):3);
if n%20=0 then writeln() fi
od
corp
- Output:
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
Dyalect
func divisorCount(number) {
var n = number
var total = 1
while (n &&& 1) == 0 {
total += 1
n >>>= 1
}
var p = 3
while p * p <= n {
var count = 1
while n % p == 0 {
count += 1
n /= p
}
total *= count
p += 2
}
if n > 1 {
total *= 2
}
total
}
let limit = 100
print("Count of divisors for the first \(limit) positive integers:")
for n in 1..limit {
print(divisorCount(number: n).ToString().PadLeft(2, ' ') + " ", terminator: "")
print() when n % 20 == 0
}
- Output:
Count of divisors for the first 100 positive integers: 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
EasyLang
func cntdiv n .
i = 1
while i <= sqrt n
if n mod i = 0
cnt += 1
if i <> n div i
cnt += 1
.
.
i += 1
.
return cnt
.
for i to 100
write cntdiv i & " "
.
EMal
fun divisorCount = int by int n
int total = 1
for ; (n & 1) == 0; n /= 2 do ++total end
for int p = 3; p * p <= n; p += 2
int count = 1
for ; n % p == 0; n /= p do ++count end
total *= count
end
if n > 1 do total *= 2 end
return total
end
int limit = 100
writeLine("Count of divisors for the first " + limit + " positive integers:")
for int n = 1; n <= limit; ++n
text value = text!divisorCount(n)
write((" " * (3 - value.length)) + value)
if n % 20 == 0 do writeLine() end
end
- Output:
Count of divisors for the first 100 positive integers: 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
F#
This task uses Extensible Prime Generator (F#).
// Tau function. Nigel Galloway: March 10th., 2021
let tau 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 |(_,0)->fG (n*i) i g (e+g)(l*i) |_->let q=fN(Seq.head P) in fG (n*q) q e (e+e) (q*q)
let n=Seq.head P in fG 1 n 1 1 n
[1..100]|>Seq.iter(tau>>printf "%d "); printfn ""
- Output:
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
Factor
USING: assocs formatting io kernel math math.primes.factors
math.ranges sequences sequences.extras ;
ERROR: nonpositive n ;
: (tau) ( n -- count )
group-factors values [ 1 + ] map-product ; inline
: tau ( n -- count ) dup 0 > [ (tau) ] [ nonpositive ] if ;
"Number of divisors for integers 1-100:" print nl
" n | tau(n)" print
"-----+-----------------------------------------" print
1 100 10 <range> [
[ "%2d |" printf ]
[ dup 10 + [a,b) [ tau "%4d" printf ] each nl ] bi
] each
- Output:
Number of divisors for integers 1-100: n | tau(n) -----+----------------------------------------- 1 | 1 2 2 3 2 4 2 4 3 4 11 | 2 6 2 4 4 5 2 6 2 6 21 | 4 4 2 8 3 4 4 6 2 8 31 | 2 6 4 4 4 9 2 4 4 8 41 | 2 8 2 6 6 4 2 10 3 6 51 | 4 6 2 8 4 8 4 4 2 12 61 | 2 4 6 7 4 8 2 6 4 8 71 | 2 12 2 4 6 6 4 8 2 10 81 | 5 4 2 12 4 4 4 8 2 12 91 | 4 6 4 4 4 12 2 6 6 9
Fermat
Func Tau(t) =
if t<3 then Return(t) else
numdiv:=2;
for q = 2 to t\2 do
if Divides(q, t) then numdiv:=numdiv+1 fi;
od;
Return(numdiv);
fi;
.;
for i = 1 to 100 do
!(Tau(i),' ');
od;
- Output:
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
Forth
: divisor_count ( n -- n )
1 >r
begin
dup 2 mod 0=
while
r> 1+ >r
2/
repeat
3
begin
2dup dup * >=
while
1 >r
begin
2dup mod 0=
while
r> 1+ >r
tuck / swap
repeat
2r> * >r
2 +
repeat
drop 1 > if r> 2* else r> then ;
: print_divisor_counts ( n -- )
." Count of divisors for the first " dup . ." positive integers:" cr
1+ 1 do
i divisor_count 2 .r
i 20 mod 0= if cr else space then
loop ;
100 print_divisor_counts
bye
- Output:
Count of divisors for the first 100 positive integers: 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
FreeBASIC
function numdiv( n as uinteger ) as uinteger
dim as uinteger c = 1
for i as uinteger = 1 to (n+1)\2
if n mod i = 0 then c += 1
next i
if n=1 then c-=1
return c
end function
for i as uinteger = 1 to 100
print numdiv(i),
if i mod 10 = 0 then print
next i
- Output:
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
Frink
tau[n] := length[allFactors[n]]
for n=1 to 100
print[tau[n] + " "]
println[]
- Output:
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
Go
package main
import "fmt"
func countDivisors(n int) int {
count := 0
i := 1
k := 2
if n%2 == 0 {
k = 1
}
for i*i <= n {
if n%i == 0 {
count++
j := n / i
if j != i {
count++
}
}
i += k
}
return count
}
func main() {
fmt.Println("The tau functions for the first 100 positive integers are:")
for i := 1; i <= 100; i++ {
fmt.Printf("%2d ", countDivisors(i))
if i%20 == 0 {
fmt.Println()
}
}
}
- Output:
The tau functions for the first 100 positive integers are: 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
GW-BASIC
10 FOR N = 1 TO 100
20 IF N < 3 THEN T=N: GOTO 70
30 T=2
40 FOR A = 2 TO INT( (N+1)/2 )
50 IF N MOD A = 0 THEN T = T + 1
60 NEXT A
70 PRINT T;
80 IF N MOD 10 = 0 THEN PRINT
90 NEXT N
- Output:
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
Haskell
tau :: Integral a => a -> a
tau n | n <= 0 = error "Not a positive integer"
tau n = go 0 (1, 1)
where
yo i = (i, i * i)
go r (i, ii)
| n < ii = r
| n == ii = r + 1
| 0 == mod n i = go (r + 2) (yo $ i + 1)
| otherwise = go r (yo $ i + 1)
main = print $ map tau [1..100]
- Output:
[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]
Or using primeFactors from the Data.Numbers.Primes library:
import Data.Numbers.Primes
import Data.List (group, intercalate, transpose)
import Data.List.Split (chunksOf)
import Text.Printf
----------------------- OEISA000005 ----------------------
oeisA000005 :: [Int]
oeisA000005 = tau <$> [1..]
tau :: Integer -> Int
tau = product . fmap (succ . length) . group . primeFactors
--------------------------- TEST -------------------------
main :: IO ()
main = putStrLn $
(table " " . chunksOf 10 . fmap show . take 100)
oeisA000005
------------------------ FORMATTING ----------------------
table :: String -> [[String]] -> String
table gap rows =
let ws = maximum . fmap length <$> transpose rows
pw = printf . flip intercalate ["%", "s"] . show
in unlines $ intercalate gap . zipWith pw ws <$> rows
- Output:
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
J
tau =: [:+/0=>:@i.|]
echo tau"0 [5 20$>:i.100
exit ''
- Output:
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
Java
public class TauFunction {
private static long divisorCount(long n) {
long total = 1;
// Deal with powers of 2 first
for (; (n & 1) == 0; n >>= 1) {
++total;
}
// Odd prime factors up to the square root
for (long p = 3; p * p <= n; p += 2) {
long count = 1;
for (; n % p == 0; n /= p) {
++count;
}
total *= count;
}
// If n > 1 then it's prime
if (n > 1) {
total *= 2;
}
return total;
}
public static void main(String[] args) {
final int limit = 100;
System.out.printf("Count of divisors for the first %d positive integers:\n", limit);
for (long n = 1; n <= limit; ++n) {
System.out.printf("%3d", divisorCount(n));
if (n % 20 == 0) {
System.out.println();
}
}
}
}
- Output:
Count of divisors for the first 100 positive integers: 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
jq
Works with gojq, the Go implementation of jq
Preliminaries
See https://rosettacode.org/wiki/Sum_of_divisors#jq for the definition of `divisors` used here.
def count(s): reduce s as $x (0; .+1);
# 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) | count(divisors)]
| nwise(10) | map(lpad(4)) | join("")
- Output:
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
Julia
Recycles code from http://www.rosettacode.org/wiki/Sequence:_smallest_number_greater_than_previous_term_with_exactly_n_divisors#Julia
using Primes
function numfactors(n)
f = [one(n)]
for (p, e) in factor(n)
f = reduce(vcat, [f * p^j for j in 1:e], init = f)
end
length(f)
end
for i in 1:100
print(rpad(numfactors(i), 3), i % 25 == 0 ? " \n" : " ")
end
- Output:
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
Lua
function divisorCount(n)
local total = 1
-- Deal with powers of 2 first
while (n & 1) == 0 do
total = total + 1
n = math.floor(n / 2)
end
-- Odd prime factors up tot eh square root
local p = 3
while p * p <= n do
local count = 1
while n % p == 0 do
count = count + 1
n = n / p
end
total = total * count
p = p + 2
end
-- If n > 1 then it's prime
if n > 1 then
total = total * 2
end
return total
end
limit = 100
print("Count of divisors for the first " .. limit .. " positive integers:")
for n=1,limit do
io.write(string.format("%3d", divisorCount(n)))
if n % 20 == 0 then
print()
end
end
- Output:
Count of divisors for the first 100 positive integers: 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
Mathematica/Wolfram Language
DivisorSum[#, 1 &] & /@ Range[100]
- Output:
{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}
MiniScript
tau = function(n)
ans = 0
i = 1
while i * i <= n
if n % i == 0 then
ans += 1
j = floor(n / i)
if j != i then ans += 1
end if
i += 1
end while
return ans
end function
taus = []
for n in range(1, 100)
taus.push(tau(n))
end for
print taus.join(", ")
- Output:
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
Modula-2
MODULE TauFunc;
FROM InOut IMPORT WriteCard, WriteLn;
VAR i: CARDINAL;
PROCEDURE tau(n: CARDINAL): CARDINAL;
VAR total, count, p: CARDINAL;
BEGIN
total := 1;
WHILE n MOD 2 = 0 DO
n := n DIV 2;
total := total + 1
END;
p := 3;
WHILE p*p <= n DO
count := 1;
WHILE n MOD p = 0 DO
n := n DIV p;
count := count + 1
END;
total := total * count;
p := p + 2
END;
IF n>1 THEN total := total * 2 END;
RETURN total;
END tau;
BEGIN
FOR i := 1 TO 100 DO
WriteCard(tau(i), 3);
IF i MOD 20 = 0 THEN WriteLn END
END
END TauFunc.
- Output:
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
Nim
import math, strutils
func divcount(n: Natural): Natural =
for i in 1..sqrt(n.toFloat).int:
if n mod i == 0:
inc result
if n div i != i: inc result
echo "Count of divisors for the first 100 positive integers:"
for i in 1..100:
stdout.write ($divcount(i)).align(3)
if i mod 20 == 0: echo()
- Output:
Count of divisors for the first 100 positive integers: 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
PARI/GP
vector(100,X,numdiv(X))
- Output:
[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]
Pascal
program tauFunction(output);
type
{ name starts with `integer…` to facilitate sorting in documentation }
integerPositive = 1..maxInt value 1;
{ the `value …` will initialize all variables to this value }
{ returns Boolean value of the expression divisor ∣ dividend ----------- }
function divides(
protected divisor: integerPositive;
protected dividend: integer
): Boolean;
begin
{ in Pascal, function result variable has the same name as function }
divides := dividend mod divisor = 0
end;
{ returns τ(i) --------------------------------------------------------- }
function tau(protected i: integerPositive): integerPositive;
var
count, potentialDivisor: integerPositive;
begin
{ count is initialized to 1 and every number is divisible by one }
for potentialDivisor := 2 to i do
begin
count := count + ord(divides(potentialDivisor, i))
end;
{ in Pascal, there must be exactly one assignment to result variable }
tau := count
end;
{ === MAIN ============================================================= }
var
i: integerPositive;
f: string(6);
begin
for i := 1 to 100 do
begin
writeStr(f, 'τ(', i:1);
writeLn(f:8, ') = ', tau(i):5)
end
end.
Free Pascal
and on TIO.RUN. Only test 0..99 for a nicer table.
program Tau_function;
{$IFDEF Windows} {$APPTYPE CONSOLE} {$ENDIF}
function CountDivisors(n: NativeUint): integer;
var
q, p, cnt, divcnt: NativeUint;
begin
divCnt := 1;
if n > 1 then
begin
cnt := 1;
while not (Odd(n)) do
begin
n := n shr 1;
divCnt := divCnt+cnt;
end;
p := 3;
while p * p <= n do
begin
cnt := divCnt;
q := n div p;
while q * p = n do
begin
n := q;
q := n div p;
divCnt := divCnt+cnt;
end;
Inc(p, 2);
end;
if n <> 1 then
divCnt := divCnt+divCnt;
end;
CountDivisors := divCnt;
end;
const
UPPERLIMIT = 99;
colWidth = trunc(ln(UPPERLIMIT)/ln(10))+1;
var
i: NativeUint;
begin
writeln('The tau functions for the first ',UPPERLIMIT,' positive integers are:');
Write('': colWidth+1);
for i := 0 to 9 do
Write(i: colWidth, ' ');
for i := 0 to UPPERLIMIT do
begin
if i mod 10 = 0 then
begin
writeln;
Write(i div 10: colWidth, '|');
end;
Write(CountDivisors(i): colWidth, ' ');
end;
writeln;
{$Ifdef Windows}readln;{$ENDIF}
end.
- TIO.RUN:
The tau functions for the first 99 positive integers are: 0 1 2 3 4 5 6 7 8 9 0| 1 1 2 2 3 2 4 2 4 3 1| 4 2 6 2 4 4 5 2 6 2 2| 6 4 4 2 8 3 4 4 6 2 3| 8 2 6 4 4 4 9 2 4 4 4| 8 2 8 2 6 6 4 2 10 3 5| 6 4 6 2 8 4 8 4 4 2 6|12 2 4 6 7 4 8 2 6 4 7| 8 2 12 2 4 6 6 4 8 2 8|10 5 4 2 12 4 4 4 8 2 9|12 4 6 4 4 4 12 2 6 6
PascalABC.NET
##
function DivisorsCount(n: integer) := Range(1,n).Count(i -> n.Divs(i));
Range(1,100).Select(n -> DivisorsCount(n)).Println
- Output:
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
Perl
use strict;
use warnings;
use feature 'say';
use ntheory 'divisors';
my @x;
push @x, scalar divisors($_) for 1..100;
say "Tau function - first 100:\n" .
((sprintf "@{['%4d' x 100]}", @x[0..100-1]) =~ s/(.{80})/$1\n/gr);
- Output:
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
Phix
imperative
for i=1 to 100 do printf(1,"%3d",{length(factors(i,1))}) if remainder(i,20)=0 then puts(1,"\n") end if end for
- Output:
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
functional
same output
sequence r = apply(apply(true,factors,{tagset(100),{1}}),length) puts(1,join_by(apply(true,sprintf,{{"%3d"},r}),1,20,""))
PL/I
taufunc: procedure options(main);
tau: procedure(nn) returns(fixed);
declare (n, nn, tot, pf, cnt) fixed;
tot = 1;
do n=nn repeat(n/2) while(mod(n,2)=0);
tot = tot + 1;
end;
do pf=3 repeat(pf+2) while(pf*pf<=n);
do cnt=1 repeat(cnt+1) while(mod(n,pf)=0);
n = n/pf;
end;
tot = tot * cnt;
end;
if n>1 then tot = tot * 2;
return(tot);
end tau;
declare n fixed;
do n=1 to 100;
put edit(tau(n)) (F(3));
if mod(n,20)=0 then put skip;
end;
end taufunc;
- Output:
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
PL/M
100H:
/* CP/M BDOS FUNCTIONS */
BDOS: PROCEDURE(F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
PR$CHAR: PROCEDURE(C); DECLARE C BYTE; CALL BDOS(2,C); END PR$CHAR;
PR$STR: PROCEDURE(S); DECLARE S ADDRESS; CALL BDOS(9,S); END PR$STR;
/* PRINT BYTE IN A 3-CHAR COLUMN */
PRINT3: PROCEDURE(N);
DECLARE (N, M) BYTE;
M = 100;
DO WHILE M>0;
IF N>=M
THEN CALL PR$CHAR('0' + (N/M) MOD 10);
ELSE CALL PR$CHAR(' ');
M = M/10;
END;
END PRINT3;
/* TAU FUNCTION */
TAU: PROCEDURE(N) BYTE;
DECLARE (N, TOTAL, COUNT, P) BYTE;
TOTAL = 1;
DO WHILE NOT N;
N = SHR(N,1);
TOTAL = TOTAL + 1;
END;
P = 3;
DO WHILE P*P <= N;
COUNT = 1;
DO WHILE N MOD P = 0;
COUNT = COUNT + 1;
N = N / P;
END;
TOTAL = TOTAL * COUNT;
P = P + 2;
END;
IF N>1 THEN TOTAL = SHL(TOTAL, 1);
RETURN TOTAL;
END TAU;
/* PRINT TAU 1..100 */
DECLARE N BYTE;
DO N=1 TO 100;
CALL PRINT3(TAU(N));
IF N MOD 20=0 THEN CALL PR$STR(.(13,10,'$'));
END;
CALL EXIT;
EOF
- Output:
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
PureBasic
If OpenConsole()
For i=1 To 100
If i<3 : Print(RSet(Str(i),4)) : Continue :EndIf
c=2
For j=2 To i/2+1 : c+Bool(i%j=0) : Next
Print(RSet(Str(c),4))
If i%10=0 : PrintN("") : EndIf
Next
Input()
EndIf
End
- Output:
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
Python
Using prime factorization
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 tau(n):
assert(n != 0)
ans = 1
for (p,k) in factorize(n):
ans *= 1 + k
return ans
if __name__ == "__main__":
print(*map(tau, range(1, 101)))
Finding divisors efficiently
def tau(n):
assert(isinstance(n, int) and 0 < n)
t = (n - 1 ^ n).bit_length()
n >>= t - 1
p = 3
while p * p <= n:
a = t
while n % p == 0:
t += a
n //= p
p += 2
if n != 1:
t += t
return t
if __name__ == "__main__":
print(*map(tau, range(1, 101)))
- Output:
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
Choosing the right abstraction
Yet another exercise in defining a divisors function.
'''The number of divisors of n'''
from itertools import count, islice
from math import floor, sqrt
# oeisA000005 :: [Int]
def oeisA000005():
'''tau(n) (also called d(n) or sigma_0(n)),
the number of divisors of n.
'''
return map(tau, count(1))
# tau :: Int -> Int
def tau(n):
'''The number of divisors of n.
'''
return len(divisors(n))
# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''The first 100 terms of OEIS A000005.
(Shown in rows of 10)
'''
terms = take(100)(
oeisA000005()
)
columnWidth = 1 + len(str(max(terms)))
print(
'\n'.join(
''.join(
str(term).rjust(columnWidth)
for term in row
)
for row in chunksOf(10)(terms)
)
)
# ----------------------- GENERIC ------------------------
# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
'''A series of lists of length n, subdividing the
contents of xs. Where the length of xs is not evenly
divible, the final list will be shorter than n.
'''
def go(xs):
return [
xs[i:n + i] for i in range(0, len(xs), n)
] if 0 < n else None
return go
# 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):
]
# take :: Int -> [a] -> [a]
# take :: Int -> String -> String
def take(n):
'''The prefix of xs of length n,
or xs itself if n > length xs.
'''
def go(xs):
return (
xs[0:n]
if isinstance(xs, (list, tuple))
else list(islice(xs, n))
)
return go
# MAIN ---
if __name__ == '__main__':
main()
- Output:
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
Quackery
factors
is defined at Factors of an integer#Quackery.
[ factors size ] is tau ( n --> n )
[] []
100 times [ i^ 1+ tau join ]
witheach [ number$ nested join ]
70 wrap$
- Output:
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
R
This only takes one line.
lengths(sapply(1:100, function(n) c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))
Racket
#lang racket
(define limit 100)
(define (divisor-count n)
(length (filter (λ (x) (zero? (remainder n x))) (range 1 (add1 n)))))
(printf "Count of divisors of the integers from 1 to ~a are~n" limit)
(for ([n (in-range 1 (add1 limit))])
(printf (~a (divisor-count n) #:width 5 #:align 'right))
(when (zero? (remainder n 10))
(newline)))
- Output:
Count of divisors of the integers from 1 to 100 are 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
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.
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
- 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
simplified, made ooRexx compatible, corrected for tau of squares, corrected for a range with fewer than cols numbers.
/* REXX program counts the number of divisors (tau,cr sigma_0) */
/* for a range of numbers */
Parse Arg lo hi cols . /*obtain optional argument from the CL.*/
If lo=='' | lo==',' Then lo=1 /*Not specified? Then use the default.*/
If hi=='' | hi==',' Then hi=lo+100-1 /*Not specified? Then use the default.*/
If cols=='' Then cols=20 /* " " " " " " */
w=2+(hi>45359) /* width of columns tau(4mns5360)=100 */
Say 'The number of divisors (tau) from' lo 'to' hi '(inclusive):'
Say ''
Say '-number' center(' tau (number of divisors) ',cols*(w+1)+1,'-')
line=''
c=0
index=lo
Do j=lo To hi
c=c+1
line=line right(tau(j),w) /* add a tau number to the output line. */
If c//cols=0 Then Do /* line has cols numbers */
Say center(index,7) line
line=''
cnt=0
Index=index+cols
End
End /*j*/
If line\=='' Then
Say center(index,7) line /*there any residuals left To display ? */
Exit 0 /*stick a fork in it, we're all done. */
/*---------------------------------------------------------------------------------*/
tau: Procedure
Parse Arg x
If x<6 Then /* some low numbers are handled special */
Return 2+(x==4)-(x==1)
tau=0
odd=x//2
Do j=1 by 1 While j*j<x
If odd & j//2=0 Then /* even j can't be a divisor of an odd x*/
Iterate
If x//j==0 Then /* if no remainder, then found a divisor*/
tau=tau+2 /* bump n of divisors */
End
If j*j=x Then /* x is a square */
tau=tau+1 /* its root is a divisor */
Return tau
- output when using the default input:
The number of divisors (tau) from 1 to 100 (inclusive): -number ----------------- tau (number of divisors) ------------------ 1 1 2 2 3 2 4 2 4 3 4 2 6 2 4 4 5 2 6 2 6 21 4 4 2 8 3 4 4 6 2 8 2 6 4 4 4 9 2 4 4 8 41 2 8 2 6 6 4 2 10 3 6 4 6 2 8 4 8 4 4 2 12 61 2 4 6 7 4 8 2 6 4 8 2 12 2 4 6 6 4 8 2 10 81 5 4 2 12 4 4 4 8 2 12 4 6 4 4 4 12 2 6 6 9
Ring
see "The tau functions for the first 100 positive integers are:" + nl
n = 0
num = 0
limit = 100
while num < limit
n = n + 1
tau = 0
for m = 1 to n
if n%m = 0
tau = tau + 1
ok
next
num = num + 1
if num%10 = 1
see nl
ok
tau = string(tau)
if len(tau) = 1
tau = " " + tau
ok
see "" + tau + " "
end
Output:
The tau functions for the first 100 positive integers are: 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
RPL
RPL Code | Python code |
---|---|
≪ → n ≪ 0 1 1 n √ FOR ii IF n ii MOD NOT THEN SWAP 1 + SWAP DROP n ii / IP IF DUP ii ≠ THEN SWAP 1 + SWAP END END NEXT DROP ≫ ≫ ‘TAU’ STO |
(n -- tau(n) ) ans, j = 0, 1 while i*i <= n: if 0 == n%i: ans += 1 j = n//i if j != i: ans += 1 i += 1 return ans . |
The following line of command delivers what is required:
≪ {} 1 100 FOR j j TAU + NEXT ≫ EVAL
- Output:
1: { 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 }
Optimized algorithm
RPL code | Comment |
---|---|
≪ DUP √ DUP FP 0 -1 IFTE 1 ROT FOR j OVER j MOD NOT DUP + + NEXT SWAP DROP ≫ ‘TAU’ STO |
( n -- tau(n) ) counter set at -1 if n square, 0 otherwise while j ≤ n² add 2 to counter for each dividing j forget n |
Ruby
require 'prime'
def tau(n) = n.prime_division.inject(1){|res, (d, exp)| res *= exp + 1}
(1..100).map{|n| tau(n).to_s.rjust(3) }.each_slice(20){|ar| puts ar.join}
- Output:
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
Rust
// returns the highest power of i that is a factor of n,
// and n divided by that power of i
fn factor_exponent(n: i32, i: i32) -> (i32, i32) {
if n % i == 0 {
let (a, b) = factor_exponent(n / i, i);
(a + 1, b)
} else {
(0, n)
}
}
fn tau(n: i32) -> i32 {
for i in 2..(n+1) {
if n % i == 0 {
let (count, next) = factor_exponent(n, i);
return (count + 1) * tau(next);
}
}
return 1;
}
fn main() {
for i in 1..101 {
print!("{} ", tau(i));
}
}
Output:
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
S-BASIC
rem - return the value of n mod m
function mod(n, m = integer) = integer
end = n - m * (n / m)
rem - return the tau value (number of divisors) of n
function tau(n = integer) = integer
var i, t, limit = integer
if n < 3 then
t = n
else
begin
t = 2
limit = (n + 1) / 2
for i = 2 to limit
if mod(n, i) = 0 then t = t + 1
next i
end
end = t
rem - test by printing the tau value of the first 100 numbers
var i = integer
print "Number of divisors for first 100 numbers:"
for i = 1 to 100
print using "## "; tau(i);
if mod(i, 10) = 0 then print
next i
end
- Output:
Number of divisors for first 100 numbers: 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
Scala
object TauFunction {
private def divisorCount(n: Long): Long = {
var count = 1L
var number = n
// Deal with powers of 2 first
while ((number & 1L) == 0) {
count += 1
number >>= 1
}
// Odd prime factors up to the square root
var p = 3L
while (p * p <= number) {
var tempCount = 1L
while (number % p == 0) {
tempCount += 1
number /= p
}
count *= tempCount
p += 2
}
// If n > 1 then it's prime
if (number > 1) {
count *= 2
}
count
}
def main(args: Array[String]): Unit = {
val limit = 100
println(s"Count of divisors for the first $limit positive integers:")
for (n <- 1 to limit) {
print(f"${divisorCount(n)}%3d")
if (n % 20 == 0) println()
}
}
}
- Output:
Count of divisors for the first 100 positive integers: 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
Sidef
Built-in:
say { .sigma0 }.map(1..100).join(' ')
- Output:
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
Swift
import Foundation
// See https://en.wikipedia.org/wiki/Divisor_function
func divisorCount(number: Int) -> Int {
var n = number
var total = 1
// Deal with powers of 2 first
while (n & 1) == 0 {
total += 1
n >>= 1
}
// Odd prime factors up to the square root
var p = 3
while p * p <= n {
var count = 1
while n % p == 0 {
count += 1
n /= p
}
total *= count
p += 2
}
// If n > 1 then it's prime
if n > 1 {
total *= 2
}
return total
}
let limit = 100
print("Count of divisors for the first \(limit) positive integers:")
for n in 1...limit {
print(String(format: "%3d", divisorCount(number: n)), terminator: "")
if n % 20 == 0 {
print()
}
}
- Output:
Count of divisors for the first 100 positive integers: 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
Tiny BASIC
LET N = 0
10 LET N = N + 1
IF N < 3 THEN GOTO 100
LET T = 2
LET A = 1
20 LET A = A + 1
IF (N/A)*A = N THEN LET T = T + 1
IF A<(N+1)/2 THEN GOTO 20
30 PRINT "Tau(",N,") = ",T
IF N<100 THEN GOTO 10
END
100 LET T = N
GOTO 30
Verilog
module main;
integer N, T, A;
initial begin
$display("The tau functions for the first 100 positive integers are:\n");
for (N = 1; N <= 100; N=N+1) begin
if (N < 3) T = N;
else begin
T = 2;
for (A = 2; A <= (N+1)/2; A=A+1) begin
if (N % A == 0) T = T + 1;
end
end
$write(T);
if (N % 10 == 0) $display("");
end
$finish ;
end
endmodule
Wren
import "./math" for Int
import "./fmt" for Fmt
System.print("The tau functions for the first 100 positive integers are:")
for (i in 1..100) {
Fmt.write("$2d ", Int.divisors(i).count)
if (i % 20 == 0) System.print()
}
- Output:
The tau functions for the first 100 positive integers are: 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
XPL0
int N, D, C;
[Format(3, 0);
for N:= 1 to 100 do
[C:= 0;
for D:= 1 to N do
if rem(N/D) = 0 then C:= C+1;
RlOut(0, float(C));
if rem(N/20) = 0 then CrLf(0);
];
]
- Output:
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
- Programming Tasks
- Solutions by Programming Task
- Mathematics
- 11l
- AArch64 Assembly
- Action!
- ALGOL 68
- ALGOL-M
- ALGOL W
- APL
- AppleScript
- ARM Assembly
- Arturo
- Asymptote
- AutoHotkey
- AWK
- BASIC
- BASIC256
- Gambas
- Chipmunk Basic
- MSX Basic
- QBasic
- Run BASIC
- True BASIC
- XBasic
- Yabasic
- Bc
- BCPL
- BQN
- C
- C++
- C sharp
- Clojure
- CLU
- COBOL
- Cowgol
- D
- Dart
- Delphi
- System.SysUtils
- Draco
- Dyalect
- EasyLang
- EMal
- F Sharp
- Factor
- Fermat
- Forth
- FreeBASIC
- Frink
- Go
- GW-BASIC
- Haskell
- J
- Java
- Jq
- Julia
- Lua
- Mathematica
- Wolfram Language
- MiniScript
- Modula-2
- Nim
- PARI/GP
- Pascal
- Free Pascal
- PascalABC.NET
- Perl
- Ntheory
- Phix
- PL/I
- PL/M
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- REXX
- Ring
- RPL
- Ruby
- Rust
- S-BASIC
- Scala
- Sidef
- Swift
- Tiny BASIC
- Verilog
- Wren
- Wren-math
- Wren-fmt
- XPL0