Data commit

Task/Tau-number/00-META.yaml

@@ -0,0 +1,5 @@
+---
+category:
+- Mathematics
+from: http://rosettacode.org/wiki/Tau_number
+note: Prime Numbers

Task/Tau-number/00-TASK.txt

@@ -0,0 +1,12 @@
+A [[wp:Refactorable_number|Tau number]] is a positive integer divisible by the count of its positive divisors.
+
+
+;Task
+Show the first   '''100'''   Tau numbers.
+The numbers shall be ''generated'' during run-time (i.e. the code may not contain string literals, sets/arrays of integers, or alike).
+
+
+;Related task
+*  [[Tau function]]
+<br><br>
+

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

@@ -0,0 +1,25 @@
+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
+
+F is_tau_number(n)
+   I n <= 0
+      R 0B
+   R 0 == n % tau(n)
+
+V n = 1
+[Int] ans
+L ans.len < 100
+   I is_tau_number(n)
+      ans.append(n)
+   n++
+print(ans)

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

@@ -0,0 +1,39 @@
+BEGIN # find tau numbers - numbers divisible by the count of theoir divisors #
+    # 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 #
+            INT p := 1;
+            WHILE  p +:= 2;
+                   ( 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 tau limit  = 100;
+        INT tau count := 0;
+        print( ( "The first ", whole( tau limit, 0 ), " tau numbers:", newline ) );
+        FOR n WHILE tau count < tau limit DO
+            IF n MOD divisor count( n ) = 0 THEN
+                tau count +:= 1;
+                print( ( whole( n, -6 ) ) );
+                IF tau count MOD 10 = 0 THEN print( ( newline ) ) FI
+            FI
+        OD
+    END
+END

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

@@ -0,0 +1,35 @@
+begin
+
+integer array dcount[1:1100];
+integer i, j, n;
+
+integer function mod(a,b);
+integer a,b;
+mod := a-a/b*b;
+
+% Calculate counts of divisors for 1 .. 1100 %
+for i := 1 step 1 until 1100 do dcount[i] := 1;
+for i := 2 step 1 until 1100 do
+begin
+    j := i;
+    while j <= 1100 do
+    begin
+        dcount[j] := dcount[j] + 1;
+        j := j + i;
+    end;
+end;
+
+n := 0;
+i := 1;
+while n < 100 do
+begin
+    if mod(i, dcount[i])=0 then
+    begin
+        if mod(n, 10)=0
+            then write(i)
+            else writeon(i);
+        n := n + 1;
+    end;
+    i := i + 1;
+end;
+end

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

@@ -0,0 +1 @@
+(⊢(/⍨)(0=(0+.=⍳|⊢)|⊢)¨)⍳ 1096

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

@@ -0,0 +1,22 @@
+# syntax: GAWK -f TAU_NUMBER.AWK
+BEGIN {
+    print("The first 100 tau numbers:")
+    while (count < 100) {
+      i++
+      if (i % count_divisors(i) == 0) {
+        printf("%4d ",i)
+        if (++count % 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-number/Action-/tau-number.action

@@ -0,0 +1,41 @@
+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 n=[1],max=[100],count=[0],divCount
+
+  WHILE count<max
+  DO
+    divCount=DivisorCount(n)
+    IF n MOD divCount=0 THEN
+      PrintC(n) Put(32)
+      count==+1
+    FI
+    n==+1
+  OD
+RETURN

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

@@ -0,0 +1,30 @@
+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, counter, astid
+set output to {"First 100 tau numbers:"}
+set n to 0
+set counter to 0
+repeat until (counter = 100)
+    set n to n + 1
+    if (n mod (factorCount(n)) = 0) then
+        set counter to counter + 1
+        if (counter mod 20 = 1) then set end of output to linefeed
+        set end of output to text -5 thru -1 of ("    " & n)
+    end if
+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-number/AppleScript/tau-number-2.applescript

@@ -0,0 +1,6 @@
+"First 100 tau numbers:
+    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 1016 1040 1044 1048 1056 1068 1089 1096"

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

@@ -0,0 +1,12 @@
+tau: function [x] -> size factors x
+
+found: 0
+i:1
+while [found<100][
+    if 0 = i % tau i [
+        prints pad to :string i 5
+        found: found + 1
+        if 0 = found % 10 -> print ""
+    ]
+    i: i + 1
+]

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

@@ -0,0 +1,17 @@
+n := c:= 0
+while (c<100)
+    if isTau(++n)
+        c++, result .= SubStr("   " n, -3) . (Mod(c, 10) ? " " : "`n")
+MsgBox % result
+return
+
+isTau(num){
+    return (num/(n := StrSplit(Factors(num), ",").Count()) = floor(num/n))
+}
+
+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-number/BASIC/tau-number.basic

@@ -0,0 +1,8 @@
+10 DEFINT A-Z
+20 S=0: N=1
+30 C=1
+40 IF N<>1 THEN FOR I=1 TO N/2: C=C-(N MOD I=0): NEXT
+50 IF N MOD C=0 THEN PRINT N,: S=S+1
+60 N=N+1
+70 IF S<100 THEN 30
+80 END

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

@@ -0,0 +1,18 @@
+print "The first 100 tau numbers are:"
+
+n = 0
+num = 0
+limit = 100
+while num < limit
+	n += 1
+	tau = 0
+	for m = 1 to n
+		if n mod m = 0 then tau += 1
+	next m
+	if n mod tau = 0 then
+		num += 1
+		if num mod 10 = 1 then print
+		print n; "  ";
+	end if
+end while
+end

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

@@ -0,0 +1,33 @@
+get "libhdr"
+
+// Count the divisors of 1..N
+let divcounts(v, n) be
+$(  // Every positive number is divisible by 1
+    for i=1 to n do v!i := 1;
+    for i=2 to n do
+    $(  let j = i
+        while j <= n do
+        $(  // J is divisible by I
+            v!j := v!j + 1
+            j := j + i
+        $)
+    $)
+$)
+
+// Given a stored vector of divisors counts, is a number a tau number?
+let tau(v, i) = i rem v!i = 0
+
+let start() be
+$(  let dvec = vec 1100
+    let n, seen = 1, 0
+
+    divcounts(dvec, 1100) // find amount of divisors for each number
+    while seen < 100 do
+    $(  if tau(dvec, n) then
+        $(  writed(n, 5)
+            seen := seen + 1
+            if seen rem 10 = 0 then wrch('*N')
+        $)
+        n := n + 1
+    $)
+$)

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

@@ -0,0 +1,35 @@
+#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 << "The first " << limit << " tau numbers are:\n";
+    unsigned int count = 0;
+    for (unsigned int n = 1; count < limit; ++n) {
+        if (n % divisor_count(n) == 0) {
+            std::cout << std::setw(6) << n;
+            ++count;
+            if (count % 10 == 0)
+                std::cout << '\n';
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+unsigned int divisor_count(unsigned int n) {
+    unsigned int total = 1;
+    unsigned int p;
+
+    // Deal with powers of 2 first
+    for (; (n & 1) == 0; n >>= 1) {
+        ++total;
+    }
+    // Odd prime factors up to the square root
+    for (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 count = 0;
+    unsigned int n;
+
+    printf("The first %d tau numbers are:\n", limit);
+    for (n = 1; count < limit; ++n) {
+        if (n % divisor_count(n) == 0) {
+            printf("%6d", n);
+            ++count;
+            if (count % 10 == 0) {
+                printf("\n");
+            }
+        }
+    }
+
+    return 0;
+}

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

@@ -0,0 +1,33 @@
+% Count the divisors of [1..N]
+count_divisors = proc (n: int) returns (sequence[int])
+    divs: array[int] := array[int]$fill(1, n, 1)
+    for i: int in int$from_to(2, n) do
+        for j: int in int$from_to_by(i, n, i) do
+            divs[j] := divs[j] + 1
+        end
+    end
+    return(sequence[int]$a2s(divs))
+end count_divisors
+
+% Find Tau numbers up to a given limit
+tau_numbers = iter (lim: int) yields (int)
+    divs: sequence[int] := count_divisors(lim)
+    n: int := 0
+    while n < lim do
+        n := n + 1
+        if n // divs[n] = 0 then yield(n) end
+    end
+end tau_numbers
+
+% Show the first 100 Tau numbers
+start_up = proc ()
+    po: stream := stream$primary_output()
+    seen: int := 0
+
+    for n: int in tau_numbers(1100) do
+        seen := seen + 1
+        stream$putright(po, int$unparse(n), 5)
+        if seen // 10 = 0 then stream$putl(po, "") end
+        if seen >= 100 then break end
+    end
+end start_up

Task/Tau-number/Clojure/tau-number.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-number/Cowgol/tau-number.cowgol

@@ -0,0 +1,35 @@
+include "cowgol.coh";
+# <nowiki>Numbered list item</nowiki>
+
+# Get count of positive divisors of number
+sub pos_div(num: uint16): (count: uint16) is
+    count := 1;
+    if num != 1 then
+        var cur: uint16 := 1;
+        while cur <= num/2 loop
+            if num % cur == 0 then
+                count := count + 1;
+            end if;
+            cur := cur + 1;
+        end loop;
+    end if;
+end sub;
+
+# Print first 100 Tau numbers
+var nums: uint8 := 0;
+var cur: uint16 := 0;
+var col: uint16 := 10;
+while nums < 100 loop
+    cur := cur + 1;
+    if cur % pos_div(cur) == 0 then
+        print_i16(cur);
+        col := col - 1;
+        if col == 0 then
+            print_nl();
+            col := 10;
+        else
+            print_char('\t');
+        end if;
+        nums := nums + 1;
+    end if;
+end loop;

Task/Tau-number/Craft-Basic/tau-number.basic

@@ -0,0 +1,31 @@
+define count = 0, num = 0, mod = 0
+define nums = 100, tau = 0
+
+do
+
+	let count = count + 1
+	let tau = 0
+	let mod = 1
+
+	do
+
+		if count % mod = 0 then
+
+			let tau = tau + 1
+
+		endif
+
+		let mod = mod + 1
+
+	loop mod < count + 1
+
+	if count % tau = 0 then
+
+		let num = num + 1
+		print count
+
+	endif
+
+loop num < nums
+
+end

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

@@ -0,0 +1,37 @@
+import std.stdio;
+
+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("The first ", limit, " tau numbers are:");
+    uint count = 0;
+    for (uint n = 1; count < limit; ++n) {
+        if (n % divisor_count(n) == 0) {
+            writef("%6d", n);
+            ++count;
+            if (count % 10 == 0) {
+                writeln;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+program Tau_number;
+
+{$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 first 100 tau numbers are:');
+  var count := 0;
+  var i := 1;
+  while count < 100 do
+  begin
+    var tf := CountDivisors(i);
+    if i mod tf = 0 then
+    begin
+      write(format('%4d ', [i]));
+      inc(count);
+      if count mod 10 = 0 then
+        writeln;
+    end;
+    inc(i);
+  end;
+
+  {$IFNDEF UNIX}  readln; {$ENDIF}
+end.

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

@@ -0,0 +1,30 @@
+/* Generate a table of the amount of divisors for each number */
+proc nonrec div_count([*]word divs) void:
+    word max, i, j;
+    max := dim(divs,1)-1;
+    divs[0] := 0;
+    for i from 1 upto max do divs[i] := 1 od;
+    for i from 2 upto max do
+        for j from i by i upto max do
+            divs[j] := divs[j] + 1
+        od
+    od
+corp
+
+/* Find Tau numbers */
+proc nonrec main() void:
+    [1100]word divs;
+    word n, seen;
+
+    div_count(divs);
+    seen := 0;
+    n := 0;
+
+    while n := n + 1; seen < 100 do
+        if n % divs[n] = 0 then
+            seen := seen + 1;
+            write(n:5);
+            if seen % 10 = 0 then writeln() fi
+        fi
+    od
+corp

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

@@ -0,0 +1,2 @@
+// Tau number. Nigel Galloway: March 9th., 2021
+Seq.initInfinite((+)1)|>Seq.filter(fun n->n%(tau n)=0)|>Seq.take 100|>Seq.iter(printf "%d "); printfn ""

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

@@ -0,0 +1,13 @@
+USING: assocs grouping io kernel lists lists.lazy math
+math.functions math.primes.factors prettyprint sequences
+sequences.extras ;
+
+: tau ( n -- count ) group-factors values [ 1 + ] map-product ;
+
+: tau? ( n -- ? ) dup tau divisor? ;
+
+: taus ( -- list ) 1 lfrom [ tau? ] lfilter ;
+
+! Task
+"The first 100 tau numbers are:" print
+100 taus ltake list>array 10 group simple-table.

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

@@ -0,0 +1,21 @@
+Func Istau(t) =
+    if t<3 then Return(1) else
+        numdiv:=2;
+        for q = 2 to t\2 do
+            if Divides(q, t) then numdiv:=numdiv+1 fi;
+        od;
+        if Divides(numdiv, t)=1 then Return(1) else Return(0) fi;
+    fi;
+    .;
+
+numtau:=0;
+i:=0;
+
+while numtau<100 do
+    i:=i+1;
+    if Istau(i) = 1 then
+        numtau:=numtau+1;
+        !(i,'   ');
+        if Divides(10, numtau) then !! fi;
+    fi;
+od;

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

@@ -0,0 +1,43 @@
+: 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_tau_numbers ( n -- )
+  ." The first " dup . ." tau numbers are:" cr
+  0 >r
+  1
+  begin
+    over r@ >
+  while
+    dup dup divisor_count mod 0= if
+      dup 6 .r
+      r> 1+
+      dup 10 mod 0= if cr else space then
+      >r
+    then
+    1+
+  repeat
+  2drop rdrop ;
+
+100 print_tau_numbers
+bye

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

@@ -0,0 +1,55 @@
+program Tau_number;
+{$IFDEF Windows}  {$APPTYPE CONSOLE} {$ENDIF}
+  function CountDivisors(n: NativeUint): integer;
+  //tau function
+  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+= 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+= cnt;
+        end;
+        Inc(p, 2);
+      end;
+      if n <> 1 then
+        divCnt += divCnt;
+    end;
+    CountDivisors := divCnt;
+  end;
+
+const
+  UPPERLIMIT = 100;
+var
+  cnt,n: NativeUint;
+begin
+  cnt := 0;
+  n := 1;
+  repeat
+    if n MOD CountDivisors(n) = 0 then
+    Begin
+      write(n:5);
+      inc(cnt);
+      if cnt Mod 10 = 0 then
+        writeln;
+    end;
+    inc(n);
+  until cnt >= UPPERLIMIT;
+  writeln;
+  {$Ifdef Windows}readln;{$ENDIF}
+end.

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

@@ -0,0 +1,22 @@
+function numdiv( n as uinteger ) as uinteger
+    dim as uinteger c = 2
+    for i as uinteger = 2 to (n+1)\2
+        if n mod i = 0 then c += 1
+    next i
+    return c
+end function
+
+function istau( n as uinteger ) as boolean
+    if n = 1 then return true
+    if n mod numdiv(n) = 0 then return true else return false
+end function
+
+dim as uinteger c = 0, i=1
+while c < 100
+    if istau(i) then
+        print i,
+        c += 1
+        if c mod 10 = 0 then print
+    end if
+    i += 1
+wend

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

@@ -0,0 +1,2 @@
+tau = {|x| x mod length[allFactors[x]] == 0}
+println[formatTable[columnize[first[select[count[1], tau], 100], 10], "right"]]

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

@@ -0,0 +1,40 @@
+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 first 100 tau numbers are:")
+    count := 0
+    i := 1
+    for count < 100 {
+        tf := countDivisors(i)
+        if i%tf == 0 {
+            fmt.Printf("%4d  ", i)
+            count++
+            if count%10 == 0 {
+                fmt.Println()
+            }
+        }
+        i++
+    }
+}

Task/Tau-number/Haskell/tau-number-1.hs

@@ -0,0 +1,15 @@
+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)
+
+isTau :: Integral a => a -> Bool
+isTau n = 0 == mod n (tau n)
+
+main = print . take 100 . filter isTau $ [1..]

Task/Tau-number/Haskell/tau-number-2.hs

@@ -0,0 +1,33 @@
+import Data.List (group, scanl)
+import Data.List.Split (chunksOf)
+import Data.Numbers.Primes (primeFactors)
+
+----------------------- TAU NUMBERS ----------------------
+
+tauNumbers :: [Int]
+tauNumbers =
+  filter
+    ((0 ==) . (rem <*> (length . divisors)))
+    [1 ..]
+
+--------------------------- TEST -------------------------
+main :: IO ()
+main =
+  let xs = take 100 $ fmap show tauNumbers
+      w = length $ last xs
+   in (putStrLn . unlines) $
+        unwords . fmap (justifyRight w ' ')
+          <$> chunksOf 10 xs
+
+------------------------- GENERIC ------------------------
+
+divisors :: Int -> [Int]
+divisors =
+  foldr
+    (flip ((<*>) . fmap (*)) . scanl (*) 1)
+    [1]
+    . group
+    . primeFactors
+
+justifyRight :: Int -> Char -> String -> String
+justifyRight n c = (drop . length) <*> (replicate n c <>)

Task/Tau-number/J/tau-number-1.j

@@ -0,0 +1,2 @@
+   tau_number=: 0 = (|~ tally_factors@>)
+   tally_factors=: [: */ 1 + _&q:

Task/Tau-number/J/tau-number-2.j

@@ -0,0 +1,5 @@
+   (i.4 25){ (#~ tau_number) 1+i.2000
+  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 1016 1040 1044 1048 1056 1068 1089 1096

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

@@ -0,0 +1,37 @@
+public class Tau {
+    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 long limit = 100;
+        System.out.printf("The first %d tau numbers are:%n", limit);
+        long count = 0;
+        for (long n = 1; count < limit; ++n) {
+            if (n % divisorCount(n) == 0) {
+                System.out.printf("%6d", n);
+                ++count;
+                if (count % 10 == 0) {
+                    System.out.println();
+                }
+            }
+        }
+    }
+}

Task/Tau-number/Jq/tau-number-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-number/Jq/tau-number-2.jq

@@ -0,0 +1,5 @@
+def taus: range(1;infinite) | select(. % count(divisors) == 0);
+
+# The first 100 Tau numbers:
+[limit(100; taus)]
+| nwise(10) | map(lpad(4)) | join(" ")

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

@@ -0,0 +1,22 @@
+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
+
+function taunumbers(toget = 100)
+    n = 0
+    for i in 1:100000000
+        if i % numfactors(i) == 0
+            n += 1
+            print(rpad(i, 5), n % 20 == 0 ? " \n" : "")
+            n == toget && break
+        end
+    end
+end
+
+taunumbers()

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

@@ -0,0 +1,40 @@
+function divisor_count(n)
+    local total = 1
+
+    -- Deal with powers of 2 first
+    while (n & 1) == 0 do
+        total = total + 1
+        n = n >> 1
+    end
+    -- Odd prime factors up to the square root
+    local p = 3
+    while p * p <= n do
+        local count = 1
+        while n % p == 0 do
+            count = count + 1
+            n = math.floor(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
+
+local limit = 100
+local count = 0
+print("The first " .. limit .. " tau numbers are:")
+local n = 1
+while count < limit do
+    if n % divisor_count(n) == 0 then
+        io.write(string.format("%6d", n))
+        count = count + 1
+        if count % 10 == 0 then
+            print()
+        end
+    end
+    n = n + 1
+end

Task/Tau-number/M2000-Interpreter/tau-number.m2000

@@ -0,0 +1,16 @@
+module tau_numbers {
+	print "The first 100 tau numbers are:"
+	long n, num, limit=100, tau, m
+	while num < limit
+		n++:
+		tau=0
+		for m=1 to n{if n mod m=0 then tau++}
+		if n mod tau= 0 else continue
+		num++:if num mod 10 = 1 then print
+		print format$("{0::-5}",n);
+	end while
+	print
+}
+profiler
+tau_numbers
+print timecount

Task/Tau-number/MAD/tau-number.mad

@@ -0,0 +1,20 @@
+            NORMAL MODE IS INTEGER
+
+            INTERNAL FUNCTION(N)
+                ENTRY TO POSDIV.
+                COUNT = 1
+                THROUGH DIV, FOR I=2, 1, I.G.N
+DIV             WHENEVER N/I*I.E.N, COUNT = COUNT+1
+                FUNCTION RETURN COUNT
+            END OF FUNCTION
+
+            SEEN=0
+            THROUGH TAU, FOR X=1, 1, SEEN.GE.100
+            DIVS=POSDIV.(X)
+            WHENEVER X/DIVS*DIVS.E.X
+                PRINT FORMAT NUM,X
+                SEEN = SEEN+1
+TAU         END OF CONDITIONAL
+
+            VECTOR VALUES NUM = $I4*$
+            END OF PROGRAM

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

@@ -0,0 +1 @@
+Take[Select[Range[10000], Divisible[#, Length[Divisors[#]]] &], 100]

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

@@ -0,0 +1,42 @@
+MODULE TauNumbers;
+FROM InOut IMPORT WriteCard, WriteLn;
+
+CONST
+    MaxNum = 1100; (* enough to generate 100 Tau numbers *)
+    NumTau = 100;  (* how many Tau numbers to generate *)
+
+VAR DivCount: ARRAY [1..MaxNum] OF CARDINAL;
+    seen, n: CARDINAL;
+
+(* Find the amount of divisors for each number beforehand *)
+PROCEDURE CountDivisors;
+VAR i, j: CARDINAL;
+BEGIN
+    FOR i := 1 TO MaxNum DO
+        DivCount[i] := 1; (* every number is divisible by 1 *)
+    END;
+
+    FOR i := 2 TO MaxNum DO
+        j := i;
+        WHILE j <= MaxNum DO (* J is divisible by I *)
+            DivCount[j] := DivCount[j] + 1;
+            j := j + i; (* next multiple of i *)
+        END;
+    END;
+END CountDivisors;
+
+BEGIN
+    CountDivisors();
+    n := 1;
+    seen := 0;
+    WHILE seen < NumTau DO
+        IF n MOD DivCount[n] = 0 THEN
+            WriteCard(n, 5);
+            INC(seen);
+            IF seen MOD 10 = 0 THEN
+                WriteLn();
+            END;
+        END;
+        INC(n);
+    END;
+END TauNumbers.

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

@@ -0,0 +1,22 @@
+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
+
+var count = 0
+var n = 1
+var tauNumbers: seq[Natural]
+while true:
+  if n mod divcount(n) == 0:
+    tauNumbers.add n
+    inc count
+    if count == 100: break
+  inc n
+
+echo "First 100 tau numbers:"
+for i, n in tauNumbers:
+  stdout.write ($n).align(5)
+  if i mod 20 == 19: echo()

Task/Tau-number/PILOT/tau-number.pilot

@@ -0,0 +1,16 @@
+T :1
+C :n=2
+C :seen=1
+C :max=100
+*number
+C :c=1
+C :i=1
+*divisor
+C (n=i*(n/i)):c=c+1
+C :i=i+1
+J (i<=n/2):*divisor
+T (n=c*(n/c)):#n
+C (n=c*(n/c)):seen=seen+1
+C :n=n+1
+J (seen<max):*number
+E :

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

@@ -0,0 +1,64 @@
+100H:
+BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
+EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
+PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
+
+/* PRINT NUMBER RIGHT-ALIGNED IN 7 POSITIONS */
+PRINT$NUMBER: PROCEDURE (N);
+    DECLARE S (7) BYTE INITIAL (' .....$');
+    DECLARE N ADDRESS, I BYTE;
+    I = 6;
+DIGIT:
+    I = I - 1;
+    S(I) = N MOD 10 + '0';
+    N = N / 10;
+    IF N > 0 THEN GO TO DIGIT;
+    DO WHILE I <> 0;
+        I = I - 1;
+        S(I) = ' ';
+    END;
+    CALL PRINT(.S);
+END PRINT$NUMBER;
+
+/* COUNT AND STORE AMOUNT OF DIVISORS FOR 1..N AT VEC */
+COUNT$DIVS: PROCEDURE (VEC, N);
+    DECLARE (VEC, N, V BASED VEC) ADDRESS;
+    DECLARE (I, J) ADDRESS;
+
+    DO I=1 TO N;
+        V(I) = 1;
+    END;
+
+    DO I=2 TO N;
+        J = I;
+        DO WHILE J <= N;
+            V(J) = V(J) + 1;
+            J = J + I;
+        END;
+    END;
+END COUNT$DIVS;
+
+/* GIVEN VECTOR OF COUNT OF DIVISORS, SEE IF N IS A TAU NUMBER */
+TAU: PROCEDURE (VEC, N) BYTE;
+    DECLARE (VEC, N, V BASED VEC) ADDRESS;
+    RETURN N MOD V(N) = 0;
+END TAU;
+
+DECLARE AMOUNT LITERALLY '100';
+DECLARE LIMIT LITERALLY '1100';
+
+DECLARE SEEN BYTE INITIAL (0);
+DECLARE N ADDRESS INITIAL (1);
+
+CALL COUNT$DIVS(.MEMORY, LIMIT);
+DO WHILE SEEN < AMOUNT;
+    IF TAU(.MEMORY, N) THEN DO;
+        CALL PRINT$NUMBER(N);
+        SEEN = SEEN + 1;
+        IF SEEN MOD 10 = 0 THEN CALL PRINT(.(13,10,'$'));
+    END;
+    N = N + 1;
+END;
+
+CALL EXIT;
+EOF

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

@@ -0,0 +1,11 @@
+use strict;
+use warnings;
+use feature 'say';
+use ntheory 'divisors';
+
+my(@x,$n);
+
+do { push(@x,$n) unless $n % scalar(divisors(++$n)) } until 100 == @x;
+
+say "Tau numbers - first 100:\n" .
+    ((sprintf "@{['%5d' x 100]}", @x[0..100-1]) =~ s/(.{80})/$1\n/gr);

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

@@ -0,0 +1,11 @@
+(phixonline)-->
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">found</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+ <span style="color: #008080;">while</span> <span style="color: #000000;">found</span><span style="color: #0000FF;"><</span><span style="color: #000000;">100</span> <span style="color: #008080;">do</span>
+     <span style="color: #008080;">if</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</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;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)))=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
+         <span style="color: #000000;">found</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</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;">"%,6d"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</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;">found</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</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;">if</span>
+     <span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+<!--

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

@@ -0,0 +1,15 @@
+(phixonline)-->
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">tau_cache</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">1</span><span style="color: #0000FF;">}</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">tau</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">></span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tau_cache</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">nt</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">tau_cache</span><span style="color: #0000FF;">[$]+</span><span style="color: #000000;">1</span>
+         <span style="color: #008080;">while</span> <span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">nt</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;">nt</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)))!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">do</span>
+             <span style="color: #000000;">nt</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+         <span style="color: #000000;">tau_cache</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">nt</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">tau_cache</span><span style="color: #0000FF;">[</span><span style="color: #000000;">n</span><span style="color: #0000FF;">]</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</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;">"%,6d"</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">apply</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;">tau</span><span style="color: #0000FF;">)}),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">))</span>
+<!--

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

@@ -0,0 +1,20 @@
+OpenConsole()
+
+Procedure.i numdiv(n)
+  c=2
+  For i=2 To (n+1)/2 : If n%i=0 : c+1 : EndIf : Next
+  ProcedureReturn c
+EndProcedure
+
+Procedure.b istau(n)
+  If n=1 : ProcedureReturn #True : EndIf
+  If n%numdiv(n)=0 : ProcedureReturn #True : Else : ProcedureReturn #False : EndIf
+EndProcedure
+
+c=0 : i=1
+While c<100
+  If istau(i) : Print(RSet(Str(i),4)+#TAB$) : c+1 : If c%10=0 : PrintN("") : EndIf: EndIf
+  i+1
+Wend
+
+Input()

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

@@ -0,0 +1,26 @@
+def tau(n):
+    assert(isinstance(n, int) and 0 < n)
+    ans, i, j = 0, 1, 1
+    while i*i <= n:
+        if 0 == n%i:
+            ans += 1
+            j = n//i
+            if j != i:
+                ans += 1
+        i += 1
+    return ans
+
+def is_tau_number(n):
+    assert(isinstance(n, int))
+    if n <= 0:
+        return False
+    return 0 == n%tau(n)
+
+if __name__ == "__main__":
+    n = 1
+    ans = []
+    while len(ans) < 100:
+        if is_tau_number(n):
+            ans.append(n)
+        n += 1
+    print(ans)

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

@@ -0,0 +1,130 @@
+'''Tau numbers'''
+
+from operator import mul
+from math import floor, sqrt
+from functools import reduce
+from itertools import (
+    accumulate, chain, count,
+    groupby, islice, product
+)
+
+
+# tauNumbers :: Generator [Int]
+def tauNumbers():
+    '''Positive integers divisible by the
+       count of their positive divisors.
+    '''
+    return (
+        n for n in count(1)
+        if 0 == n % len(divisors(n))
+    )
+
+
+# ------------------------- TEST -------------------------
+# main :: IO ()
+def main():
+    '''The first hundred Tau numbers.
+    '''
+    xs = take(100)(
+        tauNumbers()
+    )
+    w = len(str(xs[-1]))
+    print('\n'.join([
+        ' '.join([
+            str(cell).rjust(w, ' ') for cell in row
+        ])
+        for row in chunksOf(10)(xs)
+    ]))
+
+
+# ----------------------- 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):
+    '''The ordered divisors of n.
+    '''
+    def go(a, x):
+        return [a * b for a, b in product(
+            a,
+            accumulate(chain([1], x), mul)
+        )]
+    return sorted(
+        reduce(go, [
+            list(g) for _, g
+            in groupby(primeFactors(n))
+        ], [1])
+    ) if 1 < n else [1]
+
+
+# primeFactors :: Int -> [Int]
+def primeFactors(n):
+    '''A list of the prime factors of n.
+    '''
+    def f(qr):
+        r = qr[1]
+        return step(r), 1 + r
+
+    def step(x):
+        return 1 + (x << 2) - ((x >> 1) << 1)
+
+    def go(x):
+        root = floor(sqrt(x))
+
+        def p(qr):
+            q = qr[0]
+            return root < q or 0 == (x % q)
+
+        q = until(p)(f)(
+            (2 if 0 == x % 2 else 3, 1)
+        )[0]
+        return [x] if q > root else [q] + go(x // q)
+
+    return go(n)
+
+
+# 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
+
+
+# until :: (a -> Bool) -> (a -> a) -> a -> a
+def until(p):
+    '''The result of repeatedly applying f until p holds.
+       The initial seed value is x.
+    '''
+    def go(f):
+        def g(x):
+            v = x
+            while not p(v):
+                v = f(v)
+            return v
+        return g
+    return go
+
+
+# MAIN ---
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,18 @@
+PRINT "The first 100 tau numbers are:"
+
+n = 0
+num = 0
+limit = 100
+DO
+      n = n + 1
+      tau = 0
+      FOR m = 1 TO n
+          IF n MOD m = 0 THEN tau = tau + 1
+      NEXT m
+      IF n MOD tau = 0 THEN
+         num = num + 1
+         IF num MOD 10 = 1 THEN PRINT
+         PRINT USING " ####"; n; '""; n; " ";
+      END IF
+LOOP WHILE num < limit
+END

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

@@ -0,0 +1,10 @@
+  [ dup factors size mod 0 = ] is taunumber ( n --> b )
+
+  [] 0
+  [ 1+ dup taunumber if
+      [ tuck join swap ]
+    over size 100 = until ]
+  drop
+  [] swap
+  witheach [ number$ nested join ]
+  80 wrap$

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

@@ -0,0 +1,18 @@
+tau <- function(t)
+{
+  results <- integer(0)
+  resultsCount <- 0
+  n <- 1
+  while(resultsCount != t)
+  {
+    condition <- function(n) (n %% length(c(Filter(function(x) n %% x == 0, seq_len(n %/% 2)), n))) == 0
+    if(condition(n))
+    {
+      resultsCount <- resultsCount + 1
+      results[resultsCount] <- n
+    }
+    n <- n + 1
+  }
+  results
+}
+tau(100)

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

@@ -0,0 +1,38 @@
+/*REXX pgm displays   N   tau numbers,  an integer divisible by the # of its divisors). */
+parse arg n cols .                               /*obtain optional argument from the CL.*/
+if    n=='' |    n==","  then    n= 100          /*Not specified?  Then use the default.*/
+if cols=='' | cols==","  then cols=  10          /*Not specified?  Then use the default.*/
+w= max(8, length(n) )                            /*W:  used to align 1st output column. */
+@tau= ' the first '  commas(n)   " tau numbers " /*the title of the tau numbers table.  */
+say ' index │'center(@tau,  1 + cols*(w+1)     ) /*display the title of the output table*/
+say '───────┼'center(""  ,  1 + cols*(w+1), '─') /*   "     " header  "  "     "     "  */
+idx= 1;                  #= 0;           $=      /*idx: line;   #:  tau numbers;  $: #s */
+           do j=1  until #==n                    /*search for   N   tau numbers         */
+           if j//tau(j) \==0  then iterate       /*Is this a tau number?  No, then skip.*/
+           #= # + 1                              /*bump the count of tau numbers found. */
+           $= $  right( commas(j), w)            /*add a tau number to the output list. */
+           if #//cols\==0     then iterate       /*Not a multiple of cols?  Don't show. */
+           say center(idx, 7)'│'   substr($, 2)  /*display partial list to the terminal.*/
+           idx= idx + cols;               $=     /*bump idx by number of cols; nullify $*/
+           end   /*j*/
+
+if $\==''  then say center(idx, 7)"│"  substr($, 2)  /*possible display residual output.*/
+say '───────┴'center(""  ,  1 + cols*(w+1), '─')
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+commas: parse arg ?;  do jc=length(?)-3  to 1  by -3; ?=insert(',', ?, jc); end;  return ?
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+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 do;   #= 2;               end  /*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*/                              /* [↑]  this form of DO loop is faster.*/
+     return #

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

@@ -0,0 +1,19 @@
+#lang racket
+
+(define limit 100)
+
+(define (divisor-count n)
+  (length (filter (λ (x) (zero? (remainder n x))) (range 1 (+ 1 n)))))
+
+(define (display-tau-numbers (n 1) (count 1))
+  (when (<= count limit)
+    (if (zero? (remainder n (divisor-count n)))
+       (begin
+         (printf (~a n #:width 5 #:align 'right))
+         (when (zero? (remainder count 10))
+           (newline))
+         (display-tau-numbers (add1 n) (add1 count)))
+       (display-tau-numbers (add1 n) count))))
+
+(printf "The first ~a Τau numbers are~n" limit)
+(display-tau-numbers)

Task/Tau-number/Raku/tau-number.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-number/Ring/tau-number.ring

@@ -0,0 +1,21 @@
+see "The first 100 tau numbers are:" + nl + nl
+
+n = 1
+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
+      if n%tau = 0
+         num = num + 1
+         if num%10 = 1
+            see nl
+         ok
+         see "" + n + " "
+      ok
+end

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

@@ -0,0 +1,10 @@
+require 'prime'
+
+taus = Enumerator.new do |y|
+  (1..).each do |n|
+    num_divisors = n.prime_division.inject(1){|prod, n| prod *= n[1] + 1 }
+    y << n if n % num_divisors == 0
+  end
+end
+
+p taus.take(100)

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

@@ -0,0 +1,18 @@
+print "The first 100 tau numbers are:"
+
+n = 0
+num = 0
+limit = 100
+while num < limit
+    n = n +1
+    tau = 0
+    for m = 1 to n
+        if n mod m = 0 then tau = tau +1
+    next m
+    if n mod tau = 0 then
+        num = num +1
+        if num mod 10 = 1 then print
+        print using("######", n);
+    end if
+wend
+end

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

@@ -0,0 +1,30 @@
+/// Gets all divisors of a number, including itself
+fn get_divisors(n: u32) -> Vec<u32> {
+    let mut results = Vec::new();
+
+    for i in 1..(n / 2 + 1) {
+        if n % i == 0 {
+            results.push(i);
+        }
+    }
+    results.push(n);
+    results
+}
+
+fn is_tau_number(i: u32) -> bool {
+    0 == i % get_divisors(i).len() as u32
+}
+
+fn main() {
+    println!("\nFirst 100 Tau numbers:");
+    let mut counter: u32 = 0;
+    let mut i: u32 = 1;
+    while counter < 100 {
+        if is_tau_number(i) {
+            print!("{:>4}", i);
+            counter += 1;
+            print!("{}", if counter % 20 == 0 { "\n" } else { "," });
+        }
+        i += 1;
+    }
+}

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

@@ -0,0 +1,5 @@
+func is_tau_number(n) {
+    n % n.sigma0 == 0
+}
+
+say is_tau_number.first(100).join(' ')

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

@@ -0,0 +1,43 @@
+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("The first \(limit) tau numbers are:")
+var count = 0
+var n = 1
+while count < limit {
+    if n % divisorCount(number: n) == 0 {
+        print(String(format: "%5d", n), terminator: "")
+        count += 1
+        if count % 10 == 0 {
+            print()
+        }
+    }
+    n += 1
+}

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

@@ -0,0 +1,16 @@
+LET n = 0
+LET num = 0
+LET limit = 100
+DO
+   LET n = n + 1
+   LET tau = 0
+   FOR m = 1 TO n
+       IF REMAINDER(n, m) = 0 THEN LET tau = tau + 1
+   NEXT m
+   IF REMAINDER(n, tau) = 0 THEN
+      LET num = num + 1
+      IF REMAINDER(num, 10) = 1 THEN PRINT
+      PRINT ""; n; " ";
+   END IF
+LOOP WHILE num < limit
+END

Task/Tau-number/VTL-2/tau-number.vtl-2

@@ -0,0 +1,22 @@
+10 N=1100
+20 I=1
+30 :I)=1
+40 I=I+1
+50 #=N>I*30
+60 I=2
+70 J=I
+80 :J)=:J)+1
+90 J=J+I
+100 #=N>J*80
+110 I=I+1
+120 #=N>I*70
+130 C=0
+140 I=1
+150 #=I/:I)*0+0<%*210
+160 ?=I
+170 $=9
+180 C=C+1
+190 #=C/10*0+0<%*210
+200 ?=""
+210 I=I+1
+220 #=C<100*150

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

@@ -0,0 +1,23 @@
+module main;
+  integer n, m, num, limit, tau;
+
+  initial begin
+    $display("The first 100 tau numbers are:\n");
+    n = 0;
+    num = 0;
+    limit = 100;
+
+    while (num < limit) begin
+      n = n + 1;
+      tau = 0;
+      for (m = 1; m <= n; m=m+1) if (n % m == 0) tau = tau + 1;
+
+      if (n % tau == 0) begin
+        num = num + 1;
+        if (num % 5 == 1) $display("");
+        $write(n);
+      end
+    end
+    $finish ;
+  end
+endmodule

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

@@ -0,0 +1,15 @@
+import "/math" for Int
+import "/fmt" for Fmt
+
+System.print("The first 100 tau numbers are:")
+var count = 0
+var i = 1
+while (count < 100) {
+    var tf = Int.divisors(i).count
+    if (i % tf == 0) {
+        Fmt.write("$,5d  ", i)
+        count = count + 1
+        if (count % 10 == 0) System.print()
+    }
+    i = i + 1
+}

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

@@ -0,0 +1,20 @@
+func Divs(N);   \Return number of divisors of N
+int  N, D, C;
+[C:= 0;
+for D:= 1 to N do
+    if rem(N/D) = 0 then C:= C+1;
+return C;
+];
+
+int C, N;
+[Format(5, 0);
+C:= 0;  N:= 1;
+loop    [if rem(N/Divs(N)) = 0 then
+            [RlOut(0, float(N));
+            C:= C+1;
+            if rem(C/10) = 0 then CrLf(0);
+            if C >= 100 then quit;
+            ];
+        N:= N+1;
+        ];
+]

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

@@ -0,0 +1,19 @@
+print "The first 100 tau numbers are:"
+
+n = 0
+num = 0
+limit = 100
+while num < limit
+      n = n + 1
+      tau = 0
+      for m = 1 to n
+          if mod(n, m) = 0 then tau = tau + 1 : fi
+      next m
+      if mod(n, tau) = 0 then
+         num = num + 1
+         if mod(num, 10) = 1 then print : fi
+         print n using "####";
+      end if
+wend
+print
+end