Data update

Task/Duffinian-numbers/Forth/duffinian-numbers.fth

@@ -0,0 +1,61 @@
+: gcd ( u1 u2 -- u3 )
+  dup 0= if drop exit then
+  tuck mod recurse ;
+
+: duffinian? ( u -- ? )
+  dup 2 = if drop false exit then
+  1 >r dup 2
+  begin
+    over 2 mod 0=
+  while
+    dup r> + >r 2* swap 2/ swap
+  repeat
+  drop 3
+  begin
+    2dup dup * >=
+  while
+    dup 1 >r
+    begin
+      2 pick 2 pick mod 0=
+    while
+      dup r> + >r over * >r tuck / swap r>
+    repeat
+    2r> * >r drop 2 +
+  repeat
+  drop
+  2dup = if 2drop rdrop false exit then
+  dup 1 > if 1+ r> * else drop r> then
+  gcd 1 = ;
+
+: main
+  ." First 50 Duffinian numbers:" cr
+  0 1
+  begin
+    over 50 <
+  while
+    dup duffinian? if
+      dup 3 .r
+      swap 1+ swap
+      over 10 mod 0= if cr else space then
+    then
+    1+
+  repeat
+  2drop
+  cr ." First 30 Duffinian triplets:" cr
+  0 >r 0 1
+  begin
+    r@ 30 <
+  while
+    dup duffinian? if swap 1+ swap else nip 0 swap then
+    over 3 = if
+      r> 1+ >r
+      dup 2 - 5 .r space
+      dup 1- 5 .r space
+      dup 5 .r cr
+    then
+    1+
+  repeat
+  rdrop 2drop ;
+
+main
+bye

Task/Duffinian-numbers/Lua/duffinian-numbers.lua

@@ -0,0 +1,58 @@
+function gcd(a, b)
+    while b ~= 0 do
+        a, b = b, a % b
+    end
+    return a
+end
+
+function duffinian(n)
+    if n == 2 then return false end
+    local total = 1
+    local power = 2
+    local m = n
+    while (n & 1) == 0 do
+        total = total + power
+        power = power << 1
+        n = n >> 1
+    end
+    local p = 3
+    while p * p <= n do
+        local sum = 1
+        local power = p
+        while n % p == 0 do
+            sum = sum + power
+            power = power * p
+            n = n / p
+        end
+        total = total * sum
+        p = p + 2
+    end
+    if m == n then return false end
+    if n > 1 then total = total * (n + 1) end
+    return gcd(total, m) == 1
+end
+
+print("First 50 Duffinian numbers:")
+count = 0
+n = 1
+while count < 50 do
+    if duffinian(n) then
+        count = count + 1
+        if count % 10 == 0 then space = 10 else space = 32 end
+        io.write(string.format('%3d%c', n, space))
+    end
+    n = n + 1
+end
+
+print("\nFirst 30 Duffinian triplets:")
+n = 1
+m = 0
+count = 0
+while count < 30 do
+    if duffinian(n) then m = m + 1 else m = 0 end
+    if m == 3 then
+        count = count + 1
+        print(string.format('%d, %d, %d', n - 2, n - 1, n))
+    end
+    n = n + 1
+end

Task/Duffinian-numbers/Refal/duffinian-numbers.refal

@@ -0,0 +1,76 @@
+$ENTRY Go {
+    = <Prout 'First 50 Duffinian numbers:'>
+      <Each Prout <Group 10 <Gen 50 Duffinian>>>
+      <Prout>
+      <Prout 'First 15 Duffinian triples:'>
+      <Each ShowTriple <Gen 15 DuffinianTriple>>;
+};
+
+ShowTriple {
+    s.N = <Prout s.N <Add 1 s.N> <Add 2 s.N>>;
+};
+
+Each {
+    s.F = ;
+    s.F t.I e.X = <Mu s.F t.I> <Each s.F e.X>;
+};
+
+Group {
+    s.N = ;
+    s.N e.X, <First s.N e.X>: (e.1) e.2 = (e.1) <Group s.N e.2>;
+};
+
+Gen {
+    s.N s.F = <Gen s.N s.F 0>;
+    0   s.F s.I = ;
+    s.N s.F s.I, <Mu s.F s.I>: {
+        True  = s.I <Gen <Sub s.N 1> s.F <Add s.I 1>>;
+        False = <Gen s.N s.F <Add s.I 1>>;
+    };
+};
+
+DuffinianTriple {
+    s.N, <Duffinian s.N>
+         <Duffinian <Add 1 s.N>>
+         <Duffinian <Add 2 s.N>>: True True True = True;
+    s.N = False;
+};
+
+Duffinian {
+    s.N, <SigmaSum s.N>: s.S,
+         <Add s.N 1>: s.P,
+         s.S <Gcd s.N s.S>: {
+            s.P s.1 = False;
+            s.Q 1   = True;
+            s.1 s.2 = False;
+        };
+};
+
+Gcd {
+    s.A 0   = s.A;
+    s.A s.B = <Gcd s.B <Mod s.A s.B>>;
+};
+
+SigmaSum {
+    s.N = <SigmaSum s.N <Add 1 s.N> 2 <Sqrt s.N>>;
+    s.N s.Sum s.D s.Max, <Compare s.D s.Max>: '+' = s.Sum;
+    s.N s.Sum s.D s.Max, <Mul s.D s.D>: s.N = <Add s.Sum s.Max>;
+    s.N s.Sum s.D s.Max, <Mod s.N s.D>: 0 =
+        <SigmaSum s.N
+            <Add s.Sum
+            <Add s.D <Div s.N s.D>>>
+            <Add 1 s.D> s.Max>;
+    s.N s.Sum s.D s.Max = <SigmaSum s.N s.Sum <Add 1 s.D> s.Max>;
+};
+
+Sqrt {
+    0 = 1;
+    1 = 1;
+    s.N = <Sqrt s.N <Div s.N 2>>;
+    s.N s.X0,
+        <Div <Add s.X0 <Div s.N s.X0>> 2>: s.X1,
+        <Compare s.X0 s.X1>: {
+            '+' = <Sqrt s.N s.X1>;
+            s.C = s.X0;
+        };
+};

Task/Duffinian-numbers/SETL/duffinian-numbers.setl

@@ -0,0 +1,48 @@
+program duffinian_numbers;
+    init sigma := divisor_sum_table(20000);
+
+    print("First 50 Duffinian numbers:");
+    loop for n in first(50, routine is_duffinian) do
+        nprint(lpad(str n, 6));
+        if (col +:= 1) mod 10 = 0 then print; end if;
+    end loop;
+
+    print;
+    print("First 15 Duffinian triplets:");
+    loop for n in first(15, routine is_duffinian_triplet) do
+        print(+/[lpad(str i, 6) : i in [n,n+1,n+2]]);
+    end loop;
+
+    proc first(num, pred);
+        ls := [];
+        loop while #ls < num do
+            loop until call(pred, n) do
+                n +:= 1;
+            end loop;
+            ls with:= n;
+        end loop;
+        return ls;
+    end proc;
+
+    proc is_duffinian_triplet(n);
+        return and/[is_duffinian(i) : i in [n,n+1,n+2]];
+    end proc;
+
+    proc is_duffinian(n);
+        return sigma(n) > n+1 and gcd(n, sigma(n)) = 1;
+    end proc;
+
+    proc gcd(a,b);
+        return if b=0 then a else gcd(b, a mod b) end;
+    end proc;
+
+    proc divisor_sum_table(sz);
+        ds := [0] * sz;
+        loop for i in [1..sz] do
+            loop for j in [i,i+i..sz] do
+                ds(j) +:= i;
+            end loop;
+        end loop;
+        return ds;
+    end proc;
+end program;