Data commit

Task/M-bius-function/00-META.yaml

@@ -0,0 +1,3 @@
+---
+from: http://rosettacode.org/wiki/Möbius_function
+note: Prime Numbers

Task/M-bius-function/00-TASK.txt

@@ -0,0 +1,29 @@
+The classical '''Möbius function: μ(n)''' is an important multiplicative function in number theory and combinatorics.
+
+There are several ways to implement a Möbius function.
+
+A fairly straightforward method is to find the prime factors of a positive integer '''n''', then define '''μ(n)''' based on the sum of the primitive factors. It has the values '''{−1, 0, 1}''' depending on the factorization of '''n''':
+
+:*  '''μ(1)''' is defined to be '''1'''.
+
+:*  '''μ(n) = 1''' if '''n''' is a square-free positive integer with an '''even''' number of prime factors.
+
+:*  '''μ(n) = −1''' if '''n''' is a square-free positive integer with an '''odd''' number of prime factors.
+
+:*  '''μ(n) = 0''' if '''n''' has a '''squared''' prime factor.
+
+
+;Task:
+:* Write a routine (function, procedure, whatever) '''μ(n)''' to find the Möbius number for a positive integer '''n'''.
+
+:* Use that routine to find and display here, on this page, at least the first 99 terms in a grid layout. (Not just one long line or column of numbers.)
+
+
+;See also:
+:*; [[wp:Möbius function|Wikipedia: Möbius function]]
+
+
+;Related Tasks:
+:*; [[Mertens function]]
+<br><br>
+

Task/M-bius-function/11l/m-bius-function.11l

@@ -0,0 +1,32 @@
+F isPrime(n)
+   I n < 2
+      R 0B
+   L(i) 2 .. n
+      I i * i <= n & n % i == 0
+         R 0B
+   R 1B
+
+F mobius(n)
+   I n == 1
+      R 1
+
+   V p = 0
+   L(i) 1 .. n
+      I n % i == 0 & isPrime(i)
+         I n % (i * i) == 0
+            R 0
+         E
+            p = p + 1
+
+   I p % 2 != 0
+      R -1
+   E
+      R 1
+
+print(‘Mobius numbers from 1..99:’)
+
+L(i) 1..99
+   print(f:‘{mobius(i):4}’, end' ‘’)
+
+   I i % 20 == 0
+      print()

Task/M-bius-function/ALGOL-68/m-bius-function.alg

@@ -0,0 +1,27 @@
+BEGIN
+    # show the first 199 values of the moebius function                 #
+    INT sq root = 1 000;
+    INT mu max  = sq root * sq root;
+    [ 1 : mu max ]INT mu;
+    FOR i FROM LWB mu TO UPB mu DO mu[ i ] := 1 OD;
+    FOR i FROM 2 TO sq root DO
+        IF mu[ i ] = 1 THEN
+            # for each factor found, swap + and -                       #
+            FOR j FROM i     BY i     TO UPB mu DO mu[ j ] *:= -i OD;
+            FOR j FROM i * i BY i * i TO UPB mu DO mu[ j ]  :=  0 OD
+        FI
+    OD;
+    FOR i FROM 2 TO UPB mu DO
+        IF   mu[ i ] =  i THEN mu[ i ] :=  1
+        ELIF mu[ i ] = -i THEN mu[ i ] := -1
+        ELIF mu[ i ] <  0 THEN mu[ i ] :=  1
+        ELIF mu[ i ] >  0 THEN mu[ i ] := -1
+      # ELSE mu[ i ] =  0 so no change #
+        FI
+    OD;
+    print( ( "First 199 terms of the möbius function are as follows:", newline, "    " ) );
+    FOR i TO 199 DO
+        print( ( whole( mu[ i ], -4 ) ) );
+        IF ( i + 1 ) MOD 20 = 0 THEN print( ( newline ) ) FI
+    OD
+END

Task/M-bius-function/AWK/m-bius-function.awk

@@ -0,0 +1,46 @@
+# syntax: GAWK -f MOBIUS_FUNCTION.AWK
+# converted from Java
+BEGIN {
+    printf("first 199 terms of the mobius sequence:\n   ")
+    for (n=1; n<200; n++) {
+      printf("%3d",mobius(n))
+      if ((n+1) % 20 == 0) {
+        printf("\n")
+      }
+    }
+    exit(0)
+}
+function mobius(n,  i,j,mu_max) {
+    if (n in MU) {
+      return(MU[n])
+    }
+    mu_max = 1000000
+    for (i=0; i<mu_max; i++) { # populate array
+      MU[i] = 1
+    }
+    for (i=2; i<=int(sqrt(mu_max)); i++ ) {
+      if (MU[i] == 1) {
+        for (j=i; j<=mu_max; j+=i) { # for each factor found, swap + and -
+          MU[j] *= -i
+        }
+        for (j=i*i; j<=mu_max; j+=i*i) { # square factor = 0
+          MU[j] = 0
+        }
+      }
+    }
+    for (i=2; i<=mu_max; i++) {
+      if (MU[i] == i) {
+        MU[i] = 1
+      }
+      else if (MU[i] == -i) {
+        MU[i] = -1
+      }
+      else if (MU[i] < 0) {
+        MU[i] = 1
+      }
+      else if (MU[i] > 0) {
+        MU[i] = -1
+      }
+    }
+    return(MU[n])
+}

Task/M-bius-function/Applesoft-BASIC/m-bius-function.basic

@@ -0,0 +1,23 @@
+10 HOME
+20 FOR t = 0 TO 9
+30 FOR u = 1 TO 10
+40   n = 10*t+u
+50   GOSUB 130
+60   IF STR$(m) = "0" THEN PRINT "  0";
+70   IF STR$(m) = "1" THEN PRINT "  1";
+80   IF STR$(m) = "-1" THEN PRINT " -1";
+90 NEXT u
+100 PRINT
+110 NEXT t
+120 END
+130 IF n = 1 THEN m = 1 : RETURN
+140 m = 1 : f = 2
+150 IF (n-INT(n/(f*f))*(f*f)) = 0 THEN m = 0 : RETURN
+160 IF (n-INT(n/(f))*(f)) = 0 THEN GOSUB 200
+170 f = f+1
+180 IF f <= n THEN GOTO 150
+190 RETURN
+200 m = -m
+210 n = n/f
+220 RETURN
+230 END

Task/M-bius-function/Arturo/m-bius-function.arturo

@@ -0,0 +1,12 @@
+mobius: function [n][
+    if n=0 -> return ""
+    if n=1 -> return 1
+    f: factors.prime n
+
+    if f <> unique f -> return 0
+    if? odd? size f -> return neg 1
+    else -> return 1
+]
+
+loop split.every:20 map 0..199 => mobius 'a ->
+    print map a => [pad to :string & 3]

Task/M-bius-function/AutoHotkey/m-bius-function.ahk

@@ -0,0 +1,46 @@
+loop 100
+    result .= SubStr("  " Möbius(A_Index), -1) . (Mod(A_Index, 10) ? "  " : "`n")
+MsgBox, 262144, , % result
+return
+
+Möbius(n){
+    if n=1
+        return 1
+    x := prime_factors(n)
+    c := x.Count()
+    sq := []
+    for i, v in x
+        if sq[v]
+            return 0
+        else
+            sq[v] := 1
+    return (c/2 = floor(c/2)) ? 1 : -1
+}
+
+prime_factors(n) {
+    if (n <= 3)
+        return [n]
+    ans := [], done := false
+    while !done {
+        if !Mod(n, 2)
+            ans.push(2), n /= 2
+        else if !Mod(n, 3)
+            ans.push(3), n /= 3
+        else if (n = 1)
+            return ans
+        else {
+            sr := sqrt(n), done := true, i := 6
+            while (i <= sr+6) {
+                if !Mod(n, i-1) { ; is n divisible by i-1?
+                    ans.push(i-1), n /= i-1, done := false
+                    break
+                }
+                if !Mod(n, i+1) { ; is n divisible by i+1?
+                    ans.push(i+1), n /= i+1, done := false
+                    break
+                }
+                i += 6
+    }}}
+    ans.push(Format("{:d}", n))
+    return ans
+}

Task/M-bius-function/BASIC256/m-bius-function.basic

@@ -0,0 +1,21 @@
+function mobius(n)
+	if n = 1 then return 1
+	for d = 2 to int(sqr(n))
+		if n mod d = 0 then
+			if n mod (d*d) = 0 then return 0
+			return -mobius(n/d)
+		end if
+	next d
+	return -1
+end function
+
+outstr$ = " .   "
+for i = 1 to 200
+	if mobius(i) >= 0 then outstr$ += " "
+	outstr$ += string(mobius(i)) + "   "
+	if i mod 10 = 9 then
+		print outstr$
+		outstr$ = ""
+	end if
+next i
+end

Task/M-bius-function/C++/m-bius-function.cpp

@@ -0,0 +1,55 @@
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+constexpr int MU_MAX = 1'000'000;
+std::vector<int> MU;
+
+int mobiusFunction(int n) {
+    if (!MU.empty()) {
+        return MU[n];
+    }
+
+    // Populate array
+    MU.resize(MU_MAX + 1, 1);
+    int root = sqrt(MU_MAX);
+
+    for (int i = 2; i <= root; i++) {
+        if (MU[i] == 1) {
+            // for each factor found, swap + and -
+            for (int j = i; j <= MU_MAX; j += i) {
+                MU[j] *= -i;
+            }
+            // square factor = 0
+            for (int j = i * i; j <= MU_MAX; j += i * i) {
+                MU[j] = 0;
+            }
+        }
+    }
+
+    for (int i = 2; i <= MU_MAX; i++) {
+        if (MU[i] == i) {
+            MU[i] = 1;
+        } else if (MU[i] == -i) {
+            MU[i] = -1;
+        } else if (MU[i] < 0) {
+            MU[i] = 1;
+        } else if (MU[i] > 0) {
+            MU[i] = -1;
+        }
+    }
+
+    return MU[n];
+}
+
+int main() {
+    std::cout << "First 199 terms of the möbius function are as follows:\n    ";
+    for (int n = 1; n < 200; n++) {
+        std::cout << std::setw(2) << mobiusFunction(n) << "  ";
+        if ((n + 1) % 20 == 0) {
+            std::cout << '\n';
+        }
+    }
+
+    return 0;
+}

Task/M-bius-function/C/m-bius-function.c

@@ -0,0 +1,55 @@
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int main() {
+    const int MU_MAX = 1000000;
+    int i, j;
+    int *mu;
+    int sqroot;
+
+    sqroot = (int)sqrt(MU_MAX);
+
+    mu = malloc((MU_MAX + 1) * sizeof(int));
+
+    for (i = 0; i < MU_MAX;i++) {
+        mu[i] = 1;
+    }
+
+    for (i = 2; i <= sqroot; i++) {
+        if (mu[i] == 1) {
+            // for each factor found, swap + and -
+            for (j = i; j <= MU_MAX; j += i) {
+                mu[j] *= -i;
+            }
+            // square factor = 0
+            for (j = i * i; j <= MU_MAX; j += i * i) {
+                mu[j] = 0;
+            }
+        }
+    }
+
+    for (i = 2; i <= MU_MAX; i++) {
+        if (mu[i] == i) {
+            mu[i] = 1;
+        } else if (mu[i] == -i) {
+            mu[i] = -1;
+        } else if (mu[i] < 0) {
+            mu[i] = 1;
+        } else if (mu[i] > 0) {
+            mu[i] = -1;
+        }
+    }
+
+    printf("First 199 terms of the möbius function are as follows:\n    ");
+    for (i = 1; i < 200; i++) {
+        printf("%2d  ", mu[i]);
+        if ((i + 1) % 20 == 0) {
+            printf("\n");
+        }
+    }
+
+    free(mu);
+    return 0;
+}

Task/M-bius-function/Chipmunk-Basic/m-bius-function.basic

@@ -0,0 +1,21 @@
+10 CLS
+20 FOR t = 0 TO 9
+30 FOR u = 1 TO 10
+40   n = 10 * t + u
+50   GOSUB 110
+60   PRINT USING "##  "; m;
+70   NEXT u
+80   PRINT
+90 NEXT t
+100 END
+110 IF n = 1 THEN m = 1: RETURN
+120 m = 1: f = 2
+130 IF n MOD (f * f) = 0 THEN m = 0: RETURN
+140 IF n MOD f = 0 THEN GOSUB 180
+150 f = f + 1
+160 IF f <= n THEN GOTO 130
+170 RETURN
+180 m = -m
+190 n = n / f
+200 RETURN
+210 END

Task/M-bius-function/D/m-bius-function.d

@@ -0,0 +1,56 @@
+import std.math;
+import std.stdio;
+
+immutable MU_MAX = 1_000_000;
+
+int mobiusFunction(int n) {
+    static initialized = false;
+    static int[MU_MAX + 1] MU;
+
+    if (initialized) {
+        return MU[n];
+    }
+
+    // populate array
+    MU[] = 1;
+    int root = cast(int) sqrt(cast(real) MU_MAX);
+
+    for (int i = 2; i <= root; i++) {
+        if (MU[i] == 1) {
+            // for each factor found, swap + and -
+            for (int j = i; j <= MU_MAX; j += i) {
+                MU[j] *= -i;
+            }
+            // square factor = 0
+            for (int j = i * i; j <= MU_MAX; j += i * i) {
+                MU[j] = 0;
+            }
+        }
+    }
+
+    for (int i = 2; i <= MU_MAX; i++) {
+        if (MU[i] == i) {
+            MU[i] = 1;
+        } else if (MU[i] == -i) {
+            MU[i] = -1;
+        } else if (MU[i] < 0) {
+            MU[i] = 1;
+        } else if (MU[i] > 0) {
+            MU[i] = -1;
+        }
+    }
+
+    initialized = true;
+    return MU[n];
+}
+
+void main() {
+    writeln("First 199 terms of the möbius function are as follows:");
+    write("    ");
+    for (int n = 1; n < 200; n++) {
+        writef("%2d  ", mobiusFunction(n));
+        if ((n + 1) % 20 == 0) {
+            writeln;
+        }
+    }
+}

Task/M-bius-function/Delphi/m-bius-function.delphi

@@ -0,0 +1,107 @@
+function IsPrime(N: int64): boolean;
+{Fast, optimised prime test}
+var I,Stop: int64;
+begin
+if (N = 2) or (N=3) then Result:=true
+else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
+else
+     begin
+     I:=5;
+     Stop:=Trunc(sqrt(N+0.0));
+     Result:=False;
+     while I<=Stop do
+           begin
+           if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
+           Inc(I,6);
+           end;
+     Result:=True;
+     end;
+end;
+
+
+
+function GetNextPrime(var Start: integer): integer;
+{Get the next prime number after Start}
+{Start is passed by "reference," so the
+{original variable is incremented}
+begin
+repeat Inc(Start)
+until IsPrime(Start);
+Result:=Start;
+end;
+
+
+type TIntArray = array of integer;
+
+
+procedure StoreNumber(N: integer; var IA: TIntArray);
+{Expand and store number in array}
+begin
+SetLength(IA,Length(IA)+1);
+IA[High(IA)]:=N;
+end;
+
+
+procedure GetPrimeFactors(N: integer; var Facts: TIntArray);
+{Get all the prime factors of a number}
+var I: integer;
+begin
+I:=2;
+repeat
+	begin
+	if (N mod I) = 0 then
+		begin
+		StoreNumber(I,Facts);
+		N:=N div I;
+		end
+	else GetNextPrime(I);
+	end
+until N=1;
+end;
+
+
+
+function HasDuplicates(IA: TIntArray): boolean;
+{Look for duplicates factors in array}
+var I: integer;
+begin
+Result:=True;
+for I:=0 to Length(IA)-1 do
+ if IA[I]=IA[I+1] then exit;
+Result:=False;
+end;
+
+
+function Moebius(N: integer): integer;
+{Get moebius function of number}
+var I: integer;
+var Factors: TIntArray;
+var Even,Square: boolean;
+begin
+{Collect all prime factors}
+SetLength(Factors,0);
+GetPrimeFactors(N,Factors);
+{Are there an even number of factors?}
+Even:=(Length(Factors) and 1)=0;
+{If there are duplicates, there are perfect squares}
+Square:=HasDuplicates(Factors);
+{Return the Moebius function value}
+if Square then Result:=0
+else if Even then Result:=1
+else Result:=-1;
+end;
+
+procedure TestMoebiusFactors(Memo: TMemo);
+{Test Moebius function for 1..200-1}
+var N,M: integer;
+var S: string;
+begin
+S:='';
+for N:=1 to 199 do
+	begin
+	M:=Moebius(N);
+	S:=S+Format('%3d',[M]);
+	if (N mod 20)=19 then S:=S+#$0D#$0A
+	end;
+Memo.Text:=S;
+end;

Task/M-bius-function/F-Sharp/m-bius-function.fs

@@ -0,0 +1,9 @@
+// Möbius function. Nigel Galloway: January 31st., 2021
+let fN g=let n=primes32()
+         let rec fN i g e l=match (l/g,l%g,e) with (1,0,false)->i
+                                                  |(n,0,false)->fN (0-i) g true n
+                                                  |(_,0,true) ->0
+                                                  |_          ->fN i (Seq.head n) false l
+         fN -1 (Seq.head n) false g
+let mobius=seq{yield 1; yield! Seq.initInfinite((+)2>>fN)}
+mobius|>Seq.take 500|>Seq.chunkBySize 25|>Seq.iter(fun n->Array.iter(printf "%3d") n;printfn "")

Task/M-bius-function/Factor/m-bius-function.factor

@@ -0,0 +1,5 @@
+USING: formatting grouping io math.extras math.ranges sequences ;
+
+"First 199 terms of the Möbius sequence:" print
+199 [1,b] [ mobius ] map " " prefix 20 group
+[ [ "%3s" printf ] each nl ] each

Task/M-bius-function/Fortran/m-bius-function.f

@@ -0,0 +1,41 @@
+program moebius
+    use iso_fortran_env, only: output_unit
+
+    integer, parameter          :: mu_max=1000000, line_break=20
+    integer, parameter          :: sqroot=int(sqrt(real(mu_max)))
+    integer                     :: i, j
+    integer, dimension(mu_max)  :: mu
+
+    mu = 1
+
+    do i = 2, sqroot
+        if (mu(i) == 1) then
+            do j = i, mu_max, i
+                mu(j) = mu(j) * (-i)
+            end do
+
+            do j = i**2, mu_max, i**2
+                mu(j) = 0
+            end do
+        end if
+    end do
+
+    do i = 2, mu_max
+        if (mu(i) == i) then
+            mu(i) = 1
+        else if (mu(i) == -i) then
+            mu(i) = -1
+        else if (mu(i) < 0) then
+            mu(i) = 1
+        else if (mu(i) > 0) then
+            mu(i) = -1
+        end if
+    end do
+
+    write(output_unit,*) "The first 199 terms of the Möbius sequence are:"
+    write(output_unit,'(3x)', advance="no") ! Alignment of first number
+    do i = 1, 199
+        write(output_unit,'(I2,x)', advance="no") mu(i)
+        if (modulo(i+1, line_break) == 0) write(output_unit,*)
+    end do
+end program moebius

Task/M-bius-function/FreeBASIC/m-bius-function.basic

@@ -0,0 +1,20 @@
+function mobius( n as uinteger ) as integer
+    if n = 1 then return 1
+    for d as uinteger = 2 to int(sqr(n))
+        if n mod d = 0 then
+            if n mod (d*d) = 0 then return 0
+            return -mobius(n/d)
+        end if
+    next d
+    return -1
+end function
+
+dim as string outstr = " .     "
+for i as uinteger = 1 to 200
+    if mobius(i)>=0 then outstr += " "
+    outstr += str(mobius(i))+"     "
+    if i mod 10 = 9 then
+        print outstr
+        outstr = ""
+    end if
+next i

Task/M-bius-function/FutureBasic/m-bius-function.basic

@@ -0,0 +1,43 @@
+local fn IsPrime( n as long ) as BOOL
+  BOOL result = YES
+  long i
+
+  if ( n < 2 ) then result = NO : exit fn
+  for i = 2 to n + 1
+    if ( i * i <= n ) and ( n mod i == 0 )
+      result = NO : exit fn
+    end if
+  next
+end fn = result
+
+local fn Mobius( n as long ) as long
+  long i, p = 0, result = 0
+
+  if ( n == 1 ) then result = 1 : exit fn
+  for i = 1 to n + 1
+    if ( n mod i == 0 ) and ( fn IsPrime( i ) == YES )
+      if ( n mod ( i * i ) == 0 )
+        result = 0 : exit fn
+      else
+        p++
+      end if
+    end if
+  next
+  if( p mod 2 != 0 )
+    result = -1
+  else
+    result = 1
+  end if
+end fn = result
+
+window 1, @"Möbius function", (0,0,600,300)
+
+printf @"First 100 terms of Mobius sequence:"
+
+long i
+for i = 1 to 100
+  printf @"%2ld\t", fn Mobius(i)
+  if ( i mod 20 == 0 ) then print
+next
+
+HandleEvents

Task/M-bius-function/GW-BASIC/m-bius-function.basic

@@ -0,0 +1,19 @@
+10 FOR T = 0 TO 9
+20 FOR U = 1 TO 10
+30 N = 10*T + U
+40 GOSUB 100
+50 PRINT USING "##  ";M;
+60 NEXT U
+70 PRINT
+80 NEXT T
+90 END
+100 IF N = 1 THEN M = 1 : RETURN
+110 M = 1 : F = 2
+120 IF N MOD (F*F) = 0 THEN M = 0 : RETURN
+130 IF N MOD F = 0 THEN GOSUB 170
+140 F = F + 1
+150 IF F <= N THEN GOTO 120
+160 RETURN
+170 M = -M
+180 N = N/F
+190 RETURN

Task/M-bius-function/Go/m-bius-function.go

@@ -0,0 +1,56 @@
+package main
+
+import "fmt"
+
+func möbius(to int) []int {
+    if to < 1 {
+        to = 1
+    }
+    mobs := make([]int, to+1) // all zero by default
+    primes := []int{2}
+    for i := 1; i <= to; i++ {
+        j := i
+        cp := 0      // counts prime factors
+        spf := false // true if there is a square prime factor
+        for _, p := range primes {
+            if p > j {
+                break
+            }
+            if j%p == 0 {
+                j /= p
+                cp++
+            }
+            if j%p == 0 {
+                spf = true
+                break
+            }
+        }
+        if cp == 0 && i > 2 {
+            cp = 1
+            primes = append(primes, i)
+        }
+        if !spf {
+            if cp%2 == 0 {
+                mobs[i] = 1
+            } else {
+                mobs[i] = -1
+            }
+        }
+    }
+    return mobs
+}
+
+func main() {
+    mobs := möbius(199)
+    fmt.Println("Möbius sequence - First 199 terms:")
+    for i := 0; i < 200; i++ {
+        if i == 0 {
+            fmt.Print("    ")
+            continue
+        }
+        if i%20 == 0 {
+            fmt.Println()
+        }
+        fmt.Printf("  % d", mobs[i])
+    }
+}

Task/M-bius-function/Haskell/m-bius-function.hs

@@ -0,0 +1,29 @@
+import Data.List (intercalate)
+import Data.List.Split (chunksOf)
+import Data.Vector.Unboxed (toList)
+import Math.NumberTheory.ArithmeticFunctions.Moebius (Moebius(..),
+                                                      sieveBlockMoebius)
+import System.Environment (getArgs, getProgName)
+import System.IO (hPutStrLn, stderr)
+import Text.Read (readMaybe)
+
+-- Calculate the Möbius function, μ(n), for a sequence of values starting at 1.
+moebiusBlock :: Word -> [Moebius]
+moebiusBlock = toList . sieveBlockMoebius 1
+
+showMoebiusBlock :: Word -> [Moebius] -> String
+showMoebiusBlock cols = intercalate "\n" . map (concatMap showMoebius) .
+                        chunksOf (fromIntegral cols)
+  where showMoebius MoebiusN = " -1"
+        showMoebius MoebiusZ = "  0"
+        showMoebius MoebiusP = "  1"
+
+main :: IO ()
+main = do
+  prog <- getProgName
+  args <- map readMaybe <$> getArgs
+  case args of
+    [Just cols, Just n] ->
+      putStrLn ("μ(n) for 1 ≤ n ≤ " ++ show n ++ ":\n") >>
+      putStrLn (showMoebiusBlock cols $ moebiusBlock n)
+    _ -> hPutStrLn stderr $ "Usage: " ++ prog ++ " num-columns maximum-number"

Task/M-bius-function/J/m-bius-function-1.j

@@ -0,0 +1 @@
+mu=: ({{*/1-y>1}} * _1 ^ 2|+/)@q:~&_

Task/M-bius-function/J/m-bius-function-2.j

@@ -0,0 +1,11 @@
+   mu 1+i.10 20
+ 1 _1 _1 0 _1  1 _1 0  0  1 _1 0 _1  1  1 0 _1  0 _1 0
+ 1  1 _1 0  0  1  0 0 _1 _1 _1 0  1  1  1 0 _1  1  1 0
+_1 _1 _1 0  0  1 _1 0  0  0  1 0 _1  0  1 0  1  1 _1 0
+_1  1  0 0  1 _1 _1 0  1 _1 _1 0 _1  1  0 0  1 _1 _1 0
+ 0  1 _1 0  1  1  1 0 _1  0  1 0  1  1  1 0 _1  0  0 0
+_1 _1 _1 0 _1  1 _1 0 _1 _1  1 0 _1 _1  1 0  0  1  1 0
+ 0  1  1 0  0  0 _1 0  1 _1 _1 0  1  1  0 0 _1 _1 _1 0
+ 1  1  1 0  1  1  0 0 _1  0 _1 0  0 _1  1 0 _1  1  1 0
+ 1  0 _1 0 _1  1 _1 0  0 _1  0 0 _1 _1  0 0  1  1 _1 0
+_1 _1  1 0  1 _1  1 0  0 _1 _1 0 _1  1 _1 0 _1  0 _1 0

Task/M-bius-function/Java/m-bius-function.java

@@ -0,0 +1,59 @@
+public class MöbiusFunction {
+
+    public static void main(String[] args) {
+        System.out.printf("First 199 terms of the möbius function are as follows:%n    ");
+        for ( int n = 1 ; n < 200 ; n++ ) {
+            System.out.printf("%2d  ", möbiusFunction(n));
+            if ( (n+1) % 20 == 0 ) {
+                System.out.printf("%n");
+            }
+        }
+    }
+
+    private static int MU_MAX = 1_000_000;
+    private static int[] MU = null;
+
+    //  Compute mobius function via sieve
+    private static int möbiusFunction(int n) {
+        if ( MU != null ) {
+            return MU[n];
+        }
+
+        //  Populate array
+        MU = new int[MU_MAX+1];
+        int sqrt = (int) Math.sqrt(MU_MAX);
+        for ( int i = 0 ; i < MU_MAX ; i++ ) {
+            MU[i] = 1;
+        }
+
+        for ( int i = 2 ; i <= sqrt ; i++ ) {
+            if ( MU[i] == 1 ) {
+                //  for each factor found, swap + and -
+                for ( int j = i ; j <= MU_MAX ; j += i ) {
+                    MU[j] *= -i;
+                }
+                //  square factor = 0
+                for ( int j = i*i ; j <= MU_MAX ; j += i*i ) {
+                    MU[j] = 0;
+                }
+            }
+        }
+
+        for ( int i = 2 ; i <= MU_MAX ; i++ ) {
+            if ( MU[i] == i ) {
+                MU[i] = 1;
+            }
+            else if ( MU[i] == -i ) {
+                MU[i] = -1;
+            }
+            else if ( MU[i] < 0 ) {
+                MU[i] = 1;
+            }
+            else if ( MU[i] > 0 ) {
+                MU[i] = -1;
+            }
+        }
+        return MU[n];
+    }
+
+}

Task/M-bius-function/Jq/m-bius-function-1.jq

@@ -0,0 +1,25 @@
+# Input: a non-negative integer, $n
+# Output: an array of size $n + 1 such that the nth-mobius number is .[$n]
+# i.e. $n|mobius_array[-1]
+# For example, the first mobius number could be evaluated by 1|mobius_array[-1].
+def mobius_array:
+  . as $n
+  | ($n|sqrt) as $sqrt
+  | reduce range(2; 1 + $sqrt) as $i ([range(0; $n + 1) | 1];
+       if .[$i] == 1
+       then # for each factor found, swap + and -
+         reduce range($i; $n + 1; $i) as $j (.; .[$j] *= -$i)
+         | ($i*$i) as $isq #  square factor = 0
+         | reduce range($isq; $n + 1; $isq) as $j (.; .[$j] = 0 )
+       else .
+       end )
+  | reduce range(2; 1 + $n) as $i (.;
+       if   .[$i] ==  $i then .[$i] = 1
+       elif .[$i] == -$i then .[$i] = -1
+       elif .[$i]  <   0 then .[$i] = 1
+       elif .[$i]  >   0 then .[$i] = -1
+       else .[$i] = 0                   # avoid "-0"
+       end);
+
+# For one-off computations:
+def mu($n): $n | mobius_array[-1];

Task/M-bius-function/Jq/m-bius-function-2.jq

@@ -0,0 +1,13 @@
+def nwise($n):
+  def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
+  n;
+
+def task:
+  def pp: if . >=0 then " \(.)" else tostring end;
+  (199 | mobius_array) as $mu
+  | "The first 199 Möbius numbers are:",
+    (["  ", (range(1; 200) | $mu[.] | pp )]
+     | nwise(20)
+     | join(" ") ) ;
+
+task

Task/M-bius-function/Jq/m-bius-function-3.jq

@@ -0,0 +1,54 @@
+# relatively_prime(previous) tests whether the input integer is prime
+# relative to the primes in the array "previous":
+def relatively_prime(previous):
+  . as $in
+  | (previous|length) as $plen
+  # state: [found, ix]
+  | [false, 0]
+  | until( .[0] or .[1] >= $plen;
+           [ ($in % previous[.[1]]) == 0, .[1] + 1] )
+  | .[0] | not ;
+
+# Emit a stream in increasing order of all primes (from 2 onwards)
+# that are less than or equal to mx:
+def primes(mx):
+  # The helper function, next, has arity 0 for tail recursion optimization;
+  # it expects its input to be the array of previously found primes:
+  def next:
+     . as $previous
+     | ($previous | .[length-1]) as $last
+     | if ($last >= mx) then empty
+       else ((2 + $last)
+       | until( relatively_prime($previous) ; . + 2)) as $nextp
+       | if $nextp <= mx
+         then $nextp, (( $previous + [$nextp] ) | next)
+	 else empty
+         end
+       end;
+  if mx <= 1 then empty
+  elif mx == 2 then 2
+  else (2, 3, ([2,3] | next))
+  end ;
+
+# Return an array of the distinct prime factors of . in increasing order
+def prime_factors:
+
+  # Return an array of prime factors of . given that "primes"
+  # is an array of relevant primes:
+  def pf($primes):
+    if . <= 1 then []
+    else . as $in
+    | if ($in | relatively_prime($primes)) then [$in]
+      else reduce $primes[] as $p
+             ([];
+              if ($in % $p) != 0 then .
+ 	      else . + [$p] +  (($in / $p) | pf($primes))
+	      end)
+      end
+      | unique
+    end;
+
+  if . <= 1 then []
+  else . as $in
+  | pf( [ primes( (1+$in) | sqrt | floor)  ] )
+  end;

Task/M-bius-function/Jq/m-bius-function-4.jq

@@ -0,0 +1,21 @@
+def isSquareFree:
+  . as $n
+  | 2
+  | until ( (. * . > $n) or . == 0;
+       if ($n % (.*.) == 0) then 0 # i.e. stop
+       elif . > 2 then . + 2
+       else . + 1
+       end  )
+  | . != 0;
+
+def mu:
+  . as $n
+  | if . < 1 then "Argument to mu must be a positive integer" | error
+    elif . == 1 then 1
+    else if isSquareFree
+         then if ((prime_factors|length) % 2 == 0) then 1
+              else -1
+              end
+         else 0
+         end
+    end;

Task/M-bius-function/Jq/m-bius-function-5.jq

@@ -0,0 +1,12 @@
+def nwise($n):
+  def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
+  n;
+
+def task:
+  def pp: if . >=0 then " \(.)" else tostring end;
+  "The first 199 Möbius numbers are:",
+  (["  ", (range(1; 200) | mu | pp )]
+   | nwise(20)
+   | join(" ") ) ;
+
+task

Task/M-bius-function/Julia/m-bius-function.julia

@@ -0,0 +1,14 @@
+using Primes
+
+# modified from reinermartin's PR at https://github.com/JuliaMath/Primes.jl/pull/70/files
+function moebius(n::Integer)
+    @assert n > 0
+    m(p, e) = p == 0 ? 0 : e == 1 ? -1 : 0
+    reduce(*, m(p, e) for (p, e) in factor(n) if p ≥ 0; init=1)
+end
+μ(n) = moebius(n)
+
+print("First 199 terms of the Möbius sequence:\n   ")
+for n in 1:199
+    print(lpad(μ(n), 3), n % 20 == 19 ? "\n" : "")
+end

Task/M-bius-function/Kotlin/m-bius-function.kotlin

@@ -0,0 +1,58 @@
+import kotlin.math.sqrt
+
+fun main() {
+    println("First 199 terms of the möbius function are as follows:")
+    print("    ")
+    for (n in 1..199) {
+        print("%2d  ".format(mobiusFunction(n)))
+        if ((n + 1) % 20 == 0) {
+            println()
+        }
+    }
+}
+
+private const val MU_MAX = 1000000
+private var MU: IntArray? = null
+
+//  Compute mobius function via sieve
+private fun mobiusFunction(n: Int): Int {
+    if (MU != null) {
+        return MU!![n]
+    }
+
+    //  Populate array
+    MU = IntArray(MU_MAX + 1)
+    val sqrt = sqrt(MU_MAX.toDouble()).toInt()
+    for (i in 0 until MU_MAX) {
+        MU!![i] = 1
+    }
+    for (i in 2..sqrt) {
+        if (MU!![i] == 1) {
+            //  for each factor found, swap + and -
+            for (j in i..MU_MAX step i) {
+                MU!![j] *= -i
+            }
+            //  square factor = 0
+            for (j in i * i..MU_MAX step i * i) {
+                MU!![j] = 0
+            }
+        }
+    }
+    for (i in 2..MU_MAX) {
+        when {
+            MU!![i] == i -> {
+                MU!![i] = 1
+            }
+            MU!![i] == -i -> {
+                MU!![i] = -1
+            }
+            MU!![i] < 0 -> {
+                MU!![i] = 1
+            }
+            MU!![i] > 0 -> {
+                MU!![i] = -1
+            }
+        }
+    }
+    return MU!![n]
+}

Task/M-bius-function/Lua/m-bius-function.lua

@@ -0,0 +1,45 @@
+function buildArray(size, value)
+    local tbl = {}
+    for i=1, size do
+        table.insert(tbl, value)
+    end
+    return tbl
+end
+
+MU_MAX = 1000000
+sqroot = math.sqrt(MU_MAX)
+mu = buildArray(MU_MAX, 1)
+
+for i=2, sqroot do
+    if mu[i] == 1 then
+        -- for each factor found, swap + and -
+        for j=i, MU_MAX, i do
+            mu[j] = mu[j] * -i
+        end
+        -- square factor = 0
+        for j=i*i, MU_MAX, i*i do
+            mu[j] = 0
+        end
+    end
+end
+
+for i=2, MU_MAX do
+    if mu[i] == i then
+        mu[i] = 1
+    elseif mu[i] == -i then
+        mu[i] = -1
+    elseif mu[i] < 0 then
+        mu[i] = 1
+    elseif mu[i] > 0 then
+        mu[i] = -1
+    end
+end
+
+print("First 199 terms of the mobius function are as follows:")
+io.write("    ")
+for i=1, 199 do
+    io.write(string.format("%2d  ", mu[i]))
+    if (i + 1) % 20 == 0 then
+        print()
+    end
+end

Task/M-bius-function/Mathematica/m-bius-function.math

@@ -0,0 +1 @@
+Grid[Partition[MoebiusMu[Range[99]], UpTo[10]]]

Task/M-bius-function/Minimal-BASIC/m-bius-function.basic

@@ -0,0 +1,24 @@
+10 REM Moebius function
+20 FOR T = 0 TO 9
+30 FOR U = 1 TO 10
+40 LET N = 10*T+U
+50 GOSUB 110
+60 PRINT M;" ";
+70 NEXT U
+80 PRINT
+90 NEXT T
+100 END
+
+110 LET M = 1
+120 IF N = 1 THEN 230
+130 LET F = 2
+140 LET F2 = F*F
+150 IF INT(N/F2)*F2 <> N THEN 180
+160 LET M = 0
+170 GOTO 230
+180 IF INT(N/F)*F <> N THEN 210
+190 LET M = -M
+200 LET N = N/F
+210 LET F = F+1
+220 IF F <= N THEN 140
+230 RETURN

Task/M-bius-function/Nim/m-bius-function.nim

@@ -0,0 +1,53 @@
+import std/[math, sequtils, strformat]
+
+func getStep(n: int): int {.inline.} =
+  result = 1 + n shl 2 - n shr 1 shl 1
+
+func primeFac(n: int): seq[int] =
+  var
+    maxq = int(sqrt(float(n)))
+    d = 1
+    q: int = 2 + (n and 1)   # Start with 2 or 3 according to oddity.
+
+  while q <= maxq and n %% q != 0:
+    q = getStep(d)
+    inc d
+  if q <= maxq:
+    let q1 = primeFac(n /% q)
+    let q2 = primeFac(q)
+    result = concat(q2, q1, result)
+  else:
+    result.add(n)
+
+func squareFree(num: int): bool =
+  let fact = primeFac num
+
+  for i in fact:
+    if fact.count(i) > 1:
+      return false
+
+  return true
+
+func mobius(num: int): int =
+  if num == 1: return num
+
+  let fact = primeFac num
+
+  for i in fact:
+    ## check if it has a squared prime factor
+    if fact.count(i) == 2:
+      return 0
+
+  if num.squareFree:
+    if fact.len mod 2 == 0:
+      return 1
+    else:
+      return -1
+
+when isMainModule:
+  echo "The first 199 möbius numbers are:"
+
+  for i in 1..199:
+    stdout.write fmt"{mobius(i):4}"
+    if i mod 20 == 0:
+      echo "" # print newline

Task/M-bius-function/Perl/m-bius-function.pl

@@ -0,0 +1,24 @@
+use utf8;
+use strict;
+use warnings;
+use feature 'say';
+use List::Util 'uniq';
+
+sub prime_factors {
+    my ($n, $d, @factors) = (shift, 1);
+    while ($n > 1 and $d++) {
+        $n /= $d, push @factors, $d until $n % $d;
+    }
+    @factors
+}
+
+sub μ {
+    my @p = prime_factors(shift);
+    @p == uniq(@p) ? 0 == @p%2 ? 1 : -1 : 0;
+}
+
+my @möebius;
+push @möebius, μ($_) for 1 .. (my $upto = 199);
+
+say "Möbius sequence - First $upto terms:\n" .
+    (' 'x4 . sprintf "@{['%4d' x $upto]}", @möebius) =~ s/((.){80})/$1\n/gr;

Task/M-bius-function/Phix/m-bius-function.phix

@@ -0,0 +1,15 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">Moebius</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;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">f</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;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">0</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>
+     <span style="color: #008080;">return</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">odd</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">))?-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">:+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"  ."</span><span style="color: #0000FF;">}</span>
+ <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;">199</span> <span style="color: #008080;">do</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</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;">Moebius</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</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: #000000;">s</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/M-bius-function/Python/m-bius-function-1.py

@@ -0,0 +1,68 @@
+# Python Program to evaluate
+# Mobius def M(N) = 1 if N = 1
+# M(N) = 0 if any prime factor
+# of N is contained twice
+# M(N) = (-1)^(no of distinct
+# prime factors)
+# Python Program to
+# evaluate Mobius def
+# M(N) = 1 if N = 1
+# M(N) = 0 if any
+# prime factor of
+# N is contained twice
+# M(N) = (-1)^(no of
+# distinct prime factors)
+
+# def to check if
+# n is prime or not
+def isPrime(n) :
+
+    if (n < 2) :
+        return False
+    for i in range(2, n + 1) :
+        if (i * i <= n and n % i == 0) :
+            return False
+    return True
+
+def mobius(N) :
+
+    # Base Case
+    if (N == 1) :
+        return 1
+
+    # For a prime factor i
+    # check if i^2 is also
+    # a factor.
+    p = 0
+    for i in range(1, N + 1) :
+        if (N % i == 0 and
+                isPrime(i)) :
+
+            # Check if N is
+            # divisible by i^2
+            if (N % (i * i) == 0) :
+                return 0
+            else :
+
+                # i occurs only once,
+                # increase f
+                p = p + 1
+
+    # All prime factors are
+    # contained only once
+    # Return 1 if p is even
+    # else -1
+    if(p % 2 != 0) :
+        return -1
+    else :
+        return 1
+
+# Driver Code
+print("Mobius numbers from 1..99:")
+
+for i in range(1, 100):
+  print(f"{mobius(i):>4}", end = '')
+
+  if i % 20 == 0: print()
+# This code is contributed by
+# Manish Shaw(manishshaw1)

Task/M-bius-function/Python/m-bius-function-2.py

@@ -0,0 +1,64 @@
+# Python Program to evaluate
+# Mobius def M(N) = 1 if N = 1
+# M(N) = 0 if any prime factor
+# of N is contained twice
+# M(N) = (-1)^(no of distinct
+# prime factors)
+import math
+
+# def to check if n
+# is prime or not
+def isPrime(n) :
+
+    if (n < 2) :
+        return False
+    for i in range(2, n + 1) :
+        if (n % i == 0) :
+            return False
+        i = i * i
+    return True
+
+def mobius(n) :
+
+    p = 0
+
+    # Handling 2 separately
+    if (n % 2 == 0) :
+
+        n = int(n / 2)
+        p = p + 1
+
+        # If 2^2 also
+        # divides N
+        if (n % 2 == 0) :
+            return 0
+
+
+    # Check for all
+    # other prime factors
+    for i in range(3, int(math.sqrt(n)) + 1) :
+
+        # If i divides n
+        if (n % i == 0) :
+
+            n = int(n / i)
+            p = p + 1
+
+            # If i^2 also
+            # divides N
+            if (n % i == 0) :
+                return 0
+        i = i + 2
+
+    if(p % 2 == 0) :
+        return -1
+    else :
+        return 1
+
+# Driver Code
+print("Mobius numbers from 1..99:")
+
+for i in range(1, 100):
+  print(f"{mobius(i):>4}", end = '')
+# This code is contributed by
+# Manish Shaw(manishshaw1)

Task/M-bius-function/Quackery/m-bius-function.quackery

@@ -0,0 +1,27 @@
+  [ false swap
+    behead swap
+      [ witheach
+          [ tuck != if
+              done
+            dip not
+            conclude ] ]
+    drop ]               is square ( [ --> b )
+
+  [ 1 & ]                is odd    ( n --> b )
+
+  [ dup 1 = if done
+    primefactors
+    dup square iff
+      [ drop 0 ] done
+    size odd iff
+      -1 else 1 ]        is mobius ( n --> n )
+
+  say "First 199 terms:" cr
+  say "    "
+  199 times
+    [ i^ 1+ mobius
+      dup -1 > if sp
+      echo
+      i^ 1+ 20 mod
+      19 = iff cr
+      else [ sp sp ] ]

Task/M-bius-function/REXX/m-bius-function.rexx

@@ -0,0 +1,46 @@
+/*REXX pgm computes & shows a value grid of the Möbius function for a range of integers.*/
+parse arg LO HI grp .                            /*obtain optional arguments from the CL*/
+if  LO=='' |  LO==","  then  LO=   0             /*Not specified?  Then use the default.*/
+if  HI=='' |  HI==","  then  HI= 199             /* "      "         "   "   "     "    */
+if grp=='' | grp==","  then grp=  20             /* "      "         "   "   "     "    */
+                                                 /*                            ______   */
+call genP HI                                     /*generate primes up to the  √  HI     */
+say center(' The Möbius sequence from ' LO " ──► " HI" ", max(50, grp*3), '═')   /*title*/
+$=                                               /*variable holds output grid of GRP #s.*/
+    do j=LO  to  HI;  $= $  right( mobius(j), 2) /*process some numbers from  LO ──► HI.*/
+    if words($)==grp  then do;  say substr($, 2);  $=    /*show grid if fully populated,*/
+                           end                           /*  and nullify it for more #s.*/
+    end   /*j*/                                  /*for small grids, using wordCnt is OK.*/
+
+if $\==''  then say substr($, 2)                 /*handle any residual numbers not shown*/
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+mobius: procedure expose @.;  parse arg x        /*obtain a integer to be tested for mu.*/
+        if x<1  then return '∙'                  /*special? Then return symbol for null.*/
+        #= 0                                     /*start with a value of zero.          */
+             do k=1;  p= @.k                     /*get the  Kth  (pre─generated)  prime.*/
+             if p>x  then leave                  /*prime (P)   > X?    Then we're done. */
+             if p*p>x  then do;   #= #+1;  leave /*prime (P**2 > X?    Bump # and leave.*/
+                            end
+             if x//p==0  then do; #= #+1         /*X divisible by P?   Bump mu number.  */
+                                  x= x % p       /*                    Divide by prime. */
+                                  if x//p==0  then return 0  /*X÷by P?  Then return zero*/
+                              end
+             end   /*k*/                         /*#  (below) is almost always small, <9*/
+        if #//2==0  then return  1               /*Is # even?   Then return postive  1  */
+                         return -1               /* " "  odd?     "     "   negative 1. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+genP: @.1=2; @.2=3; @.3=5; @.4=7; @.5=11; @.6= 13;  nP=6  /*assign low primes; # primes.*/
+                    do lim=nP  until lim*lim>=HI /*only keep primes up to the  sqrt(HI).*/
+                    end   /*lim*/
+       do j=@.nP+4  by 2  to HI                  /*only find odd primes from here on.   */
+       parse var j '' -1 _;if _==5  then iterate /*Is last digit a "5"?   Then not prime*/
+       if j// 3==0  then iterate                 /*is J divisible by  3?    "   "    "  */
+       if j// 7==0  then iterate                 /* " "     "      "  7?    "   "    "  */
+       if j//11==0  then iterate                 /* " "     "      " 11?    "   "    "  */
+       if j//13==0  then iterate                 /* " "     "      " 13?    "   "    "  */
+                 do k=7  while k*k<=j            /*divide by some generated odd primes. */
+                 if j // @.k==0  then iterate j  /*Is J divisible by  P?  Then not prime*/
+                 end   /*k*/                     /* [↓]  a prime  (J)  has been found.  */
+       nP= nP+1;    if nP<=HI  then @.nP= j      /*bump prime count; assign prime to  @.*/
+       end      /*j*/;              return

Task/M-bius-function/Raku/m-bius-function.raku

@@ -0,0 +1,13 @@
+use Prime::Factor;
+
+sub μ (Int \n) {
+    return 0 if n %% (4|9|25|49|121);
+    my @p = prime-factors(n);
+    +@p == +@p.unique ?? +@p %% 2 ?? 1 !! -1 !! 0
+}
+
+my @möbius = lazy flat '', 1, (2..*).hyper.map: &μ;
+
+# The Task
+put "Möbius sequence - First 199 terms:\n",
+    @möbius[^200]».fmt('%3s').batch(20).join: "\n";

Task/M-bius-function/Ring/m-bius-function.ring

@@ -0,0 +1,30 @@
+mobStr = "      . "
+
+for i = 1 to 200
+    if mobius(i) >= 0
+       mobStr + = " "
+    ok
+    temp = string(mobius(i))
+    if left(temp,2) = "-0"
+       temp = right(temp,len(temp)-1)
+    ok
+    mobStr += temp + " "
+    if i % 10 = 9
+        see mobStr + nl
+        mobStr = "     "
+    ok
+next
+
+func mobius(n)
+     if n = 1
+        return 1
+     ok
+     for d = 2 to ceil(sqrt(n))
+         if n % d = 0
+            if n % (d*d) = 0
+               return 0
+            ok
+            return -mobius(n/d)
+         ok
+     next
+     return -1

Task/M-bius-function/Ruby/m-bius-function.rb

@@ -0,0 +1,9 @@
+require 'prime'
+
+def μ(n)
+  pd = n.prime_division
+  return 0 unless pd.map(&:last).all?(1)
+  pd.size.even? ? 1 : -1
+end
+
+(["  "] + (1..199).map{|n|"%2s" % μ(n)}).each_slice(20){|line| puts line.join(" ") }

Task/M-bius-function/Sidef/m-bius-function-1.sidef

@@ -0,0 +1,3 @@
+say moebius(53)    #=> -1
+say moebius(54)    #=> 0
+say moebius(55)    #=> 1

Task/M-bius-function/Sidef/m-bius-function-2.sidef

@@ -0,0 +1,11 @@
+func μ(n) {
+    var f = n.factor_exp.map { .tail }
+    f.any { _ > 1 } ? 0 : ((-1)**f.sum)
+}
+
+with (199) { |n|
+    say "Values of the Möbius function for numbers in the range 1..#{n}:"
+    [' '] + (1..n->map(μ)) -> each_slice(20, {|*line|
+        say line.map { '%2s' % _ }.join(' ')
+    })
+}

Task/M-bius-function/Tiny-BASIC/m-bius-function.basic

@@ -0,0 +1,20 @@
+    PRINT "Enter an integer"
+    INPUT N
+    IF N < 0 THEN LET N = -N
+    IF N < 2 THEN GOTO 100 + N
+    LET C = 1
+    LET F = 2
+ 10 IF ((N/F)/F)*F*F = N THEN GOTO 100
+    IF (N/F)*F = N THEN GOTO 30
+ 20 LET F = F + 1
+    IF F<=N THEN GOTO 10
+    GOTO 100 + C
+ 30 LET N = N / F
+    LET C = -C
+    GOTO 20
+ 99 PRINT "-1"
+    END
+100 PRINT "0"
+    END
+101 PRINT "1"
+    END

Task/M-bius-function/Wren/m-bius-function.wren

@@ -0,0 +1,33 @@
+import "/fmt" for Fmt
+import "/math" for Int
+
+var isSquareFree = Fn.new { |n|
+    var i = 2
+    while (i * i <= n) {
+        if (n%(i*i) == 0) return false
+        i = (i > 2) ? i + 2 : i + 1
+    }
+    return true
+}
+
+var mu = Fn.new { |n|
+    if (n < 1) Fiber.abort("Argument must be a positive integer")
+    if (n == 1) return 1
+    var sqFree = isSquareFree.call(n)
+    var factors = Int.primeFactors(n)
+    if (sqFree && factors.count % 2 == 0) return 1
+    if (sqFree) return -1
+    return 0
+}
+
+System.print("The first 199 Möbius numbers are:")
+for (i in 0..9) {
+    for (j in 0..19) {
+        if (i == 0 && j == 0) {
+            System.write("    ")
+        } else {
+            System.write("%(Fmt.dm(3, mu.call(i*20 + j))) ")
+        }
+    }
+    System.print()
+}

Task/M-bius-function/XPL0/m-bius-function.xpl0

@@ -0,0 +1,23 @@
+func Mobius(N);
+int  N, Cnt, F, K;
+[Cnt:= 0;
+F:= 2;  K:= 0;
+repeat  if rem(N/F) = 0 then
+                [Cnt:= Cnt+1;
+                N:= N/F;
+                K:= K+1;
+                if K >= 2 then return 0;
+                ]
+        else    [F:= F+1;  K:= 0];
+until   F > N;
+return if Cnt&1 then -1 else 1;
+];
+
+int  N;
+[Format(3, 0);
+Text(0, "   ");
+for N:= 1 to 199 do
+        [RlOut(0, float(Mobius(N)));
+        if rem(N/20) = 19 then CrLf(0);
+        ];
+]

Task/M-bius-function/Yabasic/m-bius-function.basic

@@ -0,0 +1,21 @@
+outstr$ = " .  "
+for i = 1 to 200
+    if mobius(i) >= 0 then outstr$ = outstr$ + " " : fi
+    outstr$ = outstr$ + str$(mobius(i)) + "  "
+    if mod(i, 10) = 9 then
+        print outstr$
+        outstr$ = ""
+    end if
+next i
+end
+
+sub mobius(n)
+    if n = 1 then return 1 : fi
+    for d = 2 to int(sqr(n))
+        if mod(n, d) = 0 then
+            if mod(n, (d*d)) = 0 then return 0 : fi
+            return -mobius(n/d)
+        end if
+    next d
+    return -1
+end sub

Task/M-bius-function/Zkl/m-bius-function-1.zkl

@@ -0,0 +1,19 @@
+fcn mobius(n){
+   pf:=primeFactors(n);
+   sq:=pf.filter1('wrap(f){ (n % (f*f))==0 });  // False if square free
+   if(sq==False){ if(pf.len().isEven) 1 else -1 }
+   else 0
+}
+fcn primeFactors(n){  // Return a list of prime factors of n
+   acc:=fcn(n,k,acc,maxD){  // k is 2,3,5,7,9,... not optimum
+      if(n==1 or k>maxD) acc.close();
+      else{
+	 q,r:=n.divr(k);   // divr-->(quotient,remainder)
+	 if(r==0) return(self.fcn(q,k,acc.write(k),q.toFloat().sqrt()));
+	 return(self.fcn(n,k+1+k.isOdd,acc,maxD))  # both are tail recursion
+      }
+   }(n,2,Sink(List),n.toFloat().sqrt());
+   m:=acc.reduce('*,1);      // mulitply factors
+   if(n!=m) acc.append(n/m); // opps, missed last factor
+   else acc;
+}

Task/M-bius-function/Zkl/m-bius-function-2.zkl

@@ -0,0 +1,3 @@
+[1..199].apply(mobius)
+.pump(Console.println, T(Void.Read,19,False),
+	fcn{ vm.arglist.pump(String,"%3d".fmt) });