Data commit

Task/Tau-function/00-META.yaml

@@ -0,0 +1,4 @@
+---
+category:
+- Mathematics
+from: http://rosettacode.org/wiki/Tau_function

Task/Tau-function/00-TASK.txt

@@ -0,0 +1,11 @@
+Given a positive integer, count the number of its positive divisors.
+
+
+;Task
+Show the result for the first   '''100'''   positive integers.
+
+
+;Related task
+*  [[Tau number]]
+<br><br>
+

Task/Tau-function/11l/tau-function.11l

@@ -0,0 +1,14 @@
+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)))

Task/Tau-function/AArch64-Assembly/tau-function.aarch64

@@ -0,0 +1,88 @@
+/* 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"

Task/Tau-function/ALGOL-68/tau-function.alg

@@ -0,0 +1,32 @@
+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

Task/Tau-function/ALGOL-M/tau-function.alg

@@ -0,0 +1,39 @@
+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

Task/Tau-function/ALGOL-W/tau-function.alg

@@ -0,0 +1,36 @@
+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.

Task/Tau-function/APL/tau-function.apl

@@ -0,0 +1,2 @@
+tau ← 0+.=⍳|⊢
+tau¨ 5 20⍴⍳100

Task/Tau-function/ARM-Assembly/tau-function.arm

@@ -0,0 +1,90 @@
+/* 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"

Task/Tau-function/AWK/tau-function.awk

@@ -0,0 +1,19 @@
+# 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)
+}

Task/Tau-function/Action-/tau-function.action

@@ -0,0 +1,38 @@
+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

Task/Tau-function/AppleScript/tau-function-1.applescript

@@ -0,0 +1,24 @@
+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

Task/Tau-function/AppleScript/tau-function-2.applescript

@@ -0,0 +1,6 @@
+"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"

Task/Tau-function/Arturo/tau-function.arturo

@@ -0,0 +1,5 @@
+tau: function [x] -> size factors x
+
+loop split.every:20 1..100 => [
+    print map & => [pad to :string tau & 3]
+]

Task/Tau-function/AutoHotkey/tau-function.ahk

@@ -0,0 +1,14 @@
+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
+}

Task/Tau-function/BASIC/tau-function.basic

@@ -0,0 +1,18 @@
+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

Task/Tau-function/BASIC256/tau-function.basic

@@ -0,0 +1,16 @@
+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

Task/Tau-function/BCPL/tau-function.bcpl

@@ -0,0 +1,26 @@
+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')
+    $)

Task/Tau-function/BQN/tau-function.bqn

@@ -0,0 +1,2 @@
+Tau ← +´0=(1+↕)|⊢
+Tau¨ 5‿20⥊1+↕100

Task/Tau-function/Bc/tau-function.bc

@@ -0,0 +1,9 @@
+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)

Task/Tau-function/C++/tau-function.cpp

@@ -0,0 +1,31 @@
+#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';
+    }
+}

Task/Tau-function/C/tau-function.c

@@ -0,0 +1,38 @@
+#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;
+}

Task/Tau-function/CLU/tau-function.clu

@@ -0,0 +1,29 @@
+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

Task/Tau-function/COBOL/tau-function.cobol

@@ -0,0 +1,65 @@
+       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.

Task/Tau-function/Clojure/tau-function.clj

@@ -0,0 +1,21 @@
+(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)))))

Task/Tau-function/Cowgol/tau-function.cowgol

@@ -0,0 +1,39 @@
+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;

Task/Tau-function/D/tau-function.d

@@ -0,0 +1,34 @@
+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;
+        }
+    }
+}

Task/Tau-function/Delphi/tau-function.delphi

@@ -0,0 +1,38 @@
+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.

Task/Tau-function/Draco/tau-function.draco

@@ -0,0 +1,30 @@
+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

Task/Tau-function/Dyalect/tau-function.dyalect

@@ -0,0 +1,33 @@
+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
+}

Task/Tau-function/EMal/tau-function.emal

@@ -0,0 +1,18 @@
+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

Task/Tau-function/F-Sharp/tau-function.fs

@@ -0,0 +1,6 @@
+// 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 ""

Task/Tau-function/Factor/tau-function.factor

@@ -0,0 +1,17 @@
+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

Task/Tau-function/Fermat/tau-function.fermat

@@ -0,0 +1,13 @@
+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;

Task/Tau-function/Forth/tau-function.fth

@@ -0,0 +1,33 @@
+: 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

Task/Tau-function/Free-Pascal/tau-function.pas

@@ -0,0 +1,56 @@
+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.

Task/Tau-function/FreeBASIC/tau-function.basic

@@ -0,0 +1,13 @@
+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

Task/Tau-function/Frink/tau-function.frink

@@ -0,0 +1,5 @@
+tau[n] := length[allFactors[n]]
+
+for n=1 to 100
+   print[tau[n] + " "]
+println[]

Task/Tau-function/GW-BASIC/tau-function.basic

@@ -0,0 +1,9 @@
+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

Task/Tau-function/Gambas/tau-function.gambas

@@ -0,0 +1,20 @@
+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

Task/Tau-function/Go/tau-function.go

@@ -0,0 +1,33 @@
+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()
+        }
+    }
+}

Task/Tau-function/Haskell/tau-function.hs

@@ -0,0 +1,12 @@
+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]

Task/Tau-function/J/tau-function.j

@@ -0,0 +1,3 @@
+tau =: [:+/0=>:@i.|]
+echo tau"0 [5 20$>:i.100
+exit ''

Task/Tau-function/Java/tau-function.java

@@ -0,0 +1,33 @@
+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();
+            }
+        }
+    }
+}

Task/Tau-function/Jq/tau-function-1.jq

@@ -0,0 +1,8 @@
+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] + .;

Task/Tau-function/Jq/tau-function-2.jq

@@ -0,0 +1,2 @@
+[range(1;101) | count(divisors)]
+| nwise(10) | map(lpad(4)) | join("")

Task/Tau-function/Julia/tau-function.julia

@@ -0,0 +1,13 @@
+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

Task/Tau-function/Lua/tau-function.lua

@@ -0,0 +1,33 @@
+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

Task/Tau-function/Mathematica/tau-function.math

@@ -0,0 +1 @@
+DivisorSum[#, 1 &] & /@ Range[100]

Task/Tau-function/Modula-2/tau-function.mod2

@@ -0,0 +1,33 @@
+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.

Task/Tau-function/Nim/tau-function.nim

@@ -0,0 +1,12 @@
+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()

Task/Tau-function/PARI-GP/tau-function.parigp

@@ -0,0 +1 @@
+vector(100,X,numdiv(X))

Task/Tau-function/PL-I/tau-function.pli

@@ -0,0 +1,23 @@
+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;

Task/Tau-function/PL-M/tau-function.plm

@@ -0,0 +1,50 @@
+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

Task/Tau-function/Pascal/tau-function.pas

@@ -0,0 +1,43 @@
+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.

Task/Tau-function/Perl/tau-function.pl

@@ -0,0 +1,10 @@
+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);

Task/Tau-function/Phix/tau-function-1.phix

@@ -0,0 +1,6 @@
+(phixonline)-->
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">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>
+<!--

Task/Tau-function/Phix/tau-function-2.phix

@@ -0,0 +1,4 @@
+(phixonline)-->
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">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>
+<!--

Task/Tau-function/PureBasic/tau-function.basic

@@ -0,0 +1,11 @@
+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

Task/Tau-function/Python/tau-function-1.py

@@ -0,0 +1,33 @@
+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)))

Task/Tau-function/Python/tau-function-2.py

@@ -0,0 +1,17 @@
+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)))

Task/Tau-function/Python/tau-function-3.py

@@ -0,0 +1,87 @@
+'''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()

Task/Tau-function/QBasic/tau-function.basic

@@ -0,0 +1,15 @@
+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

Task/Tau-function/Quackery/tau-function.quackery

@@ -0,0 +1,6 @@
+  [ factors size ] is tau ( n --> n )
+
+  [] []
+  100 times [ i^ 1+ tau join ]
+  witheach [ number$ nested join ]
+  70 wrap$

Task/Tau-function/R/tau-function.r

@@ -0,0 +1 @@
+lengths(sapply(1:100, function(n) c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n)))

Task/Tau-function/REXX/tau-function.rexx

@@ -0,0 +1,32 @@
+/*REXX program counts the number of divisors (tau,  or sigma_0)  up to and including  N.*/
+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=='' | cols==","  then cols= 20           /* "      "         "   "   "     "    */
+w= 2 + (HI>45359)                                /*W:  used to align the output columns.*/
+say 'The number of divisors  (tau)  for integers up to '    n    " (inclusive):";      say
+say '─index─'   center(" tau (number of divisors) ",  cols * (w+1)  +  1,  '─')
+$=;                                   c= 0       /*$:  the output list,  shown ROW/line.*/
+                do j=LO  to HI;       c= c + 1   /*list # proper divisors (tau) 1 ──► N */
+                $= $  right( tau(j), w)          /*add a tau number to the output list. */
+                if c//cols \== 0  then iterate   /*Not a multiple of ROW? Don't display.*/
+                idx= j - cols + 1                /*calculate index value (for this row).*/
+                say center(idx, 7)    $;  $=     /*display partial list to the terminal.*/
+                end   /*j*/
+
+if $\==''  then say center(idx+cols, 7)    $     /*there any residuals left to display ?*/
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+tau: procedure; parse arg x 1 y                  /*X  and  $  are both set from the arg.*/
+     if x<6  then return 2 + (x==4) - (x==1)     /*some low #s should be handled special*/
+     odd= x // 2                                 /*check if  X  is odd (remainder of 1).*/
+     if odd  then       #= 2                     /*Odd?    Assume divisor count of  2.  */
+             else do;   #= 4;   y= x % 2;   end  /*Even?      "      "      "    "  4.  */
+                                                 /* [↑]  start with known number of divs*/
+        do j=3  for x%2-3  by 1+odd  while j<y   /*for odd number,  skip even numbers.  */
+        if x//j==0  then do                      /*if no remainder, then found a divisor*/
+                         #= # + 2;   y= x % j    /*bump # of divisors;  calculate limit.*/
+                         if j>=y  then do;   #= # - 1;   leave;   end   /*reached limit?*/
+                         end                     /*                     ___             */
+                    else if j*j>x  then leave    /*only divide up to   √ x              */
+        end   /*j*/;               return #      /* [↑]  this form of DO loop is faster.*/

Task/Tau-function/Racket/tau-function.rkt

@@ -0,0 +1,12 @@
+#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)))

Task/Tau-function/Raku/tau-function.raku

@@ -0,0 +1,18 @@
+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

Task/Tau-function/Ring/tau-function.ring

@@ -0,0 +1,23 @@
+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

Task/Tau-function/Ruby/tau-function.rb

@@ -0,0 +1,5 @@
+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}

Task/Tau-function/Run-BASIC/tau-function.basic

@@ -0,0 +1,15 @@
+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

Task/Tau-function/Rust/tau-function.rust

@@ -0,0 +1,26 @@
+// 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));
+	}
+}

Task/Tau-function/S-BASIC/tau-function.basic

@@ -0,0 +1,28 @@
+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

Task/Tau-function/Sidef/tau-function.sidef

@@ -0,0 +1 @@
+say { .sigma0 }.map(1..100).join(' ')

Task/Tau-function/Swift/tau-function.swift

@@ -0,0 +1,37 @@
+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()
+    }
+}

Task/Tau-function/Tiny-BASIC/tau-function.basic

@@ -0,0 +1,13 @@
+    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

Task/Tau-function/True-BASIC/tau-function.basic

@@ -0,0 +1,16 @@
+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

Task/Tau-function/Verilog/tau-function.v

@@ -0,0 +1,20 @@
+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

Task/Tau-function/Wren/tau-function.wren

@@ -0,0 +1,8 @@
+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()
+}

Task/Tau-function/XBasic/tau-function.basic

@@ -0,0 +1,24 @@
+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

Task/Tau-function/XPL0/tau-function.xpl0

@@ -0,0 +1,10 @@
+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);
+    ];
+]

Task/Tau-function/Yabasic/tau-function.basic

@@ -0,0 +1,15 @@
+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