June 2018 Update

Task/Kaprekar-numbers/Erlang/kaprekar-numbers.erl

@@ -0,0 +1,27 @@
+-mode(compile).
+-import(lists, [seq/2]).
+
+kaprekar(1) -> true;
+kaprekar(N) when N < 1 -> false;
+kaprekar(N) ->
+    Sq = N*N,
+    if
+        (N rem 9) =/= (Sq rem 9) -> false;
+        true -> kaprekar(N, Sq, 10)
+    end.
+
+kaprekar(_, Sq,  M) when (Sq div M) =:= 0 -> false;
+kaprekar(N, Sq, M) ->
+    L = Sq div M,
+    R = Sq rem M,
+    if
+        R =/= 0 andalso (L + R) =:= N -> true;
+        true -> kaprekar(N, Sq, M * 10)
+    end.
+
+main(_) ->
+    Numbers = [N || N <- seq(1, 9999), kaprekar(N)],
+    io:format("The Kaprekar numbers < 10,000 are ~p~n", [Numbers]),
+
+    CountTo1e6 = length(Numbers) + length([N || N <- seq(10001, 999999), kaprekar(N)]),
+    io:format("There are ~p Kaprekar numbers < 1,000,000", [CountTo1e6]).

Task/Kaprekar-numbers/Factor/kaprekar-numbers.factor

@@ -0,0 +1,27 @@
+USING: grouping.extras kernel math math.parser math.ranges
+math.text.utils prettyprint sequences sequences.extras
+splitting ;
+IN: rosetta-code.kaprekar
+
+: digits ( n -- digits )
+    1 digit-groups reverse ;
+
+: digit-pairs ( digits -- seq1 seq2 )
+    [ tail-clump ] [ head-clump ] bi [ 1 rotate ] dip ;
+
+: digit-pairs>number-pairs ( seq1 seq2 -- seq1' seq2' )
+    [ [ 10 digits>integer ] map but-last ] bi@ ;
+
+: remove-zeros ( seq1 seq2 -- seq1' seq2' )
+    [ [ 0 = ] split1-when drop ] bi@ ;
+
+: kaprekar-pairs ( n -- seq1 seq2 )
+    digits digit-pairs digit-pairs>number-pairs remove-zeros ;
+
+: kaprekar? ( n -- ? )
+    dup sq kaprekar-pairs [ + ] 2map member? ;
+
+: main ( -- )
+    10000 [1,b) [ kaprekar? ] filter { 1 } prepend . ;
+
+MAIN: main

Task/Kaprekar-numbers/Julia/kaprekar-numbers.julia

@@ -1,6 +1,11 @@
-function iskaprekar(n)
-    str = string(n^2)
-    n == 1 ? true :
-    any([ n == parse(Int,str[1:i]) + parse(Int,str[i+1:end]) && parse(Int,str[i+1:end]) != 0
-          for i = 1:length(str)-1])
+function iskaprekar(n::Integer)
+    str = dec(n ^ 2)
+    if n == 1 return true
+    else
+        return any(n == parse(Int, str[1:i]) + parse(Int, str[i+1:end]) && parse(Int, str[i+1:end]) != 0
+            for i = 1:length(str)-1)
+    end
 end
+
+@show filter(iskaprekar, 1:10000)
+@show count(iskaprekar, 1:10000)

Task/Kaprekar-numbers/Modula-2/kaprekar-numbers.mod2

@@ -0,0 +1,63 @@
+MODULE Kaprekar;
+FROM FormatString IMPORT FormatString;
+FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;
+
+PROCEDURE kaprekar(n,base : LONGCARD) : BOOLEAN;
+VAR
+    nn,r,tens : LONGCARD;
+BEGIN
+    nn := n*n;
+    tens := 1;
+    IF ((nn - n) MOD (base - 1)) # 0 THEN RETURN FALSE END;
+
+    WHILE tens < n DO tens := tens * base END;
+    IF n = tens THEN
+        IF 1 = n THEN RETURN TRUE END;
+        RETURN FALSE
+    END;
+
+    LOOP
+        r := nn MOD tens;
+        IF r >= n THEN BREAK END;
+        IF nn DIV tens + r = n THEN RETURN tens#0 END;
+        tens := tens * base;
+    END;
+
+    RETURN FALSE
+END kaprekar;
+
+PROCEDURE print_num(n,base : LONGCARD);
+VAR q,d : LONGCARD;
+BEGIN
+    d := base;
+
+    WHILE d<n DO d := d * base END;
+    LOOP
+        d := d DIV base;
+        IF n BAND d = 0 THEN RETURN END;
+        q := n DIV d;
+        IF q<10 THEN
+            Write(CHR(INT(q) + INT(ORD('0'))))
+        ELSE
+            Write(CHR(INT(q) + INT(ORD('a')) - 10))
+        END;
+        n := n - q * d
+    END
+END print_num;
+
+VAR
+    buf : ARRAY[0..63] OF CHAR;
+    i,tens,cnt,base : LONGCARD;
+BEGIN
+    cnt := 0;
+    base := 10;
+    FOR i:=1 TO 1000000 DO
+        IF kaprekar(i,base) THEN
+            INC(cnt);
+            FormatString("%3u: %u\n", buf, cnt, i);
+            WriteString(buf)
+        END
+    END;
+
+    ReadChar
+END Kaprekar.

Task/Kaprekar-numbers/REXX/kaprekar-numbers.rexx

@@ -12,7 +12,7 @@ exit                                             /*stick a fork in it,  we're al
 /*──────────────────────────────────────────────────────────────────────────────────────*/
 Kaprekar: procedure; parse arg N; #=0; aN=abs(N) /*set counter to zero; use  │N│  value.*/
           numeric digits max(9, 2*length(N) )    /*use enough decimal digits for square.*/
-          if aN>1  then call tell 1              /*unity is defined to be a Kaprekar #. */
+          if aN>0  then call tell 1              /*unity is defined to be a Kaprekar #. */
                                                  /* [↑]  handle case of  N  being unity.*/
           if aN>1  then do j=2  for aN-2;  s=j*j /*calculate the  square  of  J   (S).  */
                         if j//9==s//9  then do k=1  for length(s)%2  /*≡ casted out 9's?*/

Task/Kaprekar-numbers/Sidef/kaprekar-numbers.sidef

@@ -1,19 +1,18 @@
-require('ntheory')
 var kap = Hash()
 
-for n (1..15) {
+for n in (1..15) {
     var np = (10**n - 1)
-    %S<ntheory>.fordivisors({ |d|
-        var dp = np//d
-        if ((d `gcd` dp) == 1) {
+    np.divisors.each { |d|
+        var dp = np/d
+        if (is_coprime(dp, d)) {
             kap{ dp == 1 ? d : d*invmod(d, dp) } := 0 ++
         }
-    }, np)
+    }
 }
 
-var nums = kap.keys.map{.to_n}.sort
+var nums = kap.keys.map{ Num(_) }.sort
 
-for n (6 .. 14) {
+for n in (6 .. 14) {
     var np = (10**n - 1)
     printf("Kaprekar numbers <= 10^%2d:  %5d\n", n, nums.count_by { .<= np })
 }