Data update

Task/Duffinian-numbers/APL/duffinian-numbers.apl

@@ -0,0 +1,8 @@
+duffinian_numbers←{
+    sigma ← +/(⍸0=⍳|⊢)
+    duff ← sigma((1=∨)∧⊣>1+⊢)⊢
+    ⎕←'First 50 Duffinian numbers:'
+    ⎕←5 10⍴(⊢(/⍨)duff¨)⍳220
+    ⎕←'First 15 Duffinian triplets:'
+    ⎕←(0 1 2∘.+⍨⊢(/⍨)0 1 2(⊃∧.⌽)(⊂duff¨))⍳8500
+}

Task/Duffinian-numbers/BCPL/duffinian-numbers.bcpl

@@ -0,0 +1,45 @@
+get "libhdr"
+
+let calcsigmas(sig, n) be
+$(  sig!0 := 0
+    for i = 0 to n do sig!i := 0
+    for i = 1 to n/2 do
+    $(  let j = i
+        while 0 < j <= n do
+        $(  sig!j := sig!j + i
+            j := j + i
+        $)
+    $)
+$)
+
+let gcd(m, n) = n=0 -> m, gcd(n, m rem n)
+
+let duff(sig, n) = sig!n > n+1 & gcd(n, sig!n) = 1
+let triple(sig, n) = duff(sig, n) & duff(sig, n+1) & duff(sig, n+2)
+
+let first(sig, f, max, cb) be
+$(  let n = 0
+    for i = 1 to max
+    $(  n := n+1 repeatuntil f(sig, n)
+        cb(i, n)
+    $)
+$)
+
+let start() be
+$(  let showsingle(i, n) be
+    $(  writef("%I4", n)
+        if i rem 10=0 then wrch('*N')
+    $)
+
+    let showtriple(i, n) be writef("%I2: %I6 %I6 %I6*N", i, n, n+1, n+2)
+
+    let sig = getvec(20000)
+    calcsigmas(sig, 20000)
+
+    writes("First 50 Duffinian numbers:*N")
+    first(sig, duff, 50, showsingle)
+
+    writes("*NFirst 15 Duffinian triples:*N")
+    first(sig, triple, 15, showtriple)
+    freevec(sig)
+$)

Task/Duffinian-numbers/Draco/duffinian-numbers.draco

@@ -0,0 +1,58 @@
+word MAXSIGMA = 10000;
+[MAXSIGMA+1]word sigma;
+
+proc calcsigma() void:
+    word i, j;
+    for i from 0 upto MAXSIGMA do sigma[i] := 0 od;
+    for i from 1 upto MAXSIGMA do
+        for j from i by i upto MAXSIGMA do
+            sigma[j] := sigma[j] + i
+        od
+    od
+corp
+
+proc gcd(word a, b) word:
+    word c;
+    while b > 0 do
+        c := a % b;
+        a := b;
+        b := c;
+    od;
+    a
+corp
+
+proc duff(word n) bool:
+    sigma[n] > n+1 and gcd(n, sigma[n]) = 1
+corp
+
+proc triplet(word n) bool:
+    duff(n) and duff(n+1) and duff(n+2)
+corp
+
+proc first(word n; proc(word n)bool pred; proc(word i,n)void cb) void:
+    word i, cur;
+    cur := 0;
+    for i from 1 upto n do
+        while cur := cur + 1; not pred(cur) do od;
+        cb(i, cur)
+    od
+corp
+
+proc tablenum(word i, n) void:
+    write(n:5);
+    if i%10 = 0 then writeln() fi
+corp
+
+proc tripletline(word i, n) void:
+    writeln(i:2, ' ', n:6, n+1:6, n+2:6)
+corp
+
+proc main() void:
+    calcsigma();
+    writeln("First 50 Duffinian numbers:");
+    first(50, duff, tablenum);
+    writeln();
+
+    writeln("First 15 Duffinian triplets:");
+    first(15, triplet, tripletline)
+corp

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

@@ -34,7 +34,7 @@ end fn = result
 local fn IsDuffinian( n as NSUInteger) as BOOL
   BOOL result = NO
 
-  if ( fn IsPrime(n) == NO and fn GCD( fn SumDiv(n), n ) == 1 ) then exit fn = YES
+  if ( fn IsPrime(n) == NO && fn GCD( fn SumDiv(n), n ) == 1 ) then exit fn = YES
 end fn = result
 
 local fn FindDuffinians

Task/Duffinian-numbers/MAD/duffinian-numbers.mad

@@ -0,0 +1,51 @@
+            NORMAL MODE IS INTEGER
+            DIMENSION SIGMA(10000),OUTROW(10)
+
+            INTERNAL FUNCTION(AA,BB)
+            ENTRY TO GCD.
+            A = AA
+            B = BB
+STEP        WHENEVER A.E.B, FUNCTION RETURN A
+            WHENEVER A.G.B, A = A-B
+            WHENEVER A.L.B, B = B-A
+            TRANSFER TO STEP
+            END OF FUNCTION
+
+            INTERNAL FUNCTION(N)
+            ENTRY TO DUFF.
+            SIG = SIGMA(N)
+            FUNCTION RETURN SIG.G.N+1 .AND. GCD.(N,SIG).E.1
+            END OF FUNCTION
+
+            INTERNAL FUNCTION(N)
+            ENTRY TO TRIP.
+            FUNCTION RETURN DUFF.(N) .AND.
+          0      DUFF.(N+1) .AND. DUFF.(N+2)
+            END OF FUNCTION
+
+            THROUGH SZERO, FOR I=1, 1, I.G.10000
+SZERO       SIGMA(I) = 0
+            THROUGH SCALC, FOR I=1, 1, I.G.10000
+            THROUGH SCALC, FOR J=I, I, J.G.10000
+SCALC       SIGMA(J) = SIGMA(J) + I
+
+            PRINT COMMENT $ FIRST 50 DUFFINIAN NUMBERS$
+            CAND = 0
+            THROUGH DUFROW, FOR R=0, 1, R.GE.5
+            THROUGH DUFCOL, FOR C=0, 1, C.GE.10
+SCHDUF      THROUGH SCHDUF, FOR CAND=CAND+1, 1, DUFF.(CAND)
+DUFCOL      OUTROW(C) = CAND
+DUFROW      PRINT FORMAT ROWFMT,OUTROW(0),OUTROW(1),OUTROW(2),
+          0           OUTROW(3),OUTROW(4),OUTROW(5),OUTROW(6),
+          1           OUTROW(7),OUTROW(8),OUTROW(9)
+
+            PRINT COMMENT $ $
+            PRINT COMMENT $ FIRST 15 DUFFINIAN TRIPLETS$
+            CAND = 0
+            THROUGH DUFTRI, FOR S=0, 1, S.GE.15
+SCHTRP      THROUGH SCHTRP, FOR CAND=CAND+1, 1, TRIP.(CAND)
+DUFTRI      PRINT FORMAT TRIFMT,CAND,CAND+1,CAND+2
+
+            VECTOR VALUES ROWFMT = $10(I5)*$
+            VECTOR VALUES TRIFMT = $3(I7)*$
+            END OF PROGRAM

Task/Duffinian-numbers/Modula-2/duffinian-numbers.mod2

@@ -0,0 +1,69 @@
+MODULE DuffinianNumbers;
+FROM InOut IMPORT WriteCard, WriteString, WriteLn;
+
+CONST
+    MaxSigma = 10000;
+
+VAR
+    seen, cur: CARDINAL;
+    sigma: ARRAY [1..MaxSigma] OF CARDINAL;
+
+PROCEDURE CalculateSigmaTable;
+    VAR i, j: CARDINAL;
+BEGIN
+    FOR i := 1 TO MaxSigma DO
+        sigma[i] := 0
+    END;
+    FOR i := 1 TO MaxSigma DO
+        j := i;
+        WHILE j <= MaxSigma DO
+            INC(sigma[j], i);
+            INC(j, i);
+        END
+    END
+END CalculateSigmaTable;
+
+PROCEDURE GCD(a, b: CARDINAL): CARDINAL;
+    VAR c: CARDINAL;
+BEGIN
+    WHILE b # 0 DO
+        c := a MOD b;
+        a := b;
+        b := c
+    END;
+    RETURN a
+END GCD;
+
+PROCEDURE IsDuffinian(n: CARDINAL): BOOLEAN;
+BEGIN
+    RETURN (sigma[n] > n+1) AND (GCD(n, sigma[n]) = 1)
+END IsDuffinian;
+
+PROCEDURE IsDuffinianTriple(n: CARDINAL): BOOLEAN;
+BEGIN
+    RETURN IsDuffinian(n) AND IsDuffinian(n+1) AND IsDuffinian(n+2)
+END IsDuffinianTriple;
+
+BEGIN
+    CalculateSigmaTable;
+    WriteString("First 50 Duffinian numbers:");
+    WriteLn;
+    cur := 0;
+    FOR seen := 1 TO 50 DO
+        REPEAT INC(cur) UNTIL IsDuffinian(cur);
+        WriteCard(cur, 4);
+        IF seen MOD 10 = 0 THEN WriteLn END
+    END;
+
+    WriteLn;
+    WriteString("First 15 Duffinian triples:");
+    WriteLn;
+    cur := 0;
+    FOR seen := 1 TO 15 DO
+        REPEAT INC(cur) UNTIL IsDuffinianTriple(cur);
+        WriteCard(cur, 6);
+        WriteCard(cur+1, 6);
+        WriteCard(cur+2, 6);
+        WriteLn
+    END
+END DuffinianNumbers.

Task/Duffinian-numbers/PL-I/duffinian-numbers.pli

@@ -0,0 +1,58 @@
+duffinianNumbers: procedure options(main);
+    %replace MAXSIGMA by 10000;
+    declare sigma (1:MAXSIGMA) fixed;
+
+    calculateSigmaTable: procedure;
+        declare (i, j) fixed;
+        do i=1 to MAXSIGMA;
+            sigma(i) = 0;
+        end;
+        do i=1 to MAXSIGMA;
+            do j=i to MAXSIGMA by i;
+                sigma(j) = sigma(j) + i;
+            end;
+        end;
+    end calculateSigmaTable;
+
+    gcd: procedure(aa,bb) returns(fixed);
+        declare (a, aa, b, bb, c) fixed;
+        a = aa;
+        b = bb;
+        do while(b > 0);
+            c = mod(a,b);
+            a = b;
+            b = c;
+        end;
+        return(a);
+    end gcd;
+
+    duffinian: procedure(n) returns(bit);
+        declare n fixed;
+        return(sigma(n) > n+1 & gcd(n, sigma(n)) = 1);
+    end duffinian;
+
+    triplet: procedure(n) returns(bit);
+        declare n fixed;
+        return(duffinian(n) & duffinian(n+1) & duffinian(n+2));
+    end triplet;
+
+    declare (i, n) fixed;
+
+    call calculateSigmaTable;
+    put skip list('First 50 Duffinian numbers:');
+    put skip;
+    n=0;
+    do i=1 to 50;
+        do n=n+1 repeat(n+1) while(^duffinian(n)); end;
+        put edit(n) (F(5));
+        if mod(i,10) = 0 then put skip;
+    end;
+
+    put skip;
+    put skip list('First 15 Duffinian triplets:');
+    n=0;
+    do i=1 to 15;
+        do n=n+1 repeat(n+1) while(^triplet(n)); end;
+        put skip edit(n, n+1, n+2) (F(7),F(7),F(7));
+    end;
+end duffinianNumbers;

Task/Duffinian-numbers/PL-M/duffinian-numbers.plm

@@ -0,0 +1,80 @@
+100H:
+BDOS: PROCEDURE (F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;
+EXIT: PROCEDURE; GO TO 0; END EXIT;
+PR$CHAR: PROCEDURE (C); DECLARE C BYTE; CALL BDOS(2,C); END PR$CHAR;
+PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;
+
+PR$NUM: PROCEDURE (N, WIDTH);
+    DECLARE N ADDRESS, WIDTH BYTE;
+    DECLARE S (6) BYTE INITIAL ('.....$');
+    DECLARE P ADDRESS, DG BASED P BYTE;
+    P = .S(5);
+DIGIT:
+    P = P - 1;
+    DG = '0' + N MOD 10;
+    IF WIDTH > 0 THEN WIDTH = WIDTH - 1;
+    IF (N := N / 10) > 0 THEN GO TO DIGIT;
+    CALL PRINT(P);
+    DO WHILE WIDTH > 0;
+        CALL PR$CHAR(' ');
+        WIDTH = WIDTH - 1;
+    END;
+END PR$NUM;
+
+DECLARE MAX$SIGMA LITERALLY '10$001';
+DECLARE SIGMA (MAX$SIGMA) ADDRESS;
+CALC$SIGMA: PROCEDURE;
+    DECLARE (I, J) ADDRESS;
+    DO I = 1 TO MAX$SIGMA-1;
+        SIGMA(I) = 0;
+    END;
+    DO I = 1 TO MAX$SIGMA-1;
+        DO J = I TO MAX$SIGMA-1 BY I;
+            SIGMA(J) = SIGMA(J) + I;
+        END;
+    END;
+END CALC$SIGMA;
+
+GCD: PROCEDURE (X, Y) ADDRESS;
+    DECLARE (X, Y, Z) ADDRESS;
+    DO WHILE Y > 0;
+        Z = X MOD Y;
+        X = Y;
+        Y = Z;
+    END;
+    RETURN X;
+END GCD;
+
+DUFF: PROCEDURE (N) BYTE;
+    DECLARE N ADDRESS;
+    RETURN SIGMA(N) > N+1 AND GCD(N, SIGMA(N)) = 1;
+END DUFF;
+
+DUFF$TRIPLE: PROCEDURE (N) BYTE;
+    DECLARE N ADDRESS;
+    RETURN DUFF(N) AND DUFF(N+1) AND DUFF(N+2);
+END DUFF$TRIPLE;
+
+DECLARE N ADDRESS, I BYTE;
+
+CALL CALC$SIGMA;
+CALL PRINT(.('FIRST 50 DUFFINIAN NUMBERS:',13,10,'$'));
+N = 0;
+DO I = 1 TO 50;
+    DO WHILE NOT DUFF(N := N+1); END;
+    CALL PR$NUM(N, 4);
+    IF I MOD 10 = 0 THEN CALL PRINT(.(13,10,'$'));
+END;
+
+CALL PRINT(.(13,10,'FIRST 15 DUFFINIAN TRIPLES:',13,10,'$'));
+N = 0;
+DO I = 1 TO 15;
+    DO WHILE NOT DUFF$TRIPLE(N := N+1); END;
+    CALL PR$NUM(N, 6);
+    CALL PR$NUM(N+1, 6);
+    CALL PR$NUM(N+2, 6);
+    CALL PRINT(.(13,10,'$'));
+END;
+
+CALL EXIT;
+EOF

Task/Duffinian-numbers/Python/duffinian-numbers.py

@@ -0,0 +1,30 @@
+# duffinian.py by xing216
+
+def factors(n):
+    factors = []
+    for i in range(1, n + 1):
+       if n % i == 0:
+           factors.append(i)
+    return factors
+def gcd(a, b):
+    while b != 0:
+        a, b = b, a % b
+    return a
+is_relively_prime = lambda a, b: gcd(a, b) == 1
+sigma_sum = lambda x: sum(factors(x))
+is_duffinian = lambda x: is_relively_prime(x, sigma_sum(x)) and len(factors(x)) > 2
+count = 0
+i = 0
+while count < 50:
+    if is_duffinian(i):
+        print(i, end=' ')
+        count += 1
+    i+=1
+count2 = 0
+j = 0
+while count2 < 20:
+    if is_duffinian(j) and is_duffinian(j+1) and is_duffinian(j+2):
+        print(f"({j},{j+1},{j+2})", end=' ')
+        count2 += 1
+        j+=3
+    j+=1

Task/Duffinian-numbers/Ruby/duffinian-numbers.rb

@@ -0,0 +1,30 @@
+require "prime"
+
+class Integer
+
+  def proper_divisors(prim_div = prime_division)
+    return [] if self == 1
+    primes = prim_div.flat_map{|prime, freq| [prime] * freq}
+    (1...primes.size).each_with_object([1]) do |n, res|
+      primes.combination(n).map{|combi| res << combi.inject(:*)}
+    end.flatten.uniq
+  end
+
+  def duffinian?
+    pd = prime_division
+    return false if pd.sum(&:last) < 2
+    gcd(proper_divisors(pd).sum + self) == 1
+  end
+
+end
+
+n = 50
+puts "The first #{n} Duffinian numbers:"
+(1..).lazy.select(&:duffinian?).first(n).each_slice(10) do |slice|
+  puts "%4d" * slice.size % slice
+end
+
+puts "\nThe first #{n} Duffinian triplets:"
+(1..).each_cons(3).lazy.select{|slice| slice.all?(&:duffinian?)}.first(n).each do |group|
+  puts "%8d" * group.size % group
+end