Initial data commit

Task/Duffinian-numbers/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Duffinian_numbers

Task/Duffinian-numbers/00-TASK.txt

@@ -0,0 +1,35 @@
+A '''Duffinian number''' is a composite number '''k''' that is relatively prime to its sigma sum '''σ'''.
+
+''The sigma sum of '''k''' is the sum of the divisors of '''k'''.''
+
+
+;E.G.
+
+'''161''' is a '''Duffinian number'''. 
+* It is composite. (7 × 23)
+* The sigma sum '''192''' (1 + 7 + 23 + 161) is relatively prime to '''161'''. 
+
+
+Duffinian numbers are very common.
+
+It is not uncommon for two consecutive integers to be Duffinian (a Duffinian twin) (8, 9), (35, 36), (49, 50), etc.
+
+Less common are Duffinian triplets; three consecutive Duffinian numbers. (63, 64, 65), (323, 324, 325), etc.
+
+Much, much less common are Duffinian quadruplets and quintuplets. The first Duffinian quintuplet is (202605639573839041, 202605639573839042, 202605639573839043, 202605639573839044, 202605639573839045).
+
+It is not possible to have six consecutive Duffinian numbers
+
+
+;Task
+* Find and show the first 50 Duffinian numbers.
+* Find and show at least the first 15 Duffinian triplets.
+
+
+;See also
+;* [https://www.numbersaplenty.com/set/Duffinian_number Numbers Aplenty - Duffinian numbers]
+;* [[oeis:A003624|OEIS:A003624 - Duffinian numbers: composite numbers k relatively prime to sigma(k)]]
+
+
+
+

Task/Duffinian-numbers/ALGOL-68/duffinian-numbers.alg

@@ -0,0 +1,50 @@
+BEGIN # find Duffinian numbers: non-primes relatively prime to their divisor count #
+    INT max number            := 500 000;      # largest number we will consider   #
+    # iterative Greatest Common Divisor routine, returns the gcd of m and n        #
+    PROC gcd = ( INT m, n )INT:
+         BEGIN
+            INT a := ABS m, b := ABS n;
+            WHILE b /= 0 DO
+                INT new a = b;
+                b        := a MOD b;
+                a        := new a
+            OD;
+            a
+         END # gcd # ;
+    # construct a table of the divisor counts                                      #
+    [ 1 : max number ]INT ds; FOR i TO UPB ds DO ds[ i ] := 1 OD;
+    FOR i FROM 2 TO UPB ds
+        DO FOR j FROM i BY i TO UPB ds DO ds[ j ] +:= i OD
+    OD;
+    # set the divisor counts of non-Duffinian numbers to 0                         #
+    ds[ 1 ] := 0;  # 1 is not Duffinian                                            #
+    FOR n FROM 2 TO UPB ds DO
+        IF INT nds = ds[ n ];
+           IF nds = n + 1 THEN TRUE ELSE gcd( n, nds ) /= 1 FI
+        THEN
+            # n is prime or is not relatively prime to its divisor sum             #
+            ds[ n ] := 0
+        FI
+    OD;
+    # show the first 50 Duffinian numbers                                          #
+    print( ( "The first 50 Duffinian numbers:", newline ) );
+    INT dcount := 0;
+    FOR n WHILE dcount < 50 DO
+        IF ds[ n ] /= 0
+        THEN # found a Duffinian number                                            #
+            print( ( " ", whole( n, -3) ) );
+            IF ( dcount +:= 1 ) MOD 25 = 0 THEN print( ( newline ) ) FI
+        FI
+    OD;
+    print( ( newline ) );
+    # show the duffinian triplets below UPB ds                                     #
+    print( ( "The Duffinian triplets up to ", whole( UPB ds, 0 ), ":", newline ) );
+    dcount := 0;
+    FOR n FROM 3 TO UPB ds DO
+        IF ds[ n - 2 ] /= 0 AND ds[ n - 1 ] /= 0 AND ds[ n ] /= 0
+        THEN # found a Duffinian triplet                                           #
+            print( ( " (", whole( n - 2, -7 ), " ", whole( n - 1, -7 ), " ", whole( n, -7 ), ")" ) );
+            IF ( dcount +:= 1 ) MOD 4 = 0 THEN print( ( newline ) ) FI
+        FI
+    OD
+END

Task/Duffinian-numbers/AppleScript/duffinian-numbers-1.applescript

@@ -0,0 +1,100 @@
+on aliquotSum(n)
+    if (n < 2) then return 0
+    set sum to 1
+    set sqrt to n ^ 0.5
+    set limit to sqrt div 1
+    if (limit = sqrt) then
+        set sum to sum + limit
+        set limit to limit - 1
+    end if
+    repeat with i from 2 to limit
+        if (n mod i is 0) then set sum to sum + i + n div i
+    end repeat
+
+    return sum
+end aliquotSum
+
+on hcf(a, b)
+    repeat until (b = 0)
+        set x to a
+        set a to b
+        set b to x mod b
+    end repeat
+
+    if (a < 0) then return -a
+    return a
+end hcf
+
+on isDuffinian(n)
+    set aliquot to aliquotSum(n) -- = sigma sum - n. = 1 if n's prime.
+    return ((aliquot > 1) and (hcf(n, aliquot + n) = 1))
+end isDuffinian
+
+-- Task code:
+on matrixToText(matrix, w)
+    script o
+        property matrix : missing value
+        property row : missing value
+    end script
+
+    set o's matrix to matrix
+    set padding to "          "
+    repeat with r from 1 to (count o's matrix)
+        set o's row to o's matrix's item r
+        repeat with i from 1 to (count o's row)
+            set o's row's item i to text -w thru end of (padding & o's row's item i)
+        end repeat
+        set o's matrix's item r to join(o's row, "")
+    end repeat
+
+    return join(o's matrix, linefeed)
+end matrixToText
+
+on join(lst, delim)
+    set astid to AppleScript's text item delimiters
+    set AppleScript's text item delimiters to delim
+    set txt to lst as text
+    set AppleScript's text item delimiters to astid
+    return txt
+end join
+
+on task(duffTarget, tupTarget, tupSize)
+    if ((duffTarget < 1) or (tupTarget < 1) or (tupSize < 2)) then error "Duff parameter(s)."
+    script o
+        property duffinians : {}
+        property tuplets : {}
+    end script
+
+    -- Populate o's duffinians and tuplets lists.
+    set n to 1
+    set tuplet to {}
+    repeat while (((count o's tuplets) < tupTarget) or ((count o's duffinians) < duffTarget))
+        if (isDuffinian(n)) then
+            if ((count o's duffinians) < duffTarget) then set end of o's duffinians to n
+            if (tuplet ends with n - 1) then
+                set end of tuplet to n
+            else
+                if ((count tuplet) = tupSize) then set end of o's tuplets to tuplet
+                set tuplet to {n}
+            end if
+        end if
+        set n to n + 1
+    end repeat
+
+    -- Format for output.
+    set duffinians to {}
+    repeat with i from 1 to duffTarget by 20
+        set j to i + 19
+        if (j > duffTarget) then set j to duffTarget
+        set end of duffinians to items i thru j of o's duffinians
+    end repeat
+    set part1 to "First " & duffTarget & " Duffinian numbers:" & linefeed & ¬
+        matrixToText(duffinians, (count (end of o's duffinians as text)) + 2)
+    set tupletTypes to {missing value, "twins", "triplets:", "quadruplets:", "quintuplets:"}
+    set part2 to "First " & tupTarget & " Duffinian " & item tupSize of tupletTypes & linefeed & ¬
+        matrixToText(o's tuplets, (count (end of end of o's tuplets as text)) + 2)
+
+    return part1 & (linefeed & linefeed & part2)
+end task
+
+return task(50, 20, 3) -- First 50 Duffinians, first 20 3-item tuplets.

Task/Duffinian-numbers/AppleScript/duffinian-numbers-2.applescript

@@ -0,0 +1,26 @@
+"First 50 Duffinian numbers:
+    4    8    9   16   21   25   27   32   35   36   39   49   50   55   57   63   64   65   75   77
+   81   85   93   98  100  111  115  119  121  125  128  129  133  143  144  155  161  169  171  175
+  183  185  187  189  201  203  205  209  215  217
+
+First 20 Duffinian triplets:
+     63     64     65
+    323    324    325
+    511    512    513
+    721    722    723
+    899    900    901
+   1443   1444   1445
+   2303   2304   2305
+   2449   2450   2451
+   3599   3600   3601
+   3871   3872   3873
+   5183   5184   5185
+   5617   5618   5619
+   6049   6050   6051
+   6399   6400   6401
+   8449   8450   8451
+  10081  10082  10083
+  10403  10404  10405
+  11663  11664  11665
+  12481  12482  12483
+  13447  13448  13449"

Task/Duffinian-numbers/Arturo/duffinian-numbers.arturo

@@ -0,0 +1,34 @@
+duffinian?: function [n]->
+    and? [not? prime? n]
+         [
+             fn: factors n
+             [1] = intersection factors sum fn fn
+         ]
+
+first50: new []
+i: 0
+while [50 > size first50][
+    if duffinian? i -> 'first50 ++ i
+    i: i + 1
+]
+
+print "The first 50 Duffinian numbers:"
+loop split.every: 10 first50 'row [
+    print map to [:string] row 'item -> pad item 3
+]
+
+first15: new []
+i: 0
+while [15 > size first15][
+    if every? i..i+2 => duffinian? [
+        'first15 ++ @[@[i, i+1, i+2]]
+        i: i+2
+    ]
+    i: i + 1
+]
+
+print ""
+print "The first 15 Duffinian triplets:"
+loop split.every: 5 first15 'row [
+    print map row 'item -> pad.right as.code item 17
+]

Task/Duffinian-numbers/C++/duffinian-numbers.cpp

@@ -0,0 +1,45 @@
+#include <iomanip>
+#include <iostream>
+#include <numeric>
+#include <sstream>
+
+bool duffinian(int n) {
+    if (n == 2)
+        return false;
+    int total = 1, power = 2, m = n;
+    for (; (n & 1) == 0; power <<= 1, n >>= 1)
+        total += power;
+    for (int p = 3; p * p <= n; p += 2) {
+        int sum = 1;
+        for (power = p; n % p == 0; power *= p, n /= p)
+            sum += power;
+        total *= sum;
+    }
+    if (m == n)
+        return false;
+    if (n > 1)
+        total *= n + 1;
+    return std::gcd(total, m) == 1;
+}
+
+int main() {
+    std::cout << "First 50 Duffinian numbers:\n";
+    for (int n = 1, count = 0; count < 50; ++n) {
+        if (duffinian(n))
+            std::cout << std::setw(3) << n << (++count % 10 == 0 ? '\n' : ' ');
+    }
+    std::cout << "\nFirst 50 Duffinian triplets:\n";
+    for (int n = 1, m = 0, count = 0; count < 50; ++n) {
+        if (duffinian(n))
+            ++m;
+        else
+            m = 0;
+        if (m == 3) {
+            std::ostringstream os;
+            os << '(' << n - 2 << ", " << n - 1 << ", " << n << ')';
+            std::cout << std::left << std::setw(24) << os.str()
+                      << (++count % 3 == 0 ? '\n' : ' ');
+        }
+    }
+    std::cout << '\n';
+}

Task/Duffinian-numbers/Delphi/duffinian-numbers.delphi

@@ -0,0 +1,86 @@
+{These subroutines would normally be in a library, but is included here for clarity}
+
+function GetAllProperDivisors(N: Integer;var IA: TIntegerDynArray): integer;
+{Make a list of all the "proper dividers" for N}
+{Proper dividers are the of numbers the divide evenly into N}
+var I: integer;
+begin
+SetLength(IA,0);
+for I:=1 to N-1 do
+ if (N mod I)=0 then
+	begin
+	SetLength(IA,Length(IA)+1);
+	IA[High(IA)]:=I;
+	end;
+Result:=Length(IA);
+end;
+
+
+function GetAllDivisors(N: Integer;var IA: TIntegerDynArray): integer;
+{Make a list of all the "proper dividers" for N, Plus N itself}
+begin
+Result:=GetAllProperDivisors(N,IA)+1;
+SetLength(IA,Length(IA)+1);
+IA[High(IA)]:=N;
+end;
+
+
+
+function IsDuffinianNumber(N: integer): boolean;
+{Test number to see if it a Duffinian number}
+var Facts1,Facts2: TIntegerDynArray;
+var Sum,I,J: integer;
+begin
+Result:=False;
+{Must be a composite number}
+if IsPrime(N) then exit;
+{Get all divisors}
+GetAllDivisors(N,Facts1);
+{Get sum of factors}
+Sum:=0;
+for I:=0 to High(Facts1) do
+ Sum:=Sum+Facts1[I];
+{Get all factor of Sum}
+GetAllDivisors(Sum,Facts2);
+{Test if the two number share any factors}
+for I:=1 to High(Facts1) do
+ for J:=1 to High(Facts2) do
+	if Facts1[I]=Facts2[J] then exit;
+{If not, they are relatively prime}
+Result:=True;
+end;
+
+procedure ShowDuffinianNumbers(Memo: TMemo);
+var N,Cnt,D1,D2,D3: integer;
+var S: string;
+begin
+Cnt:=0;
+S:='';
+Memo.Lines.Add('First 50 Duffinian Numbers');
+for N:=2 to high(integer) do
+ if IsDuffinianNumber(N) then
+	begin
+	Inc(Cnt);
+	S:=S+Format('%5d',[N]);
+	if (Cnt mod 10)=0 then S:=S+CRLF;
+	if Cnt>=50 then break;
+	end;
+Memo.Lines.Add(S);
+D1:=0; D2:=-10; D3:=0;
+S:=''; Cnt:=0;
+Memo.Lines.Add('First 15 Duffinian Triples');
+for N:=2 to high(integer) do
+ if IsDuffinianNumber(N) then
+	begin
+	D1:=D2; D2:=D3;
+	D3:=N;
+	if ((D2-D1)=1) and ((D3-D2)=1) then
+		begin
+		Inc(Cnt);
+		S:=S+Format('(%5d%5d%5d) ',[D1,D2,D3]);
+		if (Cnt mod 3)=0 then S:=S+CRLF;
+		if Cnt>=15 then break;
+		end;
+	end;
+Memo.Lines.Add(S);
+end;

Task/Duffinian-numbers/Factor/duffinian-numbers.factor

@@ -0,0 +1,18 @@
+USING: combinators.short-circuit.smart grouping io kernel lists
+lists.lazy math math.primes math.primes.factors math.statistics
+prettyprint sequences sequences.deep ;
+
+: duffinian? ( n -- ? )
+    { [ prime? not ] [ dup divisors sum simple-gcd 1 = ] } && ;
+
+: duffinians ( -- list ) 3 lfrom [ duffinian? ] lfilter ;
+
+: triples ( -- list )
+    duffinians dup cdr dup cdr lzip lzip [ flatten ] lmap-lazy
+    [ differences { 1 1 } = ] lfilter ;
+
+"First 50 Duffinian numbers:" print
+50 duffinians ltake list>array 10 group simple-table. nl
+
+"First 15 Duffinian triplets:" print
+15 triples ltake list>array simple-table.

Task/Duffinian-numbers/FreeBASIC/duffinian-numbers.basic

@@ -0,0 +1,47 @@
+#include "isprime.bas"
+
+Function GCD(p As Integer, q As Integer) As Integer
+    Return Iif(q = 0, p, GCD(q, p Mod q))
+End Function
+
+Function SumDiv(Num As Uinteger) As Uinteger
+    Dim As Uinteger Div = 2, Sum = 0, Quot
+    Do
+        Quot = Num / Div
+        If Div > Quot Then Exit Do
+        If Num Mod Div = 0 Then
+            Sum += Div
+            If Div <> Quot Then Sum += Quot
+        End If
+        Div += 1
+    Loop
+    Return Sum+1
+End Function
+
+Function Duff(N As Uinteger) As Boolean
+    Return Iif(isPrime(N), False, GCD(SumDiv(N), N) = 1)
+End Function
+
+Dim As Integer C = 0, N = 4
+Print "First 50 Duffinian numbers:"
+Do
+    If Duff(N) Then
+        Print Using "####"; N;
+        C += 1
+        If C Mod 20 = 0 Then Print
+    End If
+    N += 1
+Loop Until C >= 50
+
+C = 0 : N = 4
+Print !"\n\nFirst 50 Duffinian triplets:"
+Do
+    If Duff(N) And Duff(N+1) And Duff(N+2) Then
+        Print Using !" [###### ###### ######]\t"; N; N+1; N+2;
+        C += 1
+        If C Mod 4 = 0 Then Print
+    End If
+    N += 1
+Loop Until C >= 50
+
+Sleep

Task/Duffinian-numbers/Go/duffinian-numbers.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+    "fmt"
+    "math"
+    "rcu"
+)
+
+func isSquare(n int) bool {
+    s := int(math.Sqrt(float64(n)))
+    return s*s == n
+}
+
+func main() {
+    limit := 200000 // say
+    d := rcu.PrimeSieve(limit-1, true)
+    d[1] = false
+    for i := 2; i < limit; i++ {
+        if !d[i] {
+            continue
+        }
+        if i%2 == 0 && !isSquare(i) && !isSquare(i/2) {
+            d[i] = false
+            continue
+        }
+        sigmaSum := rcu.SumInts(rcu.Divisors(i))
+        if rcu.Gcd(sigmaSum, i) != 1 {
+            d[i] = false
+        }
+    }
+
+    var duff []int
+    for i := 1; i < len(d); i++ {
+        if d[i] {
+            duff = append(duff, i)
+        }
+    }
+    fmt.Println("First 50 Duffinian numbers:")
+    rcu.PrintTable(duff[0:50], 10, 3, false)
+
+    var triplets [][3]int
+    for i := 2; i < limit; i++ {
+        if d[i] && d[i-1] && d[i-2] {
+            triplets = append(triplets, [3]int{i - 2, i - 1, i})
+        }
+    }
+    fmt.Println("\nFirst 56 Duffinian triplets:")
+    for i := 0; i < 14; i++ {
+        s := fmt.Sprintf("%6v", triplets[i*4:i*4+4])
+        fmt.Println(s[1 : len(s)-1])
+    }
+}

Task/Duffinian-numbers/J/duffinian-numbers-1.j

@@ -0,0 +1,3 @@
+sigmasum=: >:@#.~/.~&.q:
+composite=: 1&< * 0 = 1&p:
+duffinian=: composite * 1 = ] +. sigmasum

Task/Duffinian-numbers/J/duffinian-numbers-2.j

@@ -0,0 +1,22 @@
+   5 10$(#~ duffinian) 1+i.1000
+  4   8   9  16  21  25  27  32  35  36
+ 39  49  50  55  57  63  64  65  75  77
+ 81  85  93  98 100 111 115 119 121 125
+128 129 133 143 144 155 161 169 171 175
+183 185 187 189 201 203 205 209 215 217
+   (i.3)+/~15 {.(#~ 1 1 1 E. duffinian) 1+i.100000
+  63   64   65
+ 323  324  325
+ 511  512  513
+ 721  722  723
+ 899  900  901
+1443 1444 1445
+2303 2304 2305
+2449 2450 2451
+3599 3600 3601
+3871 3872 3873
+5183 5184 5185
+5617 5618 5619
+6049 6050 6051
+6399 6400 6401
+8449 8450 8451

Task/Duffinian-numbers/Jq/duffinian-numbers-1.jq

@@ -0,0 +1,45 @@
+def count(s): reduce s as $x (0; .+1);
+
+def isSquare:
+  (sqrt|floor) as $sqrt
+  | . == ($sqrt | .*.);
+
+# Input:  a positive integer
+# Output: an array, $a, of length .+1 such that
+#         $a[$i] is $i if $i is prime, and false otherwise.
+def primeSieve:
+  # erase(i) sets .[i*j] to false for integral j > 1
+  def erase($i):
+    if .[$i] then
+      reduce (range(2*$i; length; $i)) as $j (.; .[$j] = false)
+    else .
+    end;
+  (. + 1) as $n
+  | (($n|sqrt) / 2) as $s
+  | [null, null, range(2; $n)]
+  | reduce (2, 1 + (2 * range(1; $s))) as $i (.; erase($i));
+
+def gcd(a; b):
+  # subfunction expects [a,b] as input
+  # i.e. a ~ .[0] and b ~ .[1]
+  def rgcd: if .[1] == 0 then .[0]
+         else [.[1], .[0] % .[1]] | rgcd
+         end;
+  [a,b] | rgcd;
+
+# divisors as an unsorted stream (without calling sqrt)
+def divisors:
+  if . == 1 then 1
+  else . as $n
+  | label $out
+  | range(1; $n) as $i
+  | ($i * $i) as $i2
+  | if $i2 > $n then break $out
+    else if $i2 == $n
+         then $i
+         elif ($n % $i) == 0
+         then $i, ($n/$i)
+         else empty
+	 end
+    end
+  end;

Task/Duffinian-numbers/Jq/duffinian-numbers-2.jq

@@ -0,0 +1,42 @@
+# emit an array such that .[i] is i if i is Duffinian and false otherwise
+def duffinianArray($limit):
+   ($limit | primeSieve |  map(not))
+   | .[1] = false
+   | reduce range(2; $limit) as $i (.;
+       if (.[$i]|not) then .
+       else if ($i % 2) == 0 and ($i|isSquare|not) and (($i/2)|isSquare|not)
+            then .[$i] = false
+            else sum($i|divisors) as $sigmaSum
+            | if gcd($sigmaSum; $i) != 1
+	      then .[$i] = false
+	      else .
+	      end
+	    end
+        end  );
+
+# Input: duffinianArray($limit)
+# Output: an array of the corresponding Duffinians
+def duffinians:
+ . as $d
+ | reduce range(1;length) as $i ([]; if $d[$i] then . + [$i] else . end);
+
+# Input: duffinians
+# Output: stream of triplets
+def triplets:
+  . as $d
+  | range (2; length) as $i
+  | select( $d[$i] and $d[$i-1] and $d[$i-2] )
+  | [$i-2, $i-1, $i];
+
+def withCount(s; $msg):
+  foreach (s,null) as $x (0; .+1;
+    if $x == null then "\($msg) \(.-1)" else $x end );
+
+def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
+
+# 167039 is the minimum integer that is sufficient to produce 50 triplets
+duffinianArray(167039)
+| "First 50 Duffinian numbers:",
+  (duffinians[0:50] | _nwise(10) | map(lpad(4)) | join(" ") ),
+  "\nFirst 50 Duffinian triplets:",
+  withCount(limit(50;triplets); "\nNumber of triplets: ")

Task/Duffinian-numbers/Julia/duffinian-numbers.julia

@@ -0,0 +1,28 @@
+using Primes
+
+function σ(n)
+    f = [one(n)]
+    for (p,e) in factor(n)
+        f = reduce(vcat, [f*p^j for j in 1:e], init=f)
+    end
+    return sum(f)
+end
+
+isDuffinian(n) = !isprime(n) && gcd(n, σ(n)) == 1
+
+function testDuffinians()
+    println("First 50 Duffinian numbers:")
+    foreach(p -> print(rpad(p[2], 4), p[1] % 25 == 0 ? "\n" : ""),
+        enumerate(filter(isDuffinian, 2:217)))
+    n, found = 2, 0
+    println("\nFifteen Duffinian triplets:")
+    while found < 15
+        if isDuffinian(n) && isDuffinian(n + 1) && isDuffinian(n + 2)
+            println(lpad(n, 6), lpad(n +1, 6), lpad(n + 2, 6))
+            found += 1
+        end
+        n += 1
+    end
+end
+
+testDuffinians()

Task/Duffinian-numbers/Mathematica/duffinian-numbers.math

@@ -0,0 +1,6 @@
+ClearAll[DuffianQ]
+DuffianQ[n_Integer] := CompositeQ[n] \[And] CoprimeQ[DivisorSigma[1, n], n]
+dns = Select[DuffianQ][Range[1000000]];
+Take[dns, UpTo[50]]
+triplets = ToString[dns[[#]]] <> "\[LongDash]" <> ToString[dns[[# + 2]]] & /@ SequencePosition[Differences[dns], {1, 1}][[All, 1]]
+Multicolumn[triplets, {Automatic, 5}, Appearance -> "Horizontal"]

Task/Duffinian-numbers/Nim/duffinian-numbers.nim

@@ -0,0 +1,41 @@
+import std/[algorithm, math, strformat]
+
+const MaxNumber = 500_000
+
+# Construct a table of the divisor counts.
+var ds: array[1..MaxNumber, int]
+ds.fill 1
+for i in 2..MaxNumber:
+  for j in countup(i, MaxNumber, i):
+    ds[j] += i
+
+# Set the divisor counts of non-Duffinian numbers to 0.
+ds[1] = 0   # 1 is not Duffinian.
+for n in 2..MaxNumber:
+  let nds = ds[n]
+  if nds == n + 1 or gcd(n, nds) != 1:
+    # "n" is prime or is not relatively prime to its divisor sum.
+    ds[n] = 0
+
+# Show the first 50 Duffinian numbers.
+echo "First 50 Duffinian numbers:"
+var dcount = 0
+var n = 1
+while dcount < 50:
+  if ds[n] != 0:
+    stdout.write &" {n:3}"
+    inc dcount
+    if dcount mod 25 == 0:
+      echo()
+  inc n
+echo()
+
+# Show the Duffinian triplets below MaxNumber.
+echo &"The Duffinian triplets up to {MaxNumber}:"
+dcount = 0
+for n in 3..MaxNumber:
+  if ds[n - 2] != 0 and ds[n - 1] != 0 and ds[n] != 0:
+    inc dcount
+    stdout.write &" {(n - 2, n - 1, n): ^24}"
+    stdout.write if dcount mod 4 == 0: '\n' else: ' '
+echo()

Task/Duffinian-numbers/Perl/duffinian-numbers.pl

@@ -0,0 +1,26 @@
+use strict;
+use warnings;
+use feature <say state>;
+use List::Util 'max';
+use ntheory qw<divisor_sum is_prime gcd>;
+
+sub table { my $t = shift() * (my $c = 1 + max map {length} @_); ( sprintf( ('%'.$c.'s')x@_, @_) ) =~ s/.{1,$t}\K/\n/gr }
+
+sub duffinian {
+    my($n) = @_;
+    state $c = 1; state @D;
+    do { push @D, $c if ! is_prime ++$c and 1 == gcd($c,divisor_sum($c)) } until @D > $n;
+    $D[$n];
+}
+
+say "First 50 Duffinian numbers:";
+say table 10, map { duffinian $_-1 } 1..50;
+
+my(@d3,@triples) = (4, 8, 9); my $n = 3;
+while (@triples < 39) {
+    push @triples, '('.join(', ',@d3).')' if $d3[1] == 1+$d3[0] and $d3[2] == 2+$d3[0];
+    shift @d3 and push @d3, duffinian ++$n;
+}
+
+say 'First 39 Duffinian triplets:';
+say table 3, @triples;

Task/Duffinian-numbers/Phix/duffinian-numbers.phix

@@ -0,0 +1,24 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">duffinian</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #004600;">false</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: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">triplet</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">triple_count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
+ <span style="color: #008080;">while</span> <span style="color: #000000;">triple_count</span><span style="color: #0000FF;"><</span><span style="color: #000000;">50</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">bool</span> <span style="color: #000000;">bDuff</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">is_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">gcd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sum</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;">1</span>
+     <span style="color: #000000;">duffinian</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">bDuff</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">bDuff</span> <span style="color: #008080;">then</span>
+         <span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">count</span><span style="color: #0000FF;">=</span><span style="color: #000000;">50</span> <span style="color: #008080;">then</span>
+             <span style="color: #004080;">sequence</span> <span style="color: #000000;">s50</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"%3d"</span><span style="color: #0000FF;">},</span><span style="color: #7060A8;">find_all</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">duffinian</span><span style="color: #0000FF;">)})</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;">"First 50 Duffinian numbers:\n%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s50</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">25</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">))</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">triplet</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #000000;">triple_count</span> <span style="color: #0000FF;">+=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">triplet</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">else</span>
+         <span style="color: #000000;">triplet</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</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>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">s</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;">sq_add</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">match_all</span><span style="color: #0000FF;">({</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">},</span><span style="color: #000000;">duffinian</span><span style="color: #0000FF;">),{{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}}}),</span>
+          <span style="color: #000000;">p</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;">pad_tail</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;">"[%d,%d,%d]"</span><span style="color: #0000FF;">},</span><span style="color: #000000;">s</span><span style="color: #0000FF;">}),</span><span style="color: #000000;">24</span><span style="color: #0000FF;">})</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;">"First 50 Duffinian triplets:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">)})</span>
+<!--

Task/Duffinian-numbers/Quackery/duffinian-numbers.quackery

@@ -0,0 +1,35 @@
+  [ dup factors
+    dup size 3 < iff
+      [ 2drop false ] done
+    0 swap witheach +
+    gcd 1 = ]              is duffinian ( n --> b )
+
+  [] 0
+  [ dup duffinian if
+      [ tuck join swap ]
+    1+
+    over size 50 = until ]
+  drop
+  [] swap
+  witheach
+    [ number$ nested join ]
+  60 wrap$
+  cr cr
+  0 temp put
+  [] 0
+  [ dup duffinian iff
+      [ 1 temp tally ]
+    else
+      [ 0 temp replace ]
+    temp share 2 > if
+      [ tuck 2 -
+        join swap ]
+    1+
+    over size 15 = until ]
+  drop
+  [] swap
+  witheach
+    [ dup 1+ dup 1+
+      join join
+      nested join ]
+  witheach [ echo cr ]

Task/Duffinian-numbers/Raku/duffinian-numbers.raku

@@ -0,0 +1,10 @@
+use Prime::Factor;
+
+my @duffinians = lazy (3..*).hyper.grep: { !.is-prime && $_ gcd .&divisors.sum == 1 };
+
+put "First 50 Duffinian numbers:\n" ~
+@duffinians[^50].batch(10)».fmt("%3d").join: "\n";
+
+put "\nFirst 40 Duffinian triplets:\n" ~
+    ((^∞).grep: -> $n { (@duffinians[$n] + 1 == @duffinians[$n + 1]) && (@duffinians[$n] + 2 == @duffinians[$n + 2]) })[^40]\
+    .map( { "({@duffinians[$_ .. $_+2].join: ', '})" } ).batch(4)».fmt("%-24s").join: "\n";

Task/Duffinian-numbers/Sidef/duffinian-numbers.sidef

@@ -0,0 +1,11 @@
+func is_duffinian(n) {
+    n.is_composite && n.is_coprime(n.sigma)
+}
+
+say "First 50 Duffinian numbers:"
+say 50.by(is_duffinian)
+
+say "\nFirst 15 Duffinian triplets:"
+15.by{|n| ^3 -> all {|k| is_duffinian(n+k) } }.each {|n|
+    printf("(%s, %s, %s)\n", n, n+1, n+2)
+}

Task/Duffinian-numbers/Wren/duffinian-numbers.wren

@@ -0,0 +1,27 @@
+import "./math" for Int
+import "./seq" for Lst
+import "./fmt" for Fmt
+
+var limit = 200000  // say
+var d = Int.primeSieve(limit-1, false)
+d[1] = false
+for (i in 2...limit) {
+    if (!d[i]) continue
+    if (i % 2 == 0 && !Int.isSquare(i) && !Int.isSquare(i/2)) {
+        d[i] = false
+        continue
+    }
+    var sigmaSum = Int.divisorSum(i)
+    if (Int.gcd(sigmaSum, i) != 1) d[i] = false
+}
+
+var duff = (1...d.count).where { |i| d[i] }.toList
+System.print("First 50 Duffinian numbers:")
+Fmt.tprint("$3d", duff[0..49], 10)
+
+var triplets = []
+for (i in 2...limit) {
+    if (d[i] && d[i-1] && d[i-2]) triplets.add([i-2, i-1, i])
+}
+System.print("\nFirst 50 Duffinian triplets:")
+Fmt.tprint("$-25n", triplets[0..49], 4)

Task/Duffinian-numbers/XPL0/duffinian-numbers.xpl0

@@ -0,0 +1,63 @@
+func IsPrime(N);        \Return 'true' if N is prime
+int  N, I;
+[if N <= 2 then return N = 2;
+if (N&1) = 0 then \even >2\ return false;
+for I:= 3 to sqrt(N) do
+    [if rem(N/I) = 0 then return false;
+    I:= I+1;
+    ];
+return true;
+];
+
+func    SumDiv(Num);    \Return sum of proper divisors of Num
+int     Num, Div, Sum, Quot;
+[Div:= 2;
+Sum:= 0;
+loop    [Quot:= Num/Div;
+        if Div > Quot then quit;
+        if rem(0) = 0 then
+            [Sum:= Sum + Div;
+            if Div # Quot then Sum:= Sum + Quot;
+            ];
+        Div:= Div+1;
+        ];
+return Sum+1;
+];
+
+func GCD(A, B);         \Return greatest common divisor of A and B
+int  A, B;
+[while A#B do
+  if A>B then A:= A-B
+         else B:= B-A;
+return A;
+];
+
+func Duff(N);           \Return 'true' if N is a Duffinian number
+int  N;
+[if IsPrime(N) then return false;
+return GCD(SumDiv(N), N) = 1;
+];
+
+int C, N;
+[Format(4, 0);
+C:= 0;  N:= 4;
+loop    [if Duff(N) then
+            [RlOut(0, float(N));
+            C:= C+1;
+            if C >= 50 then quit;
+            if rem(C/20) = 0 then CrLf(0);
+            ];
+        N:= N+1;
+        ];
+CrLf(0);  CrLf(0);
+Format(5, 0);
+C:= 0;  N:= 4;
+loop    [if Duff(N) & Duff(N+1) & Duff(N+2) then
+            [RlOut(0, float(N));  RlOut(0, float(N+1));  RlOut(0, float(N+2));
+            CrLf(0);
+            C:= C+1;
+            if C >= 15 then quit;
+            ];
+        N:= N+1;
+        ];
+]