Data commit

2023-07-01 11:58:00 -04:00 · 2023-07-01 11:58:00 -04:00 · cb5bb5e222
commit cb5bb5e222
parent 7387c8f97b
199093 changed files with 3378972 additions and 0 deletions
--- a/Task/Kaprekar-numbers/00-META.yaml
+++ b/Task/Kaprekar-numbers/00-META.yaml
@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Kaprekar_numbers
--- a/Task/Kaprekar-numbers/00-TASK.txt
+++ b/Task/Kaprekar-numbers/00-TASK.txt
@ -0,0 +1,47 @@
+A positive integer is a [[wp:Kaprekar number|Kaprekar number]] if:
+* It is &nbsp; '''1''' &nbsp; &nbsp; (unity)
+* The decimal representation of its square may be split once into two parts consisting of positive integers which sum to the original number. 
+<br>Note that a split resulting in a part consisting purely of 0s is not valid, 
+as 0 is not considered positive.
+
+
+;Example Kaprekar numbers:
+* <math>2223</math> is a Kaprekar number, as <math>2223 * 2223 = 4941729</math>, <math>4941729</math> may be split to <math>494</math> and <math>1729</math>, and <math>494 + 1729 = 2223</math>.
+* The series of Kaprekar numbers is known as [[oeis:A006886|A006886]], and begins as <math>1, 9, 45, 55, ...</math>.
+
+
+;Example process:
+10000 (100<sup>2</sup>) splitting from left to right:
+* The first split is [1, 0000], and is invalid; the 0000 element consists entirely of 0s, and 0 is not considered positive.
+* Slight optimization opportunity: When splitting from left to right, once the right part consists entirely of 0s, no further testing is needed; all further splits would also be invalid.
+
+
+;Task:
+Generate and show all Kaprekar numbers less than 10,000. 
+
+
+;Extra credit:
+Optionally, count (and report the count of) how many Kaprekar numbers are less than 1,000,000.
+
+
+;Extra extra credit:
+The concept of Kaprekar numbers is not limited to base 10 (i.e. decimal numbers); 
+if you can, show that Kaprekar numbers exist in other bases too.  
+
+
+For this purpose, do the following:
+* Find all Kaprekar numbers for base 17 between 1 and 1,000,000 (one million);
+* Display each of them in base 10 representation;
+* Optionally, using base 17 representation (use letters 'a' to 'g' for digits 10(10) to 16(10)), display each of the numbers, its square, and where to split the square. 
+ 
+<br>For example, 225(10) is "d4" in base 17, its square "a52g", and a5(17) + 2g(17) = d4(17), so the display would be something like:<pre>225   d4  a52g  a5 + 2g</pre>
+
+
+;Reference:
+* [http://www.cs.uwaterloo.ca/journals/JIS/VOL3/iann2a.html The Kaprekar Numbers] by Douglas E. Iannucci (2000). [http://pictor.math.uqam.ca/~plouffe/OEIS/jis/The%20Kaprekar%20Numbers.pdf PDF version]
+
+
+;Related task:
+* &nbsp; [[Casting out nines]]
+<br><br>
+
--- a/Task/Kaprekar-numbers/11l/kaprekar-numbers.11l
+++ b/Task/Kaprekar-numbers/11l/kaprekar-numbers.11l
@ -0,0 +1,11 @@
+F k(n)
+   V n2 = String(Int64(n) ^ 2)
+   L(i) 0 .< n2.len
+      V a = I i > 0 {Int(n2[0 .< i])} E 0
+      V b = Int(n2[i ..])
+      I b != 0 & a + b == n
+         R 1B
+   R 0B
+
+print((1..9999).filter(x -> k(x)))
+print((1..999999).filter(x -> k(x)).len)
--- a/Task/Kaprekar-numbers/360-Assembly/kaprekar-numbers.360
+++ b/Task/Kaprekar-numbers/360-Assembly/kaprekar-numbers.360
@ -0,0 +1,95 @@
+*        Kaprekar numbers          22/03/ 2017
+KAPREKAR CSECT
+         USING  KAPREKAR,R13       base register
+         B      72(R15)            skip savearea
+         DC     17F'0'             savearea
+         STM    R14,R12,12(R13)    save previous context
+         ST     R13,4(R15)         link backward
+         ST     R15,8(R13)         link forward
+         LR     R13,R15            set addressability
+         LA     R10,0              n=0
+         LA     R6,1               i=1
+       DO WHILE=(C,R6,LE,=F'1000000')  do i=1 to 1000000
+         CVD    R6,PI                pi=i
+         ZAP    PS,PI                ps=pi
+         MP     PS,PI                ps=pi*pi
+         ZAP    PX,PS                ps
+         OI     PX+7,X'0F'           zap sign
+         UNPK   SW,PX                packed PL8 to zoned CL16
+         MVC    SS(16),SW            s=pic(ps,16)
+         MVI    OK,X'00'             ok=false
+         LA     R7,1                 j=1
+       DO WHILE=(C,R7,LE,=F'15')     do j=1 to 15
+         LA     R2,16                  16
+         SR     R2,R7                  -j
+         ST     R2,LL                  l=16-j
+         LA     R2,S1                  @s1
+         LA     R3,20                  20
+         LA     R4,SS                  @s
+         LR     R5,R7                  j
+         ICM    R5,B'1000',=C' '       pad
+         MVCL   R2,R4                  s1=substr(s,1,j)
+         LA     R2,S2                  @s2
+         LA     R3,20                  20
+         LA     R4,SS                  @s
+         AR     R4,R7                  +j
+         L      R5,LL                  l
+         ICM    R5,B'1000',=C' '       pad
+         MVCL   R2,R4                  s2=substr(s,j+1,l)
+         MVC    ZZ,=20C'0'             zw=(20)'0'
+         LA     R2,S1                  @s1
+         LR     R3,R7                  j
+         LA     R4,ZZ                  @zz
+         LR     R5,R7                  j
+         CLCL   R2,R4                  if substr(s1,1,j)=substr(zz,1,j)
+         BE     ITERJ                  then iterate j
+         LA     R2,S2                  @s2
+         L      R3,LL                  l
+         LA     R4,ZZ                  @zz
+         L      R5,LL                  l
+         CLCL   R2,R4                  if substr(s2,1,l)=substr(zz,1,l)
+         BE     EXITJ                  then leave j
+         XDECI  R2,S1                  unedit s1
+         ST     R2,M1                  m1=s1
+         XDECI  R2,S2                  unedit s2
+         ST     R2,M2                  m2=s2
+         L      R2,M1                  m1
+         A      R2,M2                  +m2
+         ST     R2,MM                  m=m1+m2
+       IF C,R6,EQ,MM THEN              if i=m then
+         MVI    OK,X'01'                 ok=true
+         B      EXITJ                    leave j
+       ENDIF    ,                      end if
+ITERJ    LA     R7,1(R7)               j++
+       ENDDO    ,                    enddo j
+EXITJ    EQU    *                    exitj:
+       IF CLI,OK,EQ,X'01',OR,C,R6,EQ,=F'1' THEN  if ok or i=1 then
+         LA     R10,1(R10)               n=n+1
+         XDECO  R10,PG                   edit n
+         XDECO  R6,PG+12                 edit i
+         XPRNT  PG,L'PG                  print buffer
+       ENDIF    ,                      end if
+         LA     R6,1(R6)             i++
+       ENDDO    ,                  enddo i
+         L      R13,4(0,R13)       restore previous savearea pointer
+         LM     R14,R12,12(R13)    restore previous context
+         XR     R15,R15            rc=0
+         BR     R14                exit
+OK       DS     X                  ok logical
+LL       DS     F                  l  binary
+MM       DS     F                  m  "
+M1       DS     F                  m1 "
+M2       DS     F                  m2 "
+         DS     0D                 -- alignment for cvd
+PI       DS     PL8                pi fixed decimal(15)
+PM       DS     PL8                pm "
+PS       DS     PL8                ps "
+PX       DS     PL8                px "
+SS       DC     CL20' '            s  character(20)
+S1       DS     CL20               s1 "
+S2       DS     CL20               s2 "
+ZZ       DS     CL20               z  "
+SW       DS     CL16               sw character(16)
+PG       DC     CL80' '            buffer
+         YREGS
+         END    KAPREKAR
--- a/Task/Kaprekar-numbers/ALGOL-68/kaprekar-numbers.alg
+++ b/Task/Kaprekar-numbers/ALGOL-68/kaprekar-numbers.alg
@ -0,0 +1,43 @@
+# find some Kaprekar numbers                              #
+
+# returns TRUE if n is a Kaprekar number, FALSE otherwise #
+PROC is kaprekar = ( INT n )BOOL:
+     IF n < 1 THEN
+         # 0 and -ve numbers are not Kaprekar numbers     #
+         FALSE
+     ELIF n = 1 THEN
+         # 1 is defined to be a Kaprekar number           #
+         TRUE
+     ELSE
+         # n is a Kaprekar number if the digits of its    #
+         # square can be partitioned into two numbers     #
+         # that sum to n                                  #
+         LONG INT  n squared     = LENG n * n;
+         LONG INT  power of ten := 10;
+         BOOL result            := FALSE;
+         WHILE n squared > power of ten AND NOT result DO
+             LONG INT left  = n squared OVER power of ten;
+             LONG INT right = n squared  MOD power of ten;
+             result := ( ( left + right ) = n AND right /= 0 );
+             power of ten *:= 10
+         OD;
+         result
+     FI # is kaprekar # ;
+
+
+# count the number of Kaprekar numbers up to 1 000 000    #
+# printing all those below 10 000                         #
+INT max number           = 1 000 000;
+INT k count             := 0;
+[ 1 : 2 ]LONG INT split := ( 0, 0 );
+print( ( "Kaprekar numbers below 10 000: ", newline ) );
+FOR n TO max number DO
+    IF is kaprekar( n ) THEN
+        k count +:= 1;
+        IF n < 10 000 THEN
+            print( ( " ", whole( n, -4 ) ) )
+        FI
+    FI
+OD;
+print( ( newline ) );
+print( ( "There are ", whole( k count, 0 ), " Kaprekar numbers below ", whole( max number, 0 ), newline ) )
--- a/Task/Kaprekar-numbers/AWK/kaprekar-numbers.awk
+++ b/Task/Kaprekar-numbers/AWK/kaprekar-numbers.awk
@ -0,0 +1,25 @@
+# syntax: GAWK -f KAPREKAR_NUMBERS.AWK
+BEGIN {
+    limit = 1000000
+    printf("%d\n",1)
+    n = 1
+    for (i=2; i<limit; i++) {
+      squared = sprintf("%.0f",i*i)
+      for (j=1; j<=length(squared); j++) {
+        L = substr(squared,1,j) + 0
+        R = substr(squared,j+1) + 0
+        if (R == 0) {
+          continue
+        }
+        if (L + R == i) {
+          n++
+          if (i <= 10000) {
+            printf("%d\n",i)
+          }
+          break
+        }
+      }
+    }
+    printf("%d Kaprekar numbers < %s\n",n,limit)
+    exit(0)
+}
--- a/Task/Kaprekar-numbers/Ada/kaprekar-numbers.ada
+++ b/Task/Kaprekar-numbers/Ada/kaprekar-numbers.ada
@ -0,0 +1,131 @@
+with Ada.Text_IO;
+with Ada.Strings.Fixed;
+
+procedure Kaprekar2 is
+   use Ada.Strings.Fixed;
+
+   To_Digit : constant String := "0123456789abcdefghijklmnopqrstuvwxyz";
+
+   type Int is mod 2 ** 64;
+   subtype Base_Number is Int range 2 .. 36;
+
+   From_Digit : constant array (Character) of Int :=
+     ('0'    => 0,
+      '1'    => 1,
+      '2'    => 2,
+      '3'    => 3,
+      '4'    => 4,
+      '5'    => 5,
+      '6'    => 6,
+      '7'    => 7,
+      '8'    => 8,
+      '9'    => 9,
+      'a'    => 10,
+      'b'    => 11,
+      'c'    => 12,
+      'd'    => 13,
+      'e'    => 14,
+      'f'    => 15,
+      'g'    => 16,
+      'h'    => 17,
+      'i'    => 18,
+      'j'    => 19,
+      'k'    => 20,
+      'l'    => 21,
+      'm'    => 22,
+      'n'    => 23,
+      'o'    => 24,
+      'p'    => 25,
+      'q'    => 26,
+      'r'    => 27,
+      's'    => 28,
+      't'    => 29,
+      'u'    => 30,
+      'v'    => 31,
+      'w'    => 32,
+      'x'    => 33,
+      'y'    => 34,
+      'z'    => 35,
+      others => 0);
+
+   function To_String (Item : Int; Base : Base_Number := 10) return String is
+      Value       : Int := Item;
+      Digit_Index : Natural;
+      Result      : String (1 .. 64);
+      First       : Natural := Result'Last;
+   begin
+      while Value > 0 loop
+         Digit_Index := Natural (Value mod Base);
+         Result (First) := To_Digit (Digit_Index + 1);
+         Value := Value / Base;
+         First := First - 1;
+      end loop;
+      return Result (First + 1 .. Result'Last);
+   end To_String;
+
+   procedure Get (From : String; Item : out Int; Base : Base_Number := 10) is
+   begin
+      Item := 0;
+      for I in From'Range loop
+         Item := Item * Base;
+         Item := Item + From_Digit (From (I));
+      end loop;
+   end Get;
+
+   function Is_Kaprekar (N : Int; Base : Base_Number := 10) return Boolean is
+      Square : Int;
+   begin
+      if N = 1 then
+         return True;
+      else
+         Square := N ** 2;
+         declare
+            Image : String := To_String (Square, Base);
+            A, B  : Int;
+         begin
+            for I in Image'First .. Image'Last - 1 loop
+               exit when Count (Image (I + 1 .. Image'Last), "0")
+                 = Image'Last - I;
+               Get (From => Image (Image'First .. I),
+                    Item => A,
+                    Base => Base);
+               Get (From => Image (I + 1 .. Image'Last),
+                    Item => B,
+                    Base => Base);
+               if A + B = N then
+                  return True;
+               end if;
+            end loop;
+         end;
+      end if;
+      return False;
+   end Is_Kaprekar;
+
+   Count : Natural := 0;
+begin
+   for I in Int range 1 .. 10_000 loop
+      if Is_Kaprekar (I) then
+         Count := Count + 1;
+         Ada.Text_IO.Put (To_String (I) & ",");
+      end if;
+   end loop;
+   Ada.Text_IO.Put_Line (" Total:" & Integer'Image (Count));
+
+   for I in Int range 10_001 .. 1_000_000 loop
+      if Is_Kaprekar (I) then
+         Count := Count + 1;
+      end if;
+   end loop;
+   Ada.Text_IO.Put_Line ("Kaprekar Numbers below 1000000:" &
+                         Integer'Image (Count));
+
+   Count := 0;
+   Ada.Text_IO.Put_Line ("Kaprekar Numbers below 1000000 in base 17:");
+   for I in Int range 1 .. 17 ** 6 loop
+      if Is_Kaprekar (I, 17) then
+         Count := Count + 1;
+         Ada.Text_IO.Put (To_String (I, 17) & ",");
+      end if;
+   end loop;
+   Ada.Text_IO.Put_Line (" Total:" & Integer'Image (Count));
+end Kaprekar2;
--- a/Task/Kaprekar-numbers/Arturo/kaprekar-numbers.arturo
+++ b/Task/Kaprekar-numbers/Arturo/kaprekar-numbers.arturo
@ -0,0 +1,13 @@
+k?: function [n][
+    n2: to :string n*n
+    loop 0..dec size n2 'i [
+        a: (i > 0)? -> to :integer slice n2 0 dec i -> 0
+        b: to :integer slice n2 i dec size n2
+        if and? b > 0 n = a + b -> return true
+    ]
+    return false
+]
+
+loop 1..10000 'x [
+    if k? x -> print x
+]
--- a/Task/Kaprekar-numbers/AutoHotkey/kaprekar-numbers-1.ahk
+++ b/Task/Kaprekar-numbers/AutoHotkey/kaprekar-numbers-1.ahk
@ -0,0 +1,15 @@
+Kaprekar(L) {
+    Loop, % L + ( C := 0 ) {
+        S := ( N := A_Index ) ** 2
+        Loop % StrLen(N) {
+            B := ( B := SubStr(S,1+A_Index) ) ? B : 0
+            If !B & ( (A := SubStr(S,1,A_Index)) <> 1 )
+                Break
+            If ( N == A+B ) {
+                R .= ", " N , C++
+                Break
+            }
+        }
+    }
+    Return C " Kaprekar numbers in [1-" L "]:`n" SubStr(R,3)
+}
--- a/Task/Kaprekar-numbers/AutoHotkey/kaprekar-numbers-2.ahk
+++ b/Task/Kaprekar-numbers/AutoHotkey/kaprekar-numbers-2.ahk
@ -0,0 +1 @@
+MsgBox, % Kaprekar(10000)
--- a/Task/Kaprekar-numbers/BASIC256/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/BASIC256/kaprekar-numbers.basic
@ -0,0 +1,21 @@
+n = 0
+for i = 1 to 1999999
+	if Kaprekar(i) then
+		n = n + 1
+		if i < 100001 then print n; ": "; i
+	endif
+next i
+print
+print "Total de números de Kaprekar por debajo de 1.000.000 = "; n
+end
+
+function Kaprekar(n)
+	s = n ^ 2
+	t = 10 ^ (int(log(s)) + 1)
+	do
+		t = t / 10
+		if t <= n then exit do #break
+		if s-n = int(s/t)*(t-1) then return TRUE
+	until t <= n
+	return n = 1
+end function
--- a/Task/Kaprekar-numbers/BBC-BASIC/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/BBC-BASIC/kaprekar-numbers.basic
@ -0,0 +1,21 @@
+      *FLOAT 64
+      n% = 0
+      FOR i% = 1 TO 999999
+        IF FNkaprekar(i%) THEN
+          n% += 1
+          IF i% < 100001PRINT ; n% ":", i%
+        ENDIF
+      NEXT
+      PRINT "Total Kaprekar numbers under 1,000,000 = "; n%
+      END
+
+      DEF FNkaprekar(n)
+      LOCAL s, t
+      s = n^2
+      t = 10^(INT(LOG(s)) + 1)
+      REPEAT
+        t /= 10
+        IF t<=n EXIT REPEAT
+        IF s-n = INT(s/t)*(t-1) THEN = TRUE
+      UNTIL FALSE
+      = (n=1)
--- a/Task/Kaprekar-numbers/Batch-File/kaprekar-numbers.bat
+++ b/Task/Kaprekar-numbers/Batch-File/kaprekar-numbers.bat
@ -0,0 +1,58 @@
+@echo off
+setlocal enabledelayedexpansion
+
+for /l %%i in (1,1,9999) do (
+  title Processing - %%i
+  call:kaprekar %%i
+)
+
+pause>nul
+exit /b
+
+:kaprekar
+set num=%1
+if %num% leq 0 exit /b
+set /a num2=%num%*%num%
+
+if %num2% leq 9 (
+  if %num2%==%num% (
+    echo %num%
+    exit /b
+  ) else (
+    exit /b
+  )
+)
+
+call:strlength %num2%
+set len=%errorlevel%
+set /a offset=%len%-1
+set tempcount=1
+
+:loop
+
+set /a offset2=%len%-%tempcount%
+set numleft=!num2:~0,%tempcount%!
+set numright=!num2:~%tempcount%,%offset2%!
+
+for /f "tokens=* delims=0" %%i in ("%numright%") do set "numright=%%i"
+if not defined numright exit /b
+set /a sum=%numleft%+%numright%
+
+if %sum%==%num% (
+  echo %num%
+  exit /b
+)
+
+if %tempcount%==%len% exit /b
+set /a tempcount+=1
+goto loop
+
+:strlength
+setlocal enabledelayedexpansion
+set str=%1
+set tempcount=1
+:lengthloop
+set /a length=%tempcount%-1
+if "!str:~%tempcount%,1!"=="" exit /b %tempcount%
+set /a tempcount+=1
+goto lengthloop
--- a/Task/Kaprekar-numbers/Bracmat/kaprekar-numbers.bracmat
+++ b/Task/Kaprekar-numbers/Bracmat/kaprekar-numbers.bracmat
@ -0,0 +1,18 @@
+( 0:?n
+& 1:?count
+& out$(!count 1)
+&   whl
+  ' ( 1+!n:<1000000:?n
+    & ( @( !n^2
+         :   #?a
+             ( ? (#>0:?b)
+             & !a+!b:!n
+             & 1+!count:?count
+             & (!n:<10000&out$!n|)
+             )
+         )
+      |
+      )
+    )
+& out$(str$("There are " !count " kaprekar numbers less than 1000000"))
+);
--- a/Task/Kaprekar-numbers/Brat/kaprekar-numbers.brat
+++ b/Task/Kaprekar-numbers/Brat/kaprekar-numbers.brat
@ -0,0 +1,27 @@
+kaprekar = { limit |
+  results = []
+
+  1.to limit, { num |
+    true? num == 1
+    { results << 1 }
+    {
+      sqr = (num ^ 2).to_s
+
+      0.to (sqr.length - 1) { i |
+        lhs = sqr[0,i].to_i
+        rhs = sqr[i + 1,-1].to_i
+
+        true? (rhs > 0) && { lhs + rhs == num }
+        { results << num }
+      }
+    }
+  }
+
+  results
+}
+
+p "Kaprekar numbers below 10,000:"
+p kaprekar 10000
+
+p "Number of Kaprekar numbers below 1,000,000:"
+p kaprekar(1000000).length
--- a/Task/Kaprekar-numbers/C++/kaprekar-numbers-1.cpp
+++ b/Task/Kaprekar-numbers/C++/kaprekar-numbers-1.cpp
@ -0,0 +1,54 @@
+#include <vector>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include <utility>
+
+long string2long( const std::string & s ) {
+   long result ;
+   std::istringstream( s ) >> result ;
+   return result ;
+}
+
+bool isKaprekar( long number ) {
+   long long squarenumber = ((long long)number) * number ;
+   std::ostringstream numberbuf ;
+   numberbuf << squarenumber ;
+   std::string numberstring = numberbuf.str( ) ;
+   for ( int i = 0 ; i < numberstring.length( ) ; i++ ) {
+      std::string firstpart = numberstring.substr( 0 , i ) ,
+                  secondpart = numberstring.substr( i ) ;
+      //we do not accept figures ending in a sequence of zeroes
+      if ( secondpart.find_first_not_of( "0" ) == std::string::npos ) {
+	 return false ;
+      }
+      if ( string2long( firstpart ) + string2long( secondpart ) == number ) {
+	 return true ;
+      }
+   }
+   return false ;
+}
+
+int main( ) {
+   std::vector<long> kaprekarnumbers ;
+   kaprekarnumbers.push_back( 1 ) ;
+   for ( int i = 2 ; i < 1000001 ; i++ ) {
+      if ( isKaprekar( i ) )
+	 kaprekarnumbers.push_back( i ) ;
+   }
+   std::vector<long>::const_iterator svi = kaprekarnumbers.begin( ) ;
+   std::cout << "Kaprekar numbers up to 10000: \n" ;
+   while ( *svi < 10000 ) {
+      std::cout << *svi << " " ;
+      svi++ ;
+   }
+   std::cout << '\n' ;
+   std::cout << "All the Kaprekar numbers up to 1000000 :\n" ;
+   std::copy( kaprekarnumbers.begin( ) , kaprekarnumbers.end( ) ,
+	 std::ostream_iterator<long>( std::cout , "\n" ) ) ;
+   std::cout << "There are " << kaprekarnumbers.size( )
+      << " Kaprekar numbers less than one million!\n" ;
+   return 0 ;
+}
--- a/Task/Kaprekar-numbers/C++/kaprekar-numbers-2.cpp
+++ b/Task/Kaprekar-numbers/C++/kaprekar-numbers-2.cpp
@ -0,0 +1,22 @@
+// Generate Kaperkar Numbers
+//
+// Nigel Galloway. June 24th., 2012
+//
+#include <iostream>
+int main() {
+	const int Base = 10;
+	const int N = 6;
+	int Paddy_cnt = 0;
+	for (int nz=1; nz<=N; nz++)
+		for (unsigned long long int k=pow((double)Base,nz-1); k<pow((double)Base,nz); k++)
+			if ((k*(k-1))%(Base-1) == 0)
+				for (int n=nz; n<nz*2; n++){
+					const unsigned long long int B = pow((double)Base,n);
+					const double nr = k*(B-k)/(B-1);
+					const int q = k-nr;
+					if ((k*k==q*B+nr && 0<nr)){
+						std::cout << std::dec << ++Paddy_cnt << ": " << k << " is "  << q << " + " << (int)nr << " and squared is " << k*k << ". It is a member of Residual Set " << k%(Base-1) << "\n";
+						break;
+				}}
+	return 0;
+}
--- a/Task/Kaprekar-numbers/C++/kaprekar-numbers-3.cpp
+++ b/Task/Kaprekar-numbers/C++/kaprekar-numbers-3.cpp
@ -0,0 +1,3 @@
+const int Base = 16;
+const int N = 4;
+std::cout << std::dec << ++Paddy_cnt << ": " << std::hex << k << " is "  << q << " + " << (int)nr << " and squared is " << k*k << ". It is a member of Residual Set " << k%(Base-1) << "\n";
--- a/Task/Kaprekar-numbers/C++/kaprekar-numbers-4.cpp
+++ b/Task/Kaprekar-numbers/C++/kaprekar-numbers-4.cpp
@ -0,0 +1,19 @@
+// Generate Kaprekar Numbers using Casting Out Nines Generator
+//
+// Nigel Galloway. July 13th., 2012
+//
+#include <cmath>
+int main() {
+	const ran r(10);
+	int Paddy_cnt = 0;
+	for (int nz=1; nz<=6; nz++)
+		for (unsigned long long int k : co9(std::pow(r.base,nz-1),std::pow(r.base,nz)-1,&r))
+			for (int n=nz; n<nz*2; n++) {
+				const unsigned long long int B = pow(r.base,n);
+				const double nr = k*(B-k)/(B-1);
+				const int q = k-nr;
+				if (k*k==q*B+nr && 0<nr) {
+					std::cout << ++Paddy_cnt << ": " << k << " is "  << q << " + " << (int)nr << " and squared is " << k*k << ". It is a member of Residual Set " << k%(r.base-1) << "\n";
+			}}
+	return 0;
+}
--- a/Task/Kaprekar-numbers/C++/kaprekar-numbers-5.cpp
+++ b/Task/Kaprekar-numbers/C++/kaprekar-numbers-5.cpp
@ -0,0 +1,2 @@
+	const ran r = ran(16);
+					std::cout << std::dec << ++Paddy_cnt << ": " << std::hex << k << " is "  << q << " + " << (int)nr << " and squared is " << k*k << ". It is a member of Residual Set " << k%(r.base-1) << "\n";
--- a/Task/Kaprekar-numbers/C-sharp/kaprekar-numbers.cs
+++ b/Task/Kaprekar-numbers/C-sharp/kaprekar-numbers.cs
@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+
+public class KaprekarNumbers {
+
+    /// <summary>
+    /// The entry point of the program, where the program control starts and ends.
+    /// </summary>
+    public static void Main() {
+        int count = 0;
+
+        foreach ( ulong i in _kaprekarGenerator(999999) ) {
+            Console.WriteLine(i);
+            count++;
+        }
+
+        Console.WriteLine("There are {0} Kaprekar numbers less than 1000000.", count);
+    }
+
+    /// <summary>
+    /// Generator function which generates the Kaprekar numbers.
+    /// </summary>
+    /// <returns>The generator.</returns>
+    /// <param name="max">The maximum value of the numbers generated.</param>
+    private static IEnumerable<ulong> _kaprekarGenerator(ulong max) {
+
+        ulong next = 1;
+
+        // 1 is always a Kaprekar number.
+        yield return next;
+
+        for ( next = 2; next <= max; next++ ) {
+
+            ulong square = next * next;
+
+            for ( ulong check = 10; check <= 10000000000000000000; check *= 10 ) {
+                // Check the square against each power of 10 from 10^1 to 10^19 (highest which can be
+                // represented by a ulong)
+
+                // If the power of 10 to be checked against is greater than or equal to the square, stop checking
+                if ( square <= check )
+                    break;
+
+                // Given a power of 10 as 10^n, the remainder when dividing the square number by that power
+                // of 10 is equal to the last n digits of the number (starting from the right) and the
+                // quotient gives the remaining digits.
+                // If the last n digits are all zeroes, then the remainder will be zero, which is not
+                // accepted.
+
+                ulong r = square % check;
+                ulong q = (square - r) / check;
+
+                if ( r != 0 && q + r == next ) {
+                    yield return next;
+                    break;
+                }
+            }
+
+        }
+
+    }
+
+}
--- a/Task/Kaprekar-numbers/C/kaprekar-numbers-1.c
+++ b/Task/Kaprekar-numbers/C/kaprekar-numbers-1.c
@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdint.h>
+typedef uint64_t ulong;
+
+int kaprekar(ulong n, int base)
+{
+	ulong nn = n * n, r, tens = 1;
+
+	if ((nn - n) % (base - 1)) return 0;
+
+	while (tens < n) tens *= base;
+	if (n == tens) return 1 == n;
+
+	while ((r = nn % tens) < n) {
+		if (nn / tens + r == n) return tens;
+		tens *= base;
+	}
+
+	return 0;
+}
+
+void print_num(ulong n, int base)
+{
+	ulong q, div = base;
+
+	while (div < n) div *= base;
+	while (n && (div /= base)) {
+		q = n / div;
+		if (q < 10)     putchar(q + '0');
+		else            putchar(q + 'a' - 10);
+		n -= q * div;
+	}
+}
+
+int main()
+{
+	ulong i, tens;
+	int cnt = 0;
+	int base = 10;
+
+	printf("base 10:\n");
+	for (i = 1; i < 1000000; i++)
+		if (kaprekar(i, base))
+			printf("%3d: %llu\n", ++cnt, i);
+
+	base = 17;
+	printf("\nbase %d:\n  1: 1\n", base);
+	for (i = 2, cnt = 1; i < 1000000; i++)
+		if ((tens = kaprekar(i, base))) {
+			printf("%3d: %llu", ++cnt, i);
+			printf(" \t"); print_num(i, base);
+			printf("\t");  print_num(i * i, base);
+			printf("\t");  print_num(i * i / tens, base);
+			printf(" + "); print_num(i * i % tens, base);
+			printf("\n");
+		}
+
+	return 0;
+}
--- a/Task/Kaprekar-numbers/C/kaprekar-numbers-2.c
+++ b/Task/Kaprekar-numbers/C/kaprekar-numbers-2.c
@ -0,0 +1,104 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <limits.h>
+
+typedef signed long long xint;
+
+int factorize(xint n, xint* f)
+{
+	int i = 0;
+
+	inline void get_factor(xint p) {
+		if (n % p) return;
+		for (f[i] = 1; !(n % p); f[i] *= p, n /= p);
+		i++;
+	}
+
+	get_factor(2);
+	get_factor(3);
+	xint p, inc;
+	for (p = 5, inc = 4; p * p <= n; p += (inc = 6 - inc))
+		get_factor(p);
+	if (n > 1) get_factor(n);
+	return i;
+}
+
+// returns x where a x == 1 mod b
+xint mul_inv(xint a, xint b)
+{
+	xint b0 = b, t, q;
+	xint x0 = 0, x1 = 1;
+	if (b == 1) return 1;
+	while (a > 1) {
+		q = a / b;
+		t = b, b = a % b, a = t;
+		t = x0, x0 = x1 - q * x0, x1 = t;
+	}
+	if (x1 < 0) x1 += b0;
+	return x1;
+}
+
+int kaprekars(int base, xint top, xint *out, int max_cnt)
+{
+	xint f[64], pb;
+	int len, cnt = 0;
+
+	if (top >= LLONG_MAX / top) {
+		fprintf(stderr, "too large: %lld\n", top);
+		abort();
+	}
+
+	void kaps(xint a, int i) {
+		if (i < len) {
+			kaps(a * f[i], i + 1);
+			kaps(a, i + 1);
+			return;
+		}
+
+		xint x = a * mul_inv(a, (pb - 1) / a);
+		if (x > 1 && x < top) {
+			out[cnt++] = x;
+			if (cnt >= max_cnt) {
+				fprintf(stderr, "too many results\n");
+				abort();
+			}
+		}
+	}
+
+	out[cnt++] = 1;
+
+	for (pb = base; pb <= top * top / base; pb *= base) {
+		len = factorize(pb - 1, f);
+		if (f[len - 1] <= top) kaps(1, 0);
+	}
+	return cnt;
+}
+
+int main(void)
+{
+	xint x[1000];
+	int len, b;
+	
+	for (b = 2; b < 99; b++) {
+		printf("base %d:\n", b);
+
+		// find all kaprekar numbers that won't overflow
+		len = kaprekars(b, INT_MAX, x, 1000);
+#if 0
+		int i, j;
+		xint t;
+		for (i = 0; i < len; i++)
+			for (j = 0; j < i; j++)
+				if (x[i] < x[j])
+					t = x[i], x[i] = x[j], x[j] = t;
+
+		for (i = 0; i < len; i++)
+			printf("%3d: %lld\n", i + 1, x[i]);
+#else
+		printf("\t%d kaprepar numbers\n", len);
+#endif
+	}
+
+	return 0;
+}
--- a/Task/Kaprekar-numbers/CLU/kaprekar-numbers.clu
+++ b/Task/Kaprekar-numbers/CLU/kaprekar-numbers.clu
@ -0,0 +1,86 @@
+% This program assumes a 64-bit system.
+% On a 32-bit system, the main task (show Kaprekar numbers < 10,000)
+% will run correctly, but the extra credit part will crash with
+% an overflow exception.
+
+% Yield all positive splits of a number
+splits = iter (n, base: int) yields (int,int)
+    step: int := base
+    while n >= step do
+        left: int := n / step
+        right: int := n // step
+        if left ~= 0 & right ~= 0 then
+            yield(left, right)
+        end
+        step := step * base
+    end
+end splits
+
+% Check whether a number is a Kaprekar number, and if so,
+% return the proper split.
+kap_split = struct[left, right: int]
+maybe_kap = oneof[yes: kap_split, no: null]
+kaprekar = proc (n, base: int) returns (maybe_kap)
+    for left, right: int in splits(n**2, base) do
+        if left + right = n then
+            return(maybe_kap$make_yes(
+                kap_split${left:left, right:right}))
+        end
+    end
+    return(maybe_kap$make_no(nil))
+end kaprekar
+
+% Format a number in a given base
+to_base = proc (n, base: int) returns (string)
+    own digits: string := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    if n=0 then return("0") end
+    ds: array[char] := array[char]$[]
+    while n>0 do
+        array[char]$addl(ds,digits[n // base + 1])
+        n := n / base
+    end
+    return(string$ac2s(ds))
+end to_base
+
+% If a number is a Kaprekar number, show it, its square, and the split
+display = proc (o: stream, n, base: int)
+    tagcase kaprekar(n, base)
+        tag yes (s: kap_split):
+            stream$putright(o, to_base(n, 10), 6)
+            if base ~= 10 then
+                stream$putright(o, to_base(n, base), 7)
+            end
+            stream$putright(o, to_base(n**2, base), 13)
+            stream$putl(o, "  " ||
+                        to_base(s.left, base) || " + " ||
+                        to_base(s.right, base))
+       tag no:
+    end
+end display
+
+start_up = proc ()
+    po: stream := stream$primary_output()
+
+    % Find and output all the Kaprekar numbers under 10,000.
+    stream$putl(po, "Kaprekar numbers < 10,000:")
+    for i: int in int$from_to(1, 9999) do
+        display(po, i, 10)
+    end
+
+    % Count all the Kaprekar numbers under 1,000,000.
+    kaps: int := 0
+    for i: int in int$from_to(1, 999999) do
+        tagcase kaprekar(i, 10)
+            tag yes (s: kap_split): kaps := kaps + 1
+            tag no:
+        end
+    end
+    stream$putl(po, "\nThere are " || int$unparse(kaps) ||
+                " Kaprekar numbers under 1,000,000.\n")
+
+    % Find and output all base-17 Kaprekar numbers under 1,000,000.
+    stream$putl(po, "Base-17 Kaprekar numbers < 1,000,000:")
+    for i: int in int$from_to(1, 999999) do
+        display(po, i, 17)
+    end
+end start_up
--- a/Task/Kaprekar-numbers/CoffeeScript/kaprekar-numbers.coffee
+++ b/Task/Kaprekar-numbers/CoffeeScript/kaprekar-numbers.coffee
@ -0,0 +1,29 @@
+splitAt = (str, idx) ->
+    ans = [ str.substring(0, idx), str.substring(idx) ]
+    if ans[0] == ""
+        ans[0] = "0"
+    ans
+
+getKaprekarParts = (longValue, sqrStr, base) ->
+    for j in [ 0 .. sqrStr.length / 2 ]
+        parts = splitAt(sqrStr, j)
+        nums = (parseInt(n, base) for n in parts)
+
+        # if the right part is all zeroes, then it will be forever, so break
+        if nums[1] == 0
+            return null
+        if nums[0] + nums[1] == longValue
+            return parts
+    null
+
+base = 10
+count = 0
+max = 1000000
+for i in [1..max]
+    i2 = i * i
+    s = i2.toString(base)
+    p = getKaprekarParts i, s, base
+    if p
+        console.log i, i.toString(base), s, p.join '+'
+        count++
+console.log "#{count} Kaprekar numbers < #{max} (base 10) in base #{base}"
--- a/Task/Kaprekar-numbers/Common-Lisp/kaprekar-numbers-1.lisp
+++ b/Task/Kaprekar-numbers/Common-Lisp/kaprekar-numbers-1.lisp
@ -0,0 +1,41 @@
+;; make an infinite list whose accumulated sums give all
+;; numbers n where n mod (base - 1) == n^2 mod (base - 1)
+(defun res-list (base)
+    (let* ((b (- base 1))
+           (l (remove-if-not
+		    (lambda (x) (= (rem x b) (rem (* x x) b)))
+		    (loop for x from 0 below b collect x)))
+	   (ret (append l (list b)))
+	   (cycle (mapcar #'- (cdr ret) ret)))
+	(setf (cdr (last cycle)) cycle)))
+
+(defun kaprekar-p (n &optional (base 10))
+   "tests if n is kaprekar in base; if so, return left and right half"
+   (let ((nn (* n n)) (tens 1))
+	; Find a start value for base power.  nn/tens + (nn mod tens) == n
+	; can't be sastified if tens <= n: nn/tens = n * n / tens > n
+	(loop while (< tens n) do
+	      (setf tens (* tens base)))
+	(if (= tens n)  ; n a power of base, can't be a solution except 1
+	    (if (= n 1) (values T 0 1))
+	    (loop
+	       (let ((left (truncate nn tens)) (right (mod nn tens)))
+		    (cond ((>= right n) (return nil))
+			  ((= n (+ left right)) (return (values T left right))))
+		    (setf tens (* base tens)))))))
+
+(defun ktest (top &optional (base 10))
+   (format t "   #    Value     Left    Right       Squared (base ~D)~%" base)
+   (let ((fmt (format nil "~~4D ~~~D,8R ~~~D,8R ~~~D,8R ~~~D,13R~~%"
+                      base base base base base))
+	 (res (res-list base))
+	 (n 0))
+   	 (loop with cnt = 0 while (<= n top) do
+	 	(setf n (+ n (car res)))
+		(setf res (cdr res))
+	 	(multiple-value-bind (k l r) (kaprekar-p n base)
+		   (when k (format t fmt (incf cnt) n l r (* n n)))))))
+
+(ktest 1000000)
+(terpri)
+(ktest 1000000 17)
--- a/Task/Kaprekar-numbers/Common-Lisp/kaprekar-numbers-2.lisp
+++ b/Task/Kaprekar-numbers/Common-Lisp/kaprekar-numbers-2.lisp
@ -0,0 +1,14 @@
+;; Generate Kaprekar Numbers using Casting Out Nines Generator
+;;
+;; Nigel Galloway - October 1st., 2012
+;;
+(defconstant Base 10)
+(defconstant MAX 1000000)
+(defconstant ran (let ((N ()) (Base-1 (- Base 1))) (do ((cnt Base-1 (- cnt 1))) ((zerop cnt) (return N))
+   (if (= (mod (* cnt (- cnt 1)) Base-1) 0) (setf N (cons cnt N))))))
+
+(defun kap () (let ((Paddy_cnt 0) (Base-1 (- Base 1))) (do ((n 0 (+ n Base-1))) ((> n MAX) ()) (dolist (G ran)
+   (let ((N (+ G n))) (if (>= MAX N) (let ((kk (* N N))) (do ((B Base (* B Base))) (nil)
+     (let (( nr (/ (* N (- B N)) (- B 1)))) (if (< 0 nr) (let ((q (floor (- N nr)))) (if (= kk (+ nr (* q B)))
+       (format t "~3d: ~8d is ~8d + ~8d and squared is ~8d~&" (incf Paddy_cnt) N q nr kk))
+     (if (> B kk) (return)))))))))))))
--- a/Task/Kaprekar-numbers/D/kaprekar-numbers-1.d
+++ b/Task/Kaprekar-numbers/D/kaprekar-numbers-1.d
@ -0,0 +1,24 @@
+import std.stdio, std.conv, std.algorithm, std.range;
+
+bool isKaprekar(in long n) pure /*nothrow*/ @safe
+in {
+    assert(n > 0, "isKaprekar(n) is defined for n > 0.");
+} body {
+    if (n == 1)
+        return true;
+    immutable sn = text(n ^^ 2);
+
+    foreach (immutable i; 1 .. sn.length) {
+        immutable a = sn[0 .. i].to!long;
+        immutable b = sn[i .. $].to!long;
+        if (b && a + b == n)
+            return true;
+    }
+
+    return false;
+}
+
+void main() {
+    iota(1, 10_000).filter!isKaprekar.writeln;
+    iota(1, 1_000_000).count!isKaprekar.writeln;
+}
--- a/Task/Kaprekar-numbers/D/kaprekar-numbers-2.d
+++ b/Task/Kaprekar-numbers/D/kaprekar-numbers-2.d
@ -0,0 +1,21 @@
+bool isKaprekar(in uint n) pure nothrow @nogc @safe {
+    ulong powr = n ^^ 2UL;
+    ulong r, l, tens = 10;
+    while (r < n) {
+        r = powr % tens;
+        l = powr / tens;
+        if (r && (l + r == n))
+            return true;
+        tens *= 10;
+    }
+    return false;
+}
+
+void main() {
+    import std.stdio;
+
+    int count = 1;
+    foreach (immutable i; 1 .. 1_000_000)
+        if (i.isKaprekar)
+            writefln("%d: %d", count++, i);
+}
--- a/Task/Kaprekar-numbers/Dart/kaprekar-numbers.dart
+++ b/Task/Kaprekar-numbers/Dart/kaprekar-numbers.dart
@ -0,0 +1,49 @@
+import 'dart:math';
+  void main()
+{
+
+  int x1;
+  for(x1=1;x1<1000000;x1++){
+  int x;
+  int i,y,y1,l1,z,l;
+  double o,o1,o2,o3;
+   x=pow(x1,2);
+  for(i=0;;i++)
+  {z=pow(10,i);
+  if(x%z==x)break;}
+if(i.isEven)
+{
+  y=pow(10,i/2);
+  l=x%y;
+  o=x/y;
+  o=o-l/y;
+  o3=o;
+ for(int j=0;j<4;j++)
+ {
+   if(o%10==0)
+     o=o/10;
+   if(o%10!=0)
+     break;
+ }
+  if(o+l==x1 ||o3+l==x1 )
+     print('$x1');
+
+}
+  else
+
+  {  y1=pow(10,i/2+0.5);
+  l1=x%y1;
+  o1=x/y1;
+  o1=o1-l1/y1;
+   o2=o1;
+   for(int j=0;j<4;j++)
+ {
+   if(o1%10==0)
+     o1=o1/10;
+   else break;
+ }
+  if(o1+l1==x1 ||o2+l1==x1 )
+    print('$x1');
+  }
+}
+}
--- a/Task/Kaprekar-numbers/Delphi/kaprekar-numbers.delphi
+++ b/Task/Kaprekar-numbers/Delphi/kaprekar-numbers.delphi
@ -0,0 +1,39 @@
+function IsKaprekar(N: integer): boolean;
+{Return true if N is a Kaperkar number}
+var S,S1,S2: string;
+var N1,N2,Sum: cardinal;
+var Sp: integer;
+begin
+Result:=True;
+if N=1 then exit;
+{Convert N^2 to string}
+S:=IntToStr(N * N);
+{Try all different splits}
+for Sp:=2 to Length(S) do
+	begin
+	{Split into two strings}
+	S1:=Copy(S,1,Sp-1);
+	S2:=Copy(S,Sp,(Length(S)-Sp)+1);
+	{Convert to integers}
+	N1:=StrToInt(S1);
+	N2:=StrToInt(S2);
+	{Zeros aren't allowed}
+	if (N1=0) or (N2=0) then continue;
+	{Test if sum matches original number}
+	Sum:=N1 + N2;
+	if Sum=N then exit;
+	end;
+Result:=False;
+end;
+
+
+procedure ShowKaprekarNumbers(Memo: TMemo);
+{Find all Kaprekar numbers less than 10,000}
+var S: string;
+var I: integer;
+begin
+for I:=1 to 10000 do
+	begin
+	if IsKaprekar(I) then Memo.Lines.Add(IntToStr(I));
+	end;
+end;
--- a/Task/Kaprekar-numbers/Elixir/kaprekar-numbers.elixir
+++ b/Task/Kaprekar-numbers/Elixir/kaprekar-numbers.elixir
@ -0,0 +1,44 @@
+defmodule KaprekarNumber do
+  def check(n), do: check(n, 10)
+
+  def check(1,_base), do: {"1", ""}
+  def check(n, base) when rem(n*(n-1), (base-1)) != 0, do: false      # casting out nine
+  def check(n, base) do
+    square = Integer.to_string(n*n, base)
+    check(n, base, square, 1, String.length(square)-1)
+  end
+
+  defp check(_, _, _, _, 0), do: false
+  defp check(n, base, square, i, remainder) do
+    {a, b} = String.split_at(square, i)
+    if String.to_integer(b, base) == 0 do
+      false
+    else
+      sum = String.to_integer(a, base) + String.to_integer(b, base)
+      if n == sum, do: {a, b}, else: check(n, base, square, i+1, remainder-1)
+    end
+  end
+end
+
+Enum.each(1..9_999, fn n ->
+  if result = KaprekarNumber.check(n) do
+    {a, b} = result
+    :io.fwrite "~6w  ~8s  ~s + ~s~n", [n, a<>b, a, b]
+  end
+end)
+
+# Extra credit
+count = Enum.reduce(1..999_999, 0, fn n,acc ->
+  if KaprekarNumber.check(n), do: acc + 1, else: acc
+end)
+IO.puts "\n#{count} kaprekar numbers under 1,000,000"
+
+# Extra extra credit
+base = 17
+IO.puts "\nbase #{base} kaprekar numbers under 1,000,000(base10)"
+Enum.each(1..999_999, fn n ->
+  if result = KaprekarNumber.check(n, base) do
+    {a, b} = result
+    :io.fwrite "~7w  ~5s  ~9s  ~s + ~s~n", [n, Integer.to_string(n,base), a<>b, a, b]
+  end
+end)
--- a/Task/Kaprekar-numbers/Erlang/kaprekar-numbers.erl
+++ b/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]).
--- a/Task/Kaprekar-numbers/Euler/kaprekar-numbers.euler
+++ b/Task/Kaprekar-numbers/Euler/kaprekar-numbers.euler
@ -0,0 +1,16 @@
+>function map kaprekarp (n) ...
+$  m=n*n;
+$  p=10;
+$  repeat
+$    i=floor(m/p);
+$    j=mod(m,p);
+$    if j==0 then return 0; endif;
+$    if i+j==n then return 1; endif;
+$    p=p*10;
+$    until p>m;
+$  end;
+$  return 0;
+$endfunction
+>nonzeros(kaprekarp(1:100000))
+ [ 1  9  45  55  99  297  703  999  2223  2728  4879  5292  7272  7777
+ 9999  17344  22222  38962  77778  82656  95121  99999 ]
--- a/Task/Kaprekar-numbers/F-Sharp/kaprekar-numbers.fs
+++ b/Task/Kaprekar-numbers/F-Sharp/kaprekar-numbers.fs
@ -0,0 +1,35 @@
+// Count digits in number
+let digits x =
+    let rec digits' p x =
+        if 10.**p > x then p else digits' (p + 1.) x
+    digits' 1. x
+
+
+// Is n a Kaprekar number?
+let isKaprekar n =
+    // Reference: http://oeis.org/A006886
+    // Positive numbers n such that n=q+r
+    // And n^2=q*10^m+r,
+    //  for some m >= 1,
+    //  q>=0 and 0<=r<10^m,
+    //  with n != 10^a, a>=1.
+    let nSquared = n * n
+    let a = float((digits n) - 1.)
+
+    // Create a list of tuples from the nSquared digit splits
+    [1. .. float (digits nSquared)]
+    |> List.map (fun e ->
+        // Splits the nSquared digits into 2 parts
+        let x = 10.**e
+        let q = float(int(Math.Floor (nSquared / x)))
+        let r = nSquared - (q * x)
+        (q, r))
+    // Filter results based on rules
+    |> List.exists (fun (q, r) ->
+        q + r = n &&
+        if a >= 1. then n % 10.**a <> 0. else true)
+
+
+// List Kaprekar numbers from 1 to 10,000
+[1 .. 10000]
+|> List.filter (float >> isKaprekar)
--- a/Task/Kaprekar-numbers/Factor/kaprekar-numbers.factor
+++ b/Task/Kaprekar-numbers/Factor/kaprekar-numbers.factor
@ -0,0 +1,15 @@
+USING: io kernel lists lists.lazy locals math math.functions
+math.ranges prettyprint sequences ;
+
+:: kaprekar? ( n -- ? )
+    n sq :> sqr
+    1 lfrom
+    [ 10 swap ^ ] lmap-lazy
+    [ n > ] lfilter
+    [ sqr swap mod n < ] lwhile
+    list>array
+    [ 1 - sqr n - swap mod zero? ] any?
+    n 1 = or ;
+
+1,000,000 [1,b] [ kaprekar? ] filter dup . length
+"Count of Kaprekar numbers <= 1,000,000: " write .
--- a/Task/Kaprekar-numbers/Forth/kaprekar-numbers.fth
+++ b/Task/Kaprekar-numbers/Forth/kaprekar-numbers.fth
@ -0,0 +1,18 @@
+: square ( n - n^2)   dup * ;
+
+\ Return nonzero if n is a Kaprekar number for tens, where tens is a
+\ nonzero power of base.
+: is-kaprekar? ( tens n n^2 - t)   rot /mod  over >r  + =  r> and ;
+
+\ If n is a Kaprekar number, return is the power of base for which it
+\ is Kaprekar.  If n is not a Kaprekar number, return zero.
+: kaprekar ( +n - +n1)
+    dup square >r
+    base @ swap
+    begin ( tens n) ( R: n^2)
+        over r@ < while
+            2dup r@ is-kaprekar? if
+                drop  r> drop  exit  then
+            swap  base @ *  swap
+    repeat
+    r> drop  1 = and ;
--- a/Task/Kaprekar-numbers/Fortran/kaprekar-numbers.f
+++ b/Task/Kaprekar-numbers/Fortran/kaprekar-numbers.f
@ -0,0 +1,38 @@
+program Karpekar_Numbers
+  implicit none
+
+  integer, parameter :: i64 = selected_int_kind(18)
+  integer :: count
+
+  call karpekar(10000_i64, .true.)
+  write(*,*)
+  call karpekar(1000000_i64, .false.)
+
+contains
+
+subroutine karpekar(n, printnums)
+
+  integer(i64), intent(in) :: n
+  logical, intent(in) :: printnums
+  integer(i64) :: c, i, j, n1, n2
+  character(19) :: str, s1, s2
+
+  c = 0
+  do i = 1, n
+    write(str, "(i0)") i*i
+    do j = 0, len_trim(str)-1
+      s1 = str(1:j)
+      s2 = str(j+1:len_trim(str))
+      read(s1, "(i19)") n1
+      read(s2, "(i19)") n2
+      if(n2 == 0) cycle
+      if(n1 + n2 == i) then
+        c = c + 1
+        if (printnums .eqv. .true.) write(*, "(i0)") i
+        exit
+      end if
+    end do
+  end do
+  if (printnums .eqv. .false.) write(*, "(i0)") c
+end subroutine
+end program
--- a/Task/Kaprekar-numbers/FreeBASIC/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/FreeBASIC/kaprekar-numbers.basic
@ -0,0 +1,65 @@
+' version 04-12-2016
+' compile with: fbc -s console
+
+' define true and false for older versions
+#Ifndef TRUE
+#Define FALSE 0
+#Define TRUE Not FALSE
+#EndIf
+
+#Define max 1000000   ' maximum for number to be tested
+
+Function kaprekar(n As ULong) As ULong
+
+    If n = 1 Then Return TRUE
+
+    Dim As ULong x, p1, p2
+    Dim As ULongInt sq = CLngInt(n) * n
+    Dim As String sq_str = Str(sq)
+    Dim As ULong l = Len(sq_str)
+
+    ' decrease the lenght l for every "0"
+    ' at the end of the string
+    For x = l -1 To 1 Step -1
+        If sq_str[x] = Asc("0") Then
+            l = l -1
+        Else
+            Exit For
+        End If
+    Next
+
+    For x = 1 To l -1
+        p2 = Val(Mid(sq_str, x +1))
+        If p2 > n Then
+            Continue For
+        End If
+        p1 = Val(Left(sq_str, x))
+        If p1 > n Then Return FALSE  ' p1 > n leave
+        If (p1 + p2) = n Then Return TRUE
+    Next
+
+End Function
+
+' ------=< MAIN >=------
+
+Dim As ULong n, count
+
+Print "Kaprekar numbers below 10000"
+
+For n = 1 To max -1
+    If kaprekar(n) = TRUE Then
+        count = count + 1
+        If n < 10000 Then
+            Print count, n
+        End If
+    End If
+Next
+
+Print
+Print count;" numbers below "; Str(max);" are Kaprekar numbers"
+
+' empty keyboard buffer
+While Inkey <> "" : Wend
+Print : Print "hit any key to end program"
+Sleep
+End
--- a/Task/Kaprekar-numbers/Frink/kaprekar-numbers.frink
+++ b/Task/Kaprekar-numbers/Frink/kaprekar-numbers.frink
@ -0,0 +1,36 @@
+isKaprekar[n, base=10] :=
+{
+   if n==1
+      return [1, 1, 1]
+
+   s = base[n^2, base]
+   for i=1 to length[s]-1
+   {
+      ls = left[s,i]
+      l = parseInt[ls, base]
+      rs = right[s,-i]
+      r = parseInt[rs, base]
+
+      if isPositive[l] and isPositive[r] and l+r == n
+         return [n, s, "$ls + $rs"]
+   }
+
+   return undef
+}
+
+f = {|x| isKaprekar[x] != undef}
+println[formatTable[select[1 to 9999, f], "right"]]
+
+println[]
+print[length[select[1 to 999_999, f]]]
+println[" Kaprekar numbers less than 1,000,000"]
+
+println["\nKaprekar numbers in base 17:"]
+results = new array
+for i = 1 to 999_999
+{
+   r = isKaprekar[i, 17]
+   if r != undef
+      results.push[r]
+}
+println[formatTable[results, "right"]]
--- a/Task/Kaprekar-numbers/FutureBasic/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/FutureBasic/kaprekar-numbers.basic
@ -0,0 +1,28 @@
+local fn kaprekar( n as NSInteger ) as BOOL
+  NSInteger s = n^2
+  double t = 10^(int(log(s)) + 1)
+  BOOL result = NO
+
+  do
+    t = t / 10
+    if t <= n then break
+    if s - n == int(s/t)*(t-1) then result = YES : exit fn
+  until ( t <= n )
+  result = ( n = YES )
+end fn = result
+
+local fn DoIt
+  NSInteger i
+  float n = 0
+  for i = 1 to 1000000
+    if ( fn kaprekar(i) )
+      n++
+      if i < 1000000 then printf @"%2.f : %ld", n, i
+    end if
+  next
+  print "Kaprekar numbers under 1,000,000 = "; n
+end fn
+
+fn DoIt
+
+HandleEvents
--- a/Task/Kaprekar-numbers/GAP/kaprekar-numbers.gap
+++ b/Task/Kaprekar-numbers/GAP/kaprekar-numbers.gap
@ -0,0 +1,111 @@
+IsKaprekar := function(n)
+	local a, b, p, q;
+	if n = 1 then
+		return true;
+	fi;
+	q := n*n;
+	p := 10;
+	while p < q do
+		a := RemInt(q, p);
+		b := QuoInt(q, p);
+		if a > 0 and a + b = n then
+			return true;
+		fi;
+		p := p*10;
+	od;
+	return false;
+end;
+
+Filtered([1 .. 10000], IsKaprekar);
+# [ 1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272,
+#   7777, 9999 ]
+
+Size(last);
+# 17
+
+Filtered([1 .. 1000000], IsKaprekar);
+# [ 1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272,
+#   7777, 9999, 17344, 22222, 38962, 77778, 82656, 95121, 99999, 142857,
+#   148149, 181819, 187110, 208495, 318682, 329967, 351352, 356643, 390313,
+#   461539, 466830, 499500, 500500, 533170, 538461, 609687, 627615, 643357,
+#   648648, 670033, 681318, 791505, 812890, 818181, 851851, 857143, 961038,
+#   994708, 999999 ]
+
+Size(last);
+# 54
+
+
+IsKaprekarAndHow := function(n, base)
+	local a, b, p, q;
+	if n = 1 then
+		return true;
+	fi;
+	q := n*n;
+	p := base;
+	while p < q do
+		a := RemInt(q, p);
+		b := QuoInt(q, p);
+		if a > 0 and a + b = n then
+			return [a, b];
+		fi;
+		p := p*base;
+	od;
+	return false;
+end;
+
+IntegerToBaseRep := function(n, base)
+	local s, digit;
+	if base > 36 then
+		return fail;
+	elif n = 0 then
+		return "0";
+	else
+		s := "";
+		digit := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		while n <> 0 do
+			Add(s, digit[RemInt(n, base) + 1]);
+			n := QuoInt(n, base);
+		od;
+		return Reversed(s);
+	fi;
+end;
+
+PrintIfKaprekar := function(n, base)
+	local v;
+	v := IsKaprekarAndHow(n, base);
+	if IsList(v) then
+		Print(n, "(10) or in base ", base, ", ",
+			IntegerToBaseRep(n, base), "^2 = ",
+			IntegerToBaseRep(n^2, base), " and ",
+			IntegerToBaseRep(v[2], base), " + ",
+			IntegerToBaseRep(v[1], base), " = ",
+			IntegerToBaseRep(n, base), "\n");
+	fi;
+	return fail;
+end;
+
+# In base 17...
+Perform([1 .. 1000000], n -> PrintIfKaprekar(n, 17));
+# 16(10) or in base 17, G^2 = F1 and F + 1 = G
+# 64(10) or in base 17, 3D^2 = E2G and E + 2G = 3D
+# 225(10) or in base 17, D4^2 = A52G and A5 + 2G = D4
+# 288(10) or in base 17, GG^2 = GF01 and GF + 1 = GG
+# 1536(10) or in base 17, 556^2 = 1B43B2 and 1B4 + 3B2 = 556
+# 3377(10) or in base 17, BBB^2 = 8093B2 and 809 + 3B2 = BBB
+# 4912(10) or in base 17, GGG^2 = GGF001 and GGF + 1 = GGG
+# 7425(10) or in base 17, 18BD^2 = 24E166G and 24E + 166G = 18BD
+# 9280(10) or in base 17, 1F1F^2 = 39B1B94 and 39B + 1B94 = 1F1F
+# 16705(10) or in base 17, 36DB^2 = B992C42 and B99 + 2C42 = 36DB
+# 20736(10) or in base 17, 43CD^2 = 10DE32FG and 10DE + 32FG = 43CD
+# 30016(10) or in base 17, 61EB^2 = 23593F92 and 2359 + 3F92 = 61EB
+# 36801(10) or in base 17, 785D^2 = 351E433G and 351E + 433G = 785D
+# 37440(10) or in base 17, 7A96^2 = 37144382 and 3714 + 4382 = 7A96
+# 46081(10) or in base 17, 967B^2 = 52G94382 and 52G9 + 4382 = 967B
+# 46720(10) or in base 17, 98B4^2 = 5575433G and 5575 + 433G = 98B4
+# 53505(10) or in base 17, AF26^2 = 6GA43F92 and 6GA4 + 3F92 = AF26
+# 62785(10) or in base 17, CD44^2 = 9A5532FG and 9A55 + 32FG = CD44
+# 66816(10) or in base 17, DA36^2 = AEG42C42 and AEG4 + 2C42 = DA36
+# 74241(10) or in base 17, F1F2^2 = D75F1B94 and D75F + 1B94 = F1F2
+# 76096(10) or in base 17, F854^2 = E1F5166G and E1F5 + 166G = F854
+# 83520(10) or in base 17, GGGG^2 = GGGF0001 and GGGF + 1 = GGGG
+# 266224(10) or in base 17, 33334^2 = A2C52A07G and A2C5 + 2A07G = 33334
--- a/Task/Kaprekar-numbers/Go/kaprekar-numbers.go
+++ b/Task/Kaprekar-numbers/Go/kaprekar-numbers.go
@ -0,0 +1,74 @@
+package main
+
+import (
+    "fmt"
+    "strconv"
+)
+
+func kaprekar(n uint64, base uint64) (bool, int) {
+    order := 0
+    if n == 1 {
+        return true, -1
+    }
+
+    nn, power := n*n, uint64(1)
+    for power <= nn {
+        power *= base
+        order++
+    }
+
+    power /= base
+    order--
+    for ; power > 1; power /= base {
+        q, r := nn/power, nn%power
+        if q >= n {
+            return false, -1
+        }
+
+        if q+r == n {
+            return true, order
+        }
+
+        order--
+    }
+
+    return false, -1
+}
+
+func main() {
+    max := uint64(10000)
+    fmt.Printf("Kaprekar numbers < %d:\n", max)
+    for m := uint64(0); m < max; m++ {
+        if is, _ := kaprekar(m, 10); is {
+            fmt.Println("  ", m)
+        }
+    }
+
+    // extra credit
+    max = 1e6
+    var count int
+    for m := uint64(0); m < max; m++ {
+        if is, _ := kaprekar(m, 10); is {
+            count++
+        }
+    }
+    fmt.Printf("\nThere are %d Kaprekar numbers < %d.\n", count, max)
+
+    // extra extra credit
+    const base = 17
+    maxB := "1000000"
+    fmt.Printf("\nKaprekar numbers between 1 and %s(base %d):\n", maxB, base)
+    max, _ = strconv.ParseUint(maxB, base, 64)
+    fmt.Printf("\n Base 10  Base %d        Square       Split\n", base)
+    for m := uint64(2); m < max; m++ {
+        is, pos := kaprekar(m, base)
+        if !is {
+            continue
+        }
+        sq := strconv.FormatUint(m*m, base)
+        str := strconv.FormatUint(m, base)
+        split := len(sq)-pos
+        fmt.Printf("%8d  %7s  %12s  %6s + %s\n", m,
+            str, sq, sq[:split], sq[split:]) // optional extra extra credit
+    }
+}
--- a/Task/Kaprekar-numbers/Groovy/kaprekar-numbers.groovy
+++ b/Task/Kaprekar-numbers/Groovy/kaprekar-numbers.groovy
@ -0,0 +1,31 @@
+class Kaprekar {
+    private static String[] splitAt(String str, int idx) {
+        String[] ans = new String[2]
+        ans[0] = str.substring(0, idx)
+        if (ans[0] == "") ans[0] = "0" //parsing "" throws an exception
+        ans[1] = str.substring(idx)
+        return ans
+    }
+
+    static void main(String[] args) {
+        int count = 0
+        int base = (args.length > 0) ? Integer.parseInt(args[0]) : 10
+        for (long i = 1; i <= 1000000; i++) {
+            String sqrStr = Long.toString(i * i, base)
+            for (int j = 0; j < sqrStr.length() / 2 + 1; j++) {
+                String[] parts = splitAt(sqrStr, j)
+                if (parts[1] == "") continue
+                long firstNum = Long.parseLong(parts[0], base)
+                long secNum = Long.parseLong(parts[1], base)
+                //if the right part is all zeroes, then it will be forever, so break
+                if (secNum == 0) break
+                if (firstNum + secNum == i) {
+                    System.out.println(i + "\t" + Long.toString(i, base) + "\t" + sqrStr + "\t" + parts[0] + " + " + parts[1])
+                    count++
+                    break
+                }
+            }
+        }
+        System.out.println(count + " Kaprekar numbers < 1000000 (base 10) in base " + base)
+    }
+}
--- a/Task/Kaprekar-numbers/Haskell/kaprekar-numbers-1.hs
+++ b/Task/Kaprekar-numbers/Haskell/kaprekar-numbers-1.hs
@ -0,0 +1,42 @@
+import Text.Printf (printf)
+import Data.Maybe (mapMaybe)
+import Numeric (showIntAtBase)
+
+kaprekars :: Integer -> Integer -> [(Integer, Integer, Integer)]
+kaprekars base top = (1, 0, 1) : mapMaybe kap (filter res [2 .. top])
+  where
+    res x = x * (x - 1) `mod` (base - 1) == 0
+    kap n =
+      getSplit $
+      takeWhile (<= nn) $ dropWhile (< n) $ iterate (* toInteger base) 1
+      where
+        nn = n * n
+        getSplit [] = Nothing
+        getSplit (p:ps)
+          | p == n = Nothing
+          | q + r == n = Just (n, q, r)
+          | r > n = Nothing
+          | otherwise = getSplit ps
+          where
+            (q, r) = nn `divMod` p
+
+heading :: Int -> String
+heading = printf (h ++ d)
+  where
+    h = " #    Value (base 10)         Sum (base %d)             Square\n"
+    d = " -    ---------------         -------------             ------"
+
+printKap :: Integer -> (Int, (Integer, Integer, Integer)) -> String
+printKap b (i, (n, l, r)) =
+  printf "%2d %13s %26s %16s" i (show n) ss (base b (n * n))
+  where
+    ss = base b n ++ " = " ++ base b l ++ " + " ++ base b r
+    base b n = showIntAtBase b (("0123456789" ++ ['a' .. 'z']) !!) n ""
+
+main :: IO ()
+main = do
+  putStrLn $ heading 10
+  mapM_ (putStrLn . printKap 10) $ zip [1 ..] (kaprekars 10 1000000)
+  putStrLn ""
+  putStrLn $ heading 17
+  mapM_ (putStrLn . printKap 17) $ zip [1 ..] (kaprekars 17 1000000)
--- a/Task/Kaprekar-numbers/Haskell/kaprekar-numbers-2.hs
+++ b/Task/Kaprekar-numbers/Haskell/kaprekar-numbers-2.hs
@ -0,0 +1,50 @@
+import Control.Monad (foldM, join)
+import Data.List (group, nub, sort)
+
+primes :: [Int]
+primes = 2 : 3 : filter isPrime (scanl (+) 5 $ cycle [2, 4])
+  where
+    isPrime x = all ((0 /=) . mod x) $ takeWhile ((<= x) . join (*)) primes
+
+unitFactors :: Int -> [Int]
+unitFactors n = map product $ group $ f n $ takeWhile ((<= n) . join (*)) primes
+  where
+    f 1 [] = []
+    f n [] = [n]
+    f n (p:ps)
+      | n `mod` p == 0 = p : f (n `div` p) (p : ps)
+      | otherwise = f n ps
+
+-- all factors x of n where x and n/x are coprime
+factors :: Int -> [Int]
+factors = foldM f 1 . unitFactors
+  where
+    f x a = [x, x * a]
+
+-- modulo multiplication inverse: returns a where a x + b y == 1
+inverse :: Int -> Int -> Int
+inverse x y =
+  if a < 0
+    then a + y
+    else a
+  where
+    (a, b) = extEuclid x y
+    extEuclid _ 0 = (1, 0)
+    extEuclid x y = (t, s - q * t)
+      where
+        (s, t) = extEuclid y r
+        (q, r) = x `divMod` y
+
+kaprekars :: Int -> Int -> [Int]
+kaprekars base top =
+  nub . sort . concatMap kaps $
+  takeWhile (<= top * top `div` base ^ 2) $ (\x -> base ^ x - 1) <$> [1 ..]
+  where
+    kaps pb = filter (<= top) $ f <$> factors pb
+      where
+        f x
+          | x == pb = pb
+          | otherwise = x * inverse x (pb `div` x)
+
+main :: IO ()
+main = mapM_ print $ kaprekars 10 10000000
--- a/Task/Kaprekar-numbers/Icon/kaprekar-numbers.icon
+++ b/Task/Kaprekar-numbers/Icon/kaprekar-numbers.icon
@ -0,0 +1,11 @@
+procedure is_kaprekar(n)  #: return n if n is a kaprekar number
+if ( n = 1 ) |
+   ( n^2 ? ( n = move(1 to *&subject-1) + (0 ~= tab(0)) | fail )) then
+   return n
+end
+
+procedure main()
+every write(is_kaprekar(1 to 10000))                        # primary goal
+every (count := 0, is_kaprekar(1 to 999999), count +:= 1)   # stretch goal
+write ("Number of Kaprekar numbers less than 1000000 is ", count)
+end
--- a/Task/Kaprekar-numbers/J/kaprekar-numbers-1.j
+++ b/Task/Kaprekar-numbers/J/kaprekar-numbers-1.j
@ -0,0 +1,2 @@
+kapbase=: 0,. [ ^ 1 + [: i. 1 + [ <.@^.  >.&1
+isKap=: 1 e. ] ((0 < {:"1@]) *. [ = +/"1@]) kapbase #: *:@]
--- a/Task/Kaprekar-numbers/J/kaprekar-numbers-2.j
+++ b/Task/Kaprekar-numbers/J/kaprekar-numbers-2.j
@ -0,0 +1,2 @@
+   I. 10 isKap"0 i.1e6
+1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999 17344 22222 38962 77778 82656 95121 99999 142857 148149 181819 187110 208495 318682 329967 351352 356643 390313 461539 466830 499500 500500 533170 538461 609687 627615 643357 648648 670033 681318 791505 812890 818181 851851 857143 961038 994708 999999
--- a/Task/Kaprekar-numbers/J/kaprekar-numbers-3.j
+++ b/Task/Kaprekar-numbers/J/kaprekar-numbers-3.j
@ -0,0 +1,53 @@
+   ]K17=: I. 17 isKap"0 i.1e6
+1 16 64 225 288 1536 3377 4912 7425 9280 16705 20736 30016 36801 37440 46081 46720 53505 62785 66816 74241 76096 83520 266224
+   base=: [: (] u:@+ 39 * 57 < ]) 48 + #.inv
+   17 ([ base&.> ],*:@],] (] {:@,@#~ (0 < {:"1@]) *. [ = +/"1@]) kapbase #: *:@])"0 x:K17
+┌─────┬─────────┬─────┐
+│1    │1        │1    │
+├─────┼─────────┼─────┤
+│g    │f1       │1    │
+├─────┼─────────┼─────┤
+│3d   │e2g      │2g   │
+├─────┼─────────┼─────┤
+│d4   │a52g     │2g   │
+├─────┼─────────┼─────┤
+│gg   │gf01     │1    │
+├─────┼─────────┼─────┤
+│556  │1b43b2   │3b2  │
+├─────┼─────────┼─────┤
+│bbb  │8093b2   │3b2  │
+├─────┼─────────┼─────┤
+│ggg  │ggf001   │1    │
+├─────┼─────────┼─────┤
+│18bd │24e166g  │166g │
+├─────┼─────────┼─────┤
+│1f1f │39b1b94  │1b94 │
+├─────┼─────────┼─────┤
+│36db │b992c42  │2c42 │
+├─────┼─────────┼─────┤
+│43cd │10de32fg │32fg │
+├─────┼─────────┼─────┤
+│61eb │23593f92 │3f92 │
+├─────┼─────────┼─────┤
+│785d │351e433g │433g │
+├─────┼─────────┼─────┤
+│7a96 │37144382 │4382 │
+├─────┼─────────┼─────┤
+│967b │52g94382 │4382 │
+├─────┼─────────┼─────┤
+│98b4 │5575433g │433g │
+├─────┼─────────┼─────┤
+│af26 │6ga43f92 │3f92 │
+├─────┼─────────┼─────┤
+│cd44 │9a5532fg │32fg │
+├─────┼─────────┼─────┤
+│da36 │aeg42c42 │2c42 │
+├─────┼─────────┼─────┤
+│f1f2 │d75f1b94 │1b94 │
+├─────┼─────────┼─────┤
+│f854 │e1f5166g │166g │
+├─────┼─────────┼─────┤
+│gggg │gggf0001 │1    │
+├─────┼─────────┼─────┤
+│33334│a2c52a07g│2a07g│
+└─────┴─────────┴─────┘
--- a/Task/Kaprekar-numbers/J/kaprekar-numbers-4.j
+++ b/Task/Kaprekar-numbers/J/kaprekar-numbers-4.j
@ -0,0 +1,6 @@
+   kapbase=: 0,.10 ^ [: (<.+i.@>.)@(-:&.<:) 10 <.@^.  >.&1
+   isKapGroup=: [: +./"1 (((0 < {:"1@]) *. [ = +/"1@]) (kapbase@{: #:"2 0 ])@:*:)
+   6!:2 'a=.1, I. ([:; (<@isKapGroup/.~ 10<.@^.*:)) i.1e6'
+12.3963
+   #a
+54
--- a/Task/Kaprekar-numbers/J/kaprekar-numbers-5.j
+++ b/Task/Kaprekar-numbers/J/kaprekar-numbers-5.j
@ -0,0 +1,4 @@
+splitNum=: {. ,&(_&".) }.
+allSplits=: (i.&.<:@# splitNum"0 1 ])@":
+sumValidSplits=: +/"1@:(#~ 0 -.@e."1 ])
+filterKaprekar=: #~ ] e."0 1 [: sumValidSplits@allSplits"0 *:
--- a/Task/Kaprekar-numbers/J/kaprekar-numbers-6.j
+++ b/Task/Kaprekar-numbers/J/kaprekar-numbers-6.j
@ -0,0 +1,4 @@
+   filterKaprekar i. 10000
+0 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999
+   #filterKaprekar i. 1e6
+54
--- a/Task/Kaprekar-numbers/Java/kaprekar-numbers.java
+++ b/Task/Kaprekar-numbers/Java/kaprekar-numbers.java
@ -0,0 +1,31 @@
+public class Kaprekar {
+    private static String[] splitAt(String str, int idx){
+        String[] ans = new String[2];
+        ans[0] = str.substring(0, idx);
+        if(ans[0].equals("")) ans[0] = "0"; //parsing "" throws an exception
+        ans[1] = str.substring(idx);
+        return ans;
+    }
+
+    public static void main(String[] args){
+        int count = 0;
+        int base = (args.length > 0) ? Integer.parseInt(args[0]) : 10;
+        for(long i = 1; i <= 1000000; i++){
+            String sqrStr = Long.toString(i * i, base);
+            for(int j = 0; j < sqrStr.length() / 2 + 1; j++){
+                String[] parts = splitAt(sqrStr, j);
+                long firstNum = Long.parseLong(parts[0], base);
+                long secNum = Long.parseLong(parts[1], base);
+                //if the right part is all zeroes, then it will be forever, so break
+                if(secNum == 0) break;
+                if(firstNum + secNum == i){
+                    System.out.println(i + "\t" + Long.toString(i, base) +
+                            "\t" + sqrStr + "\t" + parts[0] + " + " + parts[1]);
+                    count++;
+                    break;
+                }
+            }
+        }
+        System.out.println(count + " Kaprekar numbers < 1000000 (base 10) in base "+base);
+    }
+}
--- a/Task/Kaprekar-numbers/JavaScript/kaprekar-numbers-1.js
+++ b/Task/Kaprekar-numbers/JavaScript/kaprekar-numbers-1.js
@ -0,0 +1,12 @@
+function isKaprekar( n, bs ) {
+	if ( n < 1 ) return false
+	if ( n == 1 ) return true
+	bs = bs || 10
+	var s = (n * n).toString(bs)
+	for (var i=1, e=s.length; i<e; i+=1) {
+		var a = parseInt(s.substr(0, i), bs)
+		var b = parseInt(s.substr(i), bs)
+		if (b && a + b == n) return true
+	}
+	return false
+}
--- a/Task/Kaprekar-numbers/JavaScript/kaprekar-numbers-2.js
+++ b/Task/Kaprekar-numbers/JavaScript/kaprekar-numbers-2.js
@ -0,0 +1,11 @@
+function isKaprekar( n, bs ) {
+	if ( n < 1 ) return false
+	if ( n == 1 ) return true
+	bs = bs || 10
+	for (var a=n*n, b=0, s=1; a; s*=bs) {
+		b += a%bs*s
+		a = Math.floor(a/bs)
+		if (b && a + b == n) return true
+	}
+	return false
+}
--- a/Task/Kaprekar-numbers/JavaScript/kaprekar-numbers-3.js
+++ b/Task/Kaprekar-numbers/JavaScript/kaprekar-numbers-3.js
@ -0,0 +1,12 @@
+function kaprekar( s, e, bs, pbs ) {
+	bs = bs || 10; pbs = pbs || 10
+	const toString = n => n.toString(pbs).toUpperCase()
+	document.write('start:',toString(s), ' end:',toString(e), ' base:',bs, ' printBase:',pbs, '<br>' )
+	for (var k=0, n=s; n<=e; n+=1) if (isKaprekar(n, bs)) k+=1, document.write(toString(n), ' ')
+	document.write('<br>found ', k, ' numbers<br><br>')
+}
+
+kaprekar( 1, 99 )
+kaprekar( 1, 255, 16)
+kaprekar( 1, 255, 16, 16)
+kaprekar( 1, 288, 17, 17)
--- a/Task/Kaprekar-numbers/Jq/kaprekar-numbers-1.jq
+++ b/Task/Kaprekar-numbers/Jq/kaprekar-numbers-1.jq
@ -0,0 +1,32 @@
+# Is the input integer a Kaprekar integer?
+def is_kaprekar:
+    # The helper function acts like a loop:
+    # input is [n, number, str]
+    # where n is the position to be considered next,
+    # number is the integer under consideration,
+    # and str is the string representing number*number
+    def _try:
+      .[0] as $n | .[1] as $number | .[2] as $str
+      | if $n >= ($str|length) then null
+        else   ($str[0:$n] | tonumber) as $left
+             | ($str[$n:]  | tonumber) as $right
+             | if $left > $number then null
+               elif $right == 0 then null
+               elif ($left + $right) == $number then $n
+               else [($n + 1), $number, $str] | _try
+               end
+        end;
+    . as $in
+    | if . == 1 then true
+      elif . < 1 then false
+      else null != ([1, $in, ($in*$in|tostring)] | _try)
+      end ;
+
+# Useful for counting how many times the condition is satisfied:
+def count(generator; condition):
+  reduce generator as $i (0; if ($i|condition ) then .+1 else . end);
+
+def task:
+  [ range(1;10000) | select( is_kaprekar ) ],
+  count( range(1;1000000); is_kaprekar )
+;
--- a/Task/Kaprekar-numbers/Jq/kaprekar-numbers-2.jq
+++ b/Task/Kaprekar-numbers/Jq/kaprekar-numbers-2.jq
@ -0,0 +1,3 @@
+$ jq -n -c -f is_kaprekar.jq
+[1,9,45,55,99,297,703,999,2223,2728,4879,4950,5050,5292,7272,7777,9999]
+54
--- a/Task/Kaprekar-numbers/Julia/kaprekar-numbers.julia
+++ b/Task/Kaprekar-numbers/Julia/kaprekar-numbers.julia
@ -0,0 +1,9 @@
+function iskaprekar(n::Integer)
+    n == 1 && return true
+    test(a, b) = n == a + b && b ≠ 0
+    str = string(n^2)
+    any(test(parse(Int, str[1:i]), parse(Int, str[i+1:end])) for i = 1:length(str)-1)
+end
+
+@show filter(iskaprekar, 1:10000)
+@show count(iskaprekar, 1:10000)
--- a/Task/Kaprekar-numbers/Kotlin/kaprekar-numbers.kotlin
+++ b/Task/Kaprekar-numbers/Kotlin/kaprekar-numbers.kotlin
@ -0,0 +1,35 @@
+import java.lang.Long.parseLong
+import java.lang.Long.toString
+
+fun String.splitAt(idx: Int): Array<String> {
+    val ans = arrayOf(substring(0, idx), substring(idx))
+    if (ans.first() == "") ans[0] = "0" // parsing "" throws an exception
+    return ans
+}
+
+fun Long.getKaprekarParts(sqrStr:  String, base: Int): Array<String>? {
+    for (j in 0..sqrStr.length / 2) {
+        val parts = sqrStr.splitAt(j)
+        val (first, second) = parts.map { parseLong(it, base) }
+
+        // if the right part is all zeroes, then it will be forever, so break
+        if (second == 0L) return null
+        if (first + second == this) return parts
+    }
+    return null
+}
+
+fun main(args: Array<String>) {
+    val base = if (args.isNotEmpty()) args[0].toInt() else 10
+    var count = 0
+    val max = 1000000L
+    for (i in 1..max) {
+        val s = toString(i * i, base)
+        val p = i.getKaprekarParts(s, base)
+        if (p != null) {
+            println("%6d\t%6s\t%12s\t%7s + %7s".format(i, toString(i, base), s, p[0], p[1]))
+            count++
+        }
+    }
+    println("$count Kaprekar numbers < $max (base 10) in base $base")
+}
--- a/Task/Kaprekar-numbers/Liberty-BASIC/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/Liberty-BASIC/kaprekar-numbers.basic
@ -0,0 +1,17 @@
+ For i = 1 To 10000  '1000000 - Changing to one million takes a long time to complete!!!!
+    Kaprekar = isKaprekar(i)
+    If Kaprekar Then numKaprekar = (numKaprekar + 1) : Print Kaprekar
+Next i
+
+Print numKaprekar
+End
+
+Function isKaprekar(num)
+    If num < 1 Then isKaprekar = 0 : Exit Function
+    If num = 1 Then isKaprekar = num : Exit Function
+    squarenum$ = str$(num ^ 2)
+    For i = 1 To Len(squarenum$)
+        If Val(Mid$(squarenum$, i)) = 0 Then isKaprekar = 0 : Exit Function
+        If (Val(Left$(squarenum$, (i - 1))) + Val(Mid$(squarenum$, i)) = num) Then isKaprekar = num : Exit Function
+    Next i
+End Function
--- a/Task/Kaprekar-numbers/Lua/kaprekar-numbers.lua
+++ b/Task/Kaprekar-numbers/Lua/kaprekar-numbers.lua
@ -0,0 +1,33 @@
+-- Return length of an integer without string conversion
+function numLength (n)
+    local length = 0
+    repeat
+        n = math.floor(n / 10)
+        length = length + 1
+    until n == 0
+    return length
+end
+
+-- Return a boolean indicating whether n is a Kaprekar number
+function isKaprekar (n)
+    if n == 1 then return true end
+    local nSquared, a, b = n * n
+    for splitPoint = 1, numLength(nSquared) - 1 do
+        a = math.floor(nSquared / 10^splitPoint)
+        b = nSquared % 10^splitPoint
+        if a > 0 and b > 0 and a + b == n then return true end
+    end
+    return false
+end
+
+-- Main task
+for n = 1, 10^4 do
+    if isKaprekar(n) then io.write(n .. " ") end
+end
+
+-- Extra credit
+local count = 0
+for n = 1, 10^6 do
+    if isKaprekar(n) then count = count + 1 end
+end
+print("\nThere are " .. count .. " Kaprekar numbers under one million.")
--- a/Task/Kaprekar-numbers/MLite/kaprekar-numbers-1.mlite
+++ b/Task/Kaprekar-numbers/MLite/kaprekar-numbers-1.mlite
@ -0,0 +1,35 @@
+local
+  val base = 10;
+  fun kaprekar
+        (num, numSquared, numDiv, numRem, power) where (base ^ power >= numSquared) = ()
+
+    |   (num, numSquared, numDiv, numRem, power) where ((numDiv = 0) or (numRem = 0))=
+          kaprekar (num, numSquared, numSquared div (base ^ power ), numSquared rem (base ^ power), power + 1)
+
+    |   (num, numSquared, numDiv, numRem, power) =
+          if ((numDiv + numRem) = num) then
+            num
+          else
+            kaprekar (num, numSquared, numSquared div (base ^ power ), numSquared rem (base ^ power), power + 1)
+
+    |   num =
+          if (num = 1) then
+            num
+          else
+            kaprekar (num, num * num, (num * num) div base, (num * num) rem base, 1)
+
+in
+  fun kaprekar_list
+       ([], collector) = rev collector
+    |  (num :: nums, collector ) =
+         let
+           val k = kaprekar num
+         in
+           if (k = ()) then
+             kaprekar_list (nums, collector)
+           else
+             kaprekar_list (nums, num :: collector)
+         end
+    |  (num :: nums) = kaprekar_list (num :: nums, [])
+end
+;
--- a/Task/Kaprekar-numbers/MLite/kaprekar-numbers-2.mlite
+++ b/Task/Kaprekar-numbers/MLite/kaprekar-numbers-2.mlite
@ -0,0 +1 @@
+print "kaprekar numbers < 10_000: "; println ` kaprekar_list (iota 10000);
--- a/Task/Kaprekar-numbers/MLite/kaprekar-numbers-3.mlite
+++ b/Task/Kaprekar-numbers/MLite/kaprekar-numbers-3.mlite
@ -0,0 +1 @@
+print "number of kaprekar numbers < 1_000_000: "; println ` len ` kaprekar_list (iota 1000000);
--- a/Task/Kaprekar-numbers/Maple/kaprekar-numbers.maple
+++ b/Task/Kaprekar-numbers/Maple/kaprekar-numbers.maple
@ -0,0 +1,26 @@
+isKaprekar := proc(n::posint)
+local holder, square, num_of_digits, k, left, right;
+holder := true;
+if n = 1 then
+ holder := true;
+else
+ holder := false;
+ square := n^2;
+ num_of_digits := length(n^2);
+ for k to num_of_digits do left := floor(square/10^k);
+     right := irem(square, 10^k);
+     if left + right = n and right <> 0 then
+        holder := true;
+     break;
+     end if;
+ end do;
+end if;
+return holder;
+end proc;
+
+showKaprekar := n -> select(isKaprekar, select(x -> irem(x, 9) = 1 or irem(x, 9) = 0, [seq(1 .. n - 1)]));
+
+countKaprekar := n -> nops(showKaprekar(n));
+
+showKaprekar(10000);
+countKaprekar(1000000);
--- a/Task/Kaprekar-numbers/Mathematica/kaprekar-numbers.math
+++ b/Task/Kaprekar-numbers/Mathematica/kaprekar-numbers.math
@ -0,0 +1,7 @@
+KaprekaQ[1] = True;
+KaprekaQ[n_Integer] :=  Block[{data = IntegerDigits[n^2], last = False, i = 1},
+  While[i < Length[data] && FromDigits[data[[i + 1 ;;]]] =!= 0 &&  Not[last],
+   last = FromDigits[data[[;; i]]] + FromDigits[data[[i + 1 ;;]]] == n;
+   i++]; last];
+Select[Range[10000], KaprekaQ]
+Length[Select[Range[1000000], KaprekaQ]]
--- a/Task/Kaprekar-numbers/Maxima/kaprekar-numbers.maxima
+++ b/Task/Kaprekar-numbers/Maxima/kaprekar-numbers.maxima
@ -0,0 +1,25 @@
+kaprekarp(n) := block(
+   [p, q, a, b],
+   if n = 1 then true else (
+      q: n * n,
+      p: 10,
+      catch(
+         while p < q do (
+            [a, b]: divide(q, p),
+            if b > 0 and a + b = n then throw(true),
+            p: 10 * p
+         ),
+         false
+      )
+   )
+)$
+
+sublist(makelist(i, i, 1, 10^6), kaprekarp);
+[1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999,
+17344, 22222, 38962, 77778, 82656, 95121, 99999, 142857, 148149, 181819, 187110, 208495,
+318682, 329967, 351352, 356643, 390313, 461539, 466830, 499500, 500500, 533170, 538461,
+609687, 627615, 643357, 648648, 670033, 681318, 791505, 812890, 818181, 851851, 857143,
+961038, 994708, 999999]
+
+length(%);
+54
--- a/Task/Kaprekar-numbers/Modula-2/kaprekar-numbers.mod2
+++ b/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.
--- a/Task/Kaprekar-numbers/Nim/kaprekar-numbers.nim
+++ b/Task/Kaprekar-numbers/Nim/kaprekar-numbers.nim
@ -0,0 +1,12 @@
+import strutils, sequtils
+
+proc k(n: int): bool =
+  let n2 = $(n.int64 * n)
+  for i in 0 .. n2.high:
+    let a = if i > 0: parseBiggestInt n2[0 ..< i] else: 0
+    let b = parseBiggestInt n2[i .. n2.high]
+    if b > 0 and a + b == n:
+      return true
+
+echo toSeq(1..10_000).filter(k)
+echo len toSeq(1..1_000_000).filter(k)
--- a/Task/Kaprekar-numbers/PARI-GP/kaprekar-numbers.parigp
+++ b/Task/Kaprekar-numbers/PARI-GP/kaprekar-numbers.parigp
@ -0,0 +1,22 @@
+K(d)={
+  my(D=10^d,DD,t,v=List());
+  for(n=D/10+1,D-1,
+    t=divrem(n^2,D);
+    if(t[2]&t[1]+t[2]==n,listput(v,n);next);
+    DD=D;
+    while(t[2]<n,
+      t=divrem(n^2,DD*=10);
+      if(t[2]&t[1]+t[2]==n,listput(v,n);next(2))
+    );
+    DD=D;
+    while(t[1]<n,
+      t=divrem(n^2,DD/=10);
+      if(t[2]&t[1]+t[2]==n,listput(v,n);next(2))
+    )
+  );
+  Vec(v)
+};
+upTo(d)=my(v=[1]);for(n=1,d,v=concat(v,K(n)));v;
+upTo(4)
+v=upTo(6);v
+#v
--- a/Task/Kaprekar-numbers/PHP/kaprekar-numbers.php
+++ b/Task/Kaprekar-numbers/PHP/kaprekar-numbers.php
@ -0,0 +1,18 @@
+set_time_limit(300);
+
+print_r(array_filter(range(1, 10000), 'isKaprekar'));
+echo count(array_filter(range(1, 1000000), 'isKaprekar'));
+
+function isKaprekar($n) {
+    $a = $n * $n;
+    $b = bcmod("$a", "10");
+    for ($d = 1, $t = 0; $a > 0; $d *= 10) {
+        $b += $t * $d;
+        if ($b > $n) break;
+        $a = floor($a / 10);
+        if ($b && $a + $b == $n)
+            return true;
+        $t = bcmod("$a", "10");
+    }
+    return false;
+}
--- a/Task/Kaprekar-numbers/PL-I/kaprekar-numbers.pli
+++ b/Task/Kaprekar-numbers/PL-I/kaprekar-numbers.pli
@ -0,0 +1,21 @@
+kaprekar: procedure options (main);  /* 22 January 2012 */
+   declare i fixed decimal (9), j fixed binary;
+   declare s character (20) character varying;
+   declare m fixed decimal (9);
+   declare (z, zeros) character (20) varying;
+
+   zeros = '00000000000000000000';
+
+   put skip list (1);
+   do i = 2 to 100000;
+      s = i*i;
+      s = trim(s);
+      z = substr(zeros, 1, length(s));
+      do j = 1 to length(s)-1;
+         if substr(s, j+1) = substr(z, j+1) then leave;
+         m = substr(s, 1, j) + substr(s, j+1);
+         if i = m then put skip list (i);
+      end;
+   end;
+
+end kaprekar;
--- a/Task/Kaprekar-numbers/Perl/kaprekar-numbers-1.pl
+++ b/Task/Kaprekar-numbers/Perl/kaprekar-numbers-1.pl
@ -0,0 +1,17 @@
+sub isKap {
+  my $k = shift;
+  return if $k*($k-1) % 9;  # Fast return "casting out nines"
+  my($k2, $p) = ($k*$k, 10);
+  do {
+    my $i = int($k2/$p);
+    my $j = $k2 % $p;
+    return 1 if $j && $i+$j == $k;
+    $p *= 10;
+  } while $p <= $k2;
+  0;
+}
+
+print "[", join(" ", grep { isKap($_) } 1..9999), "]\n\n";
+my @kaprekar;
+isKap($_) && push @kaprekar,$_ for 1..1_000_000;
+print "Kaprekar Numbers below 1000000: ", scalar(@kaprekar), "\n";
--- a/Task/Kaprekar-numbers/Perl/kaprekar-numbers-2.pl
+++ b/Task/Kaprekar-numbers/Perl/kaprekar-numbers-2.pl
@ -0,0 +1,17 @@
+use ntheory qw/fordivisors gcd invmod/;
+
+my %kap;
+for my $n (1..15) {
+  my $np = int(10**$n)-1;
+  fordivisors {
+    my($d, $dp) = ($_, $np/$_);
+    $kap{ $dp==1 ? $d : invmod($d,$dp)*$d }++
+      if  gcd($d, $dp) == 1;
+  } $np;
+}
+my @kap = sort { $a<=>$b } keys %kap;
+for my $n (6 .. 14) {
+  my $np = int(10**$n)-1;
+  printf "Kaprekar numbers <= 10^%2d:  %5d\n",
+         $n, scalar(grep { $_ <= $np } @kap);
+}
--- a/Task/Kaprekar-numbers/Phix/kaprekar-numbers.phix
+++ b/Task/Kaprekar-numbers/Phix/kaprekar-numbers.phix
@ -0,0 +1,57 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #004080;">atom</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">Kaprekar</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;">base</span><span style="color: #0000FF;">=</span><span style="color: #000000;">10</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: #004600;">true</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #004080;">atom</span> <span style="color: #000000;">sq</span><span style="color: #0000FF;">=</span><span style="color: #000000;">n</span><span style="color: #0000FF;">*</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">basen</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">base</span>
+     <span style="color: #000000;">r</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span>
+     <span style="color: #008080;">while</span> <span style="color: #000000;">r</span><span style="color: #0000FF;"><</span><span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sq</span><span style="color: #0000FF;">,</span><span style="color: #000000;">basen</span><span style="color: #0000FF;">)</span>
+         <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sq</span><span style="color: #0000FF;">/</span><span style="color: #000000;">basen</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">r</span> <span style="color: #008080;">and</span> <span style="color: #000000;">l</span> <span style="color: #008080;">and</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">+</span><span style="color: #000000;">r</span><span style="color: #0000FF;">=</span><span style="color: #000000;">n</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #004600;">true</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #000000;">basen</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">base</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #008080;">return</span> <span style="color: #004600;">false</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: #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;">10_000</span> <span style="color: #008080;">do</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">Kaprekar</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+         <span style="color: #000000;">s</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">i</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: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %d Kaprekar numbers between 1 and 10,000:\n%v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">),</span><span style="color: #000000;">s</span><span style="color: #0000FF;">})</span>
+ <span style="color: #004080;">integer</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</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;">1_000_000</span> <span style="color: #008080;">do</span>
+     <span style="color: #000000;">c</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">Kaprekar</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;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %d Kaprekar numbers between 1 and 1,000,000\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">base17</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">deep_copy</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</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: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #004080;">atom</span> <span style="color: #000000;">si</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+         <span style="color: #004080;">string</span> <span style="color: #000000;">num</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">""</span>
+         <span style="color: #008080;">while</span> <span style="color: #000000;">si</span> <span style="color: #008080;">do</span>
+             <span style="color: #004080;">integer</span> <span style="color: #000000;">digit</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">si</span><span style="color: #0000FF;">,</span><span style="color: #000000;">17</span><span style="color: #0000FF;">)</span>
+             <span style="color: #000000;">si</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">si</span><span style="color: #0000FF;">/</span><span style="color: #000000;">17</span><span style="color: #0000FF;">)</span>
+             <span style="color: #000000;">num</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">digit</span><span style="color: #0000FF;">+</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">digit</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">9</span><span style="color: #0000FF;">?</span><span style="color: #008000;">'0'</span><span style="color: #0000FF;">:</span><span style="color: #000000;">87</span><span style="color: #0000FF;">)&</span><span style="color: #000000;">num</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+         <span style="color: #000000;">s</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;">num</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">s</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span> <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span> <span style="color: #000000;">l</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</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;">1_000_000</span> <span style="color: #008080;">do</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">Kaprekar</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">17</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</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: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">*</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">l</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</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: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"There are %d Kaprekar base 17 numbers between 1 and 1,000,000 (decimal):\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
+ <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">5</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">5</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</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: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</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;">"%s squared %s, split %s+%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">base17</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]))</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">4</span> <span style="color: #008080;">then</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;">" ...\n"</span><span style="color: #0000FF;">)</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>
+<!--
--- a/Task/Kaprekar-numbers/Phixmonti/kaprekar-numbers.phixmonti
+++ b/Task/Kaprekar-numbers/Phixmonti/kaprekar-numbers.phixmonti
@ -0,0 +1,18 @@
+def FNkaprekar
+    var n
+    dup 2 power var s
+    s log int 1 + 10 swap power var t
+    true while
+        t 10 / var t
+        t n <= IF false else
+            s n - s t / int t 1 - * == IF false 1 var n else TRUE endif
+        endif
+    endwhile
+    n 1 ==
+enddef
+
+0
+10000 FOR
+     dup FNkaprekar IF print " " print 1 + else drop endif
+endfor
+nl print " Kaprekar numbers" print
--- a/Task/Kaprekar-numbers/Picat/kaprekar-numbers.picat
+++ b/Task/Kaprekar-numbers/Picat/kaprekar-numbers.picat
@ -0,0 +1,47 @@
+go =>
+  println(base=10),
+  println(kaprekar_number(10,10000)),
+  nl,
+  println("Testing 1000000:"),
+
+  K10 = kaprekar_number(10,1000000),
+  % println(K10),
+  nl,
+  println(base=16),
+  K16 = [I.to_hex_string() : I in kaprekar_number(16,1000000)],
+  % println(K16),
+  nl,
+
+  println(base=17),
+  K17 = [to_radix_string(I,17).to_lowercase : I in  kaprekar_number(17,1000000)],
+  % println(K17),
+  nl,
+
+  println(base=36),
+  K36 = [to_radix_string(I,36) : I in  kaprekar_number(36,1000000)],
+  % println(K36),
+
+  nl.
+
+kaprekar_number(Base,Limit) = Ks =>
+  N = ceiling(log(Base,Limit)),
+  PaddyCnt = 0,
+  Ks = [],
+  foreach(Nz in 1..N)
+    foreach(K in Base**(Nz-1)..(Base**Nz)-1, K <= Limit)
+       if (K*(K-1)) mod (Base-1) == 0 then
+          Found = false,
+	  foreach(N2 in Nz..Nz*2-1,Found = false)
+ 	     B = Base**N2,
+	     Nr = K*(B-K) div (B-1),
+	     Q = K-Nr,
+	     if K*K==Q*B+Nr, 0<Nr then
+                PaddyCnt := PaddyCnt+1,
+                Ks := Ks ++ [K],
+		Found := true
+	     end
+          end
+       end
+    end
+  end,
+  println(len=Ks.length).
--- a/Task/Kaprekar-numbers/PicoLisp/kaprekar-numbers.l
+++ b/Task/Kaprekar-numbers/PicoLisp/kaprekar-numbers.l
@ -0,0 +1,5 @@
+(de kaprekar (N)
+   (let L (cons 0 (chop (* N N)))
+      (for ((I . R) (cdr L) R (cdr R))
+         (NIL (gt0 (format R)))
+         (T (= N (+ @ (format (head I L)))) N) ) ) )
--- a/Task/Kaprekar-numbers/PowerShell/kaprekar-numbers-1.psh
+++ b/Task/Kaprekar-numbers/PowerShell/kaprekar-numbers-1.psh
@ -0,0 +1,25 @@
+function Test-Kaprekar ([int]$Number)
+{
+    if ($Number -eq 1)
+    {
+        return $true
+    }
+
+    [int64]$a = $Number * $Number
+    [int64]$b = 10
+
+    while ($b -lt $a)
+    {
+        [int64]$remainder = $a % $b
+        [int64]$quotient  = ($a - $remainder) / $b
+
+        if ($remainder -gt 0 -and $remainder + $quotient -eq $Number)
+        {
+            return $true
+        }
+
+        $b *= 10
+    }
+
+    return $false
+}
--- a/Task/Kaprekar-numbers/PowerShell/kaprekar-numbers-2.psh
+++ b/Task/Kaprekar-numbers/PowerShell/kaprekar-numbers-2.psh
@ -0,0 +1,5 @@
+"Kaprekar numbers less than 10,000:"
+1..10000 | ForEach-Object {if (Test-Kaprekar -Number $_) {"{0,6}" -f $_}} | Format-Wide {$_} -Column 17 -Force
+
+"Kaprekar numbers less than 1,000,000:"
+1..1000000 | ForEach-Object {if (Test-Kaprekar -Number $_) {"{0,6}" -f $_}} | Format-Wide {$_} -Column 18 -Force
--- a/Task/Kaprekar-numbers/Prolog/kaprekar-numbers.pro
+++ b/Task/Kaprekar-numbers/Prolog/kaprekar-numbers.pro
@ -0,0 +1,12 @@
+kaprekar_(Z, X) :-
+	split_number(Z, 10, X).
+
+
+split_number(Z, N, X) :-
+	N < Z,
+	A is Z // N,
+	B is Z mod N,
+	(   (X is A+B,  B\= 0)-> true; N1 is N*10, split_number(Z, N1, X)).
+
+kaprekar(N, V) :-
+	V <- {X & X <- 1 .. N & ((Z is X * X, kaprekar_(Z, X)); X = 1) }.
--- a/Task/Kaprekar-numbers/PureBasic/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/PureBasic/kaprekar-numbers.basic
@ -0,0 +1,27 @@
+Procedure Kaprekar(n.i)
+  nn.q  = n*n
+  tens.q= 1
+  While tens<nn: tens*10: Wend
+  Repeat
+    tens/10
+    If tens<=n: Break: EndIf
+    If nn-n = (nn/tens) * (tens-1)
+      ProcedureReturn #True
+    EndIf
+  ForEver
+  If n=1
+    ProcedureReturn #True
+  EndIf
+EndProcedure
+
+If OpenConsole()
+  For i=1 To 1000000
+    If Kaprekar(i)
+      cnt+1
+      PrintN(RSet(Str(cnt),3)+":"+RSet(Str(i),8))
+    EndIf
+  Next
+  ;
+  Print("Press ENTER to exit")
+  Input()
+EndIf
--- a/Task/Kaprekar-numbers/Python/kaprekar-numbers-1.py
+++ b/Task/Kaprekar-numbers/Python/kaprekar-numbers-1.py
@ -0,0 +1,14 @@
+>>> def k(n):
+	n2 = str(n**2)
+	for i in range(len(n2)):
+		a, b = int(n2[:i] or 0), int(n2[i:])
+		if b and a + b == n:
+			return n
+			#return (n, (n2[:i], n2[i:]))
+
+		
+>>> [x for x in range(1,10000) if k(x)]
+[1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]
+>>> len([x for x in range(1,1000000) if k(x)])
+54
+>>>
--- a/Task/Kaprekar-numbers/Python/kaprekar-numbers-2.py
+++ b/Task/Kaprekar-numbers/Python/kaprekar-numbers-2.py
@ -0,0 +1,29 @@
+def encode(n, base):
+    result = ""
+    while n:
+        n, d = divmod(n, base)
+        if d < 10:
+            result += str(d)
+        else:
+            result += chr(d - 10 + ord("a"))
+    return result[::-1]
+def Kaprekar(n, base):
+    if n == '1':
+        return True
+    sq = encode((int(n, base)**2), base)
+    for i in range(1,len(sq)):
+        if (int(sq[:i], base) + int(sq[i:], base) == int(n, base)) and (int(sq[:i], base) > 0) and (int(sq[i:], base)>0):
+            return True
+    return False
+def Find(m, n, base):
+    return [encode(i, base) for i in range(m,n+1) if Kaprekar(encode(i, base), base)]
+
+m = int(raw_input('Where to start?\n'))
+n = int(raw_input('Where to stop?\n'))
+base = int(raw_input('Enter base:'))
+KNumbers = Find(m, n, base)
+for i in KNumbers:
+    print i
+print 'The number of Kaprekar Numbers found are',
+print len(KNumbers)
+raw_input()
--- a/Task/Kaprekar-numbers/Python/kaprekar-numbers-3.py
+++ b/Task/Kaprekar-numbers/Python/kaprekar-numbers-3.py
@ -0,0 +1,11 @@
+Base = 10
+N = 6
+Paddy_cnt = 1
+for n in range(N):
+  for V in CastOut(Base,Start=Base**n,End=Base**(n+1)):
+    for B in range(n+1,n*2+2):
+      x,y = divmod(V*V,Base**B)
+      if V == x+y and 0<y:
+        print('{1}: {0}'.format(V, Paddy_cnt))
+        Paddy_cnt += 1
+        break
--- a/Task/Kaprekar-numbers/Python/kaprekar-numbers-4.py
+++ b/Task/Kaprekar-numbers/Python/kaprekar-numbers-4.py
@ -0,0 +1,10 @@
+Base = 16
+N = 4
+Paddy_cnt = 1
+for V in CastOut(Base,Start=1,End=Base**N):
+  for B in range(1,N*2-1):
+    x,y = divmod(V*V,Base**B)
+    if V == x+y and 0<y:
+      print('{1}: {0:x}'.format(V, Paddy_cnt))
+      Paddy_cnt += 1
+      break
--- a/Task/Kaprekar-numbers/Quackery/kaprekar-numbers.quackery
+++ b/Task/Kaprekar-numbers/Quackery/kaprekar-numbers.quackery
@ -0,0 +1,41 @@
+  [ dup 1 = if done
+    dup temp put
+    dup *
+    false swap 1
+    [ base share *
+      2dup /mod
+      over 0 = iff
+        2drop done
+      dup 0 = iff
+        2drop again
+      + temp share = iff
+        [ rot not unrot ]
+        done
+      again ]
+    2drop
+    temp release ]        is kaprekar ( n --> b )
+
+  say "Kaprekar numbers less than one thousand: "
+  []
+  1000 times
+    [ i^ kaprekar if
+      [ i^ join ] ]
+  echo cr cr
+
+  say "Number of Kaprekar numbers less than one million: "
+  0
+  1000000 times
+    [ i^ kaprekar if 1+ ]
+  echo cr cr
+
+  say "Base 17 Kaprekar numbers less than one million." cr cr
+  17 base put
+    []
+  1000000 times
+    [ i^ kaprekar if
+      [ i^ join ] ]
+  say "In base 17: "
+  dup echo cr
+  base release
+  say "In decimal: "
+  echo
--- a/Task/Kaprekar-numbers/REXX/kaprekar-numbers.rexx
+++ b/Task/Kaprekar-numbers/REXX/kaprekar-numbers.rexx
@ -0,0 +1,26 @@
+/*REXX pgm generates & counts (& maybe shows) some Kaprekar #s using the cast─out─9 test*/
+parse arg A B .                                  /*obtain optional arguments from the CL*/
+if A=='' | A=","  then A=    10000               /*Not specified?  Then use the default.*/
+if B=='' | B=","  then B= -1000000               /* "      "         "   "   "     "    */
+call Kaprekar          A                         /*gen Kaprekar numbers and display 'em.*/
+call Kaprekar          B                         /* "     "        "   don't    "     " */
+exit 0                                           /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+Kaprekar: procedure; parse arg N;  aN= abs(N)    /*obtain the limit;   use  │N│  value. */
+          numeric digits max(9, 2 * length(aN) ) /*use enough decimal digits for square.*/
+          d= digits();         tell= N>0         /*set D to number of digits;  set TELL.*/
+          #= 0;       if aN>0  then do;    #= 1;    if tell  then say right(1, d);    end
+                                                 /* [↑]  handle case of  N  being unity.*/
+          if aN>1  then do j=9  for aN-9;        /*calculate the  square  of  J   (S).  */
+                        jc= j//9                 /*JC:   J modulo 9   (cast out nines). */
+                        if jc >2  then iterate   /*Is  J mod 9 > two?  Then skip this J.*/
+                        s= j*j                   /*calculate the  square  of  J   (S).  */
+                        if jc==s//9  then do k=1  for length(s)%2   /*≡ casted out 9's? */
+                                          parse var    s      L   +(k)   R
+                                          if j\==L+R  then iterate
+                                          #= # + 1;   if tell  then say right(j, d); leave
+                                          end   /*k*/
+                        end   /*j*/
+          say
+          say center(" There're "     #     ' Kaprekar numbers below '     aN" ", 79, "═")
+          return
--- a/Task/Kaprekar-numbers/Racket/kaprekar-numbers.rkt
+++ b/Task/Kaprekar-numbers/Racket/kaprekar-numbers.rkt
@ -0,0 +1,11 @@
+#lang racket
+(define (kaprekar? n)
+  (or (= n 1)
+      (let ([q (sqr n)])
+        (let loop ((p 10))
+          (and (<= p q)
+               (or (let-values  ([(b a) (quotient/remainder q p)])
+                     (and (> a 0) (= n (+ a b))))
+                   (loop (* p 10))))))))
+
+(filter kaprekar? (range 1 10000))
--- a/Task/Kaprekar-numbers/Raku/kaprekar-numbers-1.raku
+++ b/Task/Kaprekar-numbers/Raku/kaprekar-numbers-1.raku
@ -0,0 +1,13 @@
+sub kaprekar( Int $n ) {
+    my $sq = $n ** 2;
+    for 0 ^..^ $sq.chars -> $i {
+        my $x = +$sq.substr(0, $i);
+        my $y = +$sq.substr($i) || return;
+        return True if $x + $y == $n;
+    }
+    False;
+}
+
+print 1;
+print " $_" if .&kaprekar for ^10000;
+print "\n";
--- a/Task/Kaprekar-numbers/Raku/kaprekar-numbers-2.raku
+++ b/Task/Kaprekar-numbers/Raku/kaprekar-numbers-2.raku
@ -0,0 +1,32 @@
+sub kaprekar( Int $n, Int :$base = 10 ) {
+    my $hi = $n ** 2;
+    my $lo = 0;
+    loop (my $s = 1; $hi; $s *= $base) {
+        $lo += ($hi % $base) * $s;
+        $hi div= $base;
+        return $hi,$lo if $lo + $hi == $n and $lo;
+    }
+    ();
+}
+
+print " $_" if .&kaprekar for ^10_000;
+
+my atomicint $n;
+(^1_000_000).race.map: { $n++ if kaprekar $_ }
+say "\n\nBase 10 Kaprekar numbers < :10<1_000_000> = $n";
+
+say "\nBase 17 Kaprekar numbers < :17<1_000_000>";
+
+my &k17 = &kaprekar.assuming(:base(17));
+
+my @results;
+(^:17<1_000_000>).race.map: -> $n {
+    my ($h,$l) = k17 $n;
+    next unless $l;
+    my $n17 = $n.base(17);
+    my $s17 = ($n * $n).base(17);
+    my $h17 = $h.base(17);
+    @results.push: "$n $n17 $s17 ($h17 + $s17.substr(* - max(1,($s17.chars - $h17.chars))))";
+}
+
+.say for @results.sort: *.chars;
--- a/Task/Kaprekar-numbers/Raku/kaprekar-numbers-3.raku
+++ b/Task/Kaprekar-numbers/Raku/kaprekar-numbers-3.raku
@ -0,0 +1,41 @@
+sub kaprekar-generator( :$base = 10 ) {
+    my $base-m1 = $base - 1;
+    gather loop (my $place = 1; ; ++$place) {
+        my $nend = $base ** $place;
+        loop (my $n = $base ** ($place - 1); $n < $nend; ++$n) {
+            if $n * ($n - 1) %% $base-m1 {
+                my $pend = $place * 2;
+                loop (my $p = $place; $p < $pend; ++$p) {
+                    my $B = $base ** $p;
+                    my $lo = $n * ($B - $n) div ($B - 1);
+                    my $hi = floor $n - $lo;
+                    if $n * $n == $hi * $B + $lo and $lo {
+                        take [$n, $hi, $lo];
+                        last;
+                    }
+                }
+            }
+        }
+    }
+}
+
+print " $_[0]" for kaprekar-generator() ...^ *.[0] >= 10_000;
+say "\n";
+
+say "Base 10 Kaprekar numbers < :10<1_000_000> = ", +(kaprekar-generator() ...^ *.[0] >= 1000000);
+say '';
+
+say "Base 17 Kaprekar numbers < :17<1_000_000>";
+
+my &k17-gen = &kaprekar-generator.assuming(:base(17));
+
+for k17-gen() ...^ *.[0] >= :17<1000000> -> @r {
+    my ($n,$h,$l) = @r;
+    my $n17 = $n.base(17);
+    my $s = $n * $n;
+    my $s17 = $s.base(17);
+    my $h17 = $h.base(17);
+    my $l17 = $l.base(17);
+    $l17 = '0' x ($s17.chars - $h17.chars - $l17.chars) ~ $l17;
+    say "$n $n17 $s17 ($h17 + $l17)";
+}
--- a/Task/Kaprekar-numbers/Ring/kaprekar-numbers.ring
+++ b/Task/Kaprekar-numbers/Ring/kaprekar-numbers.ring
@ -0,0 +1,18 @@
+nr = 0
+for i = 1 to 200
+    if kaprekar(i)
+       nr += 1
+       if i < 201 see "" + nr + " : " + i + nl ok ok
+next
+see "total kaprekar numbers under 200 = " + nr + nl
+
+func kaprekar n
+     s = pow(n,2)
+     x = floor(log(s)) + 1
+     t = pow(10,x)
+     while true
+           t /= 10
+           if t<=n exit ok
+           if s-n = floor(s/t)*(t-1) n = true ok
+     end
+     return (n = 1)
--- a/Task/Kaprekar-numbers/Ruby/kaprekar-numbers.rb
+++ b/Task/Kaprekar-numbers/Ruby/kaprekar-numbers.rb
@ -0,0 +1,32 @@
+def kaprekar(n, base = 10)
+  return [1, 1, 1, ""] if n == 1
+  return if n*(n-1) % (base-1) != 0     # casting out nine
+  sqr = (n ** 2).to_s(base)
+  (1...sqr.length).each do |i|
+    a = sqr[0 ... i]
+    b = sqr[i .. -1]
+    break if b.delete("0").empty?
+    sum = a.to_i(base) + b.to_i(base)
+    return n.to_s(base), sqr, a, b if sum == n
+  end
+  nil
+end
+
+count = 0
+1.upto(10_000 - 1) do |i|
+  if result = kaprekar(i)
+    puts "%4d  %8d  %s + %s" % result
+    count += 1
+  end
+end
+
+10_000.upto(1_000_000 - 1) {|i| count += 1 if kaprekar(i)}
+puts "#{count} kaprekar numbers under 1,000,000"
+
+puts "\nbase17 kaprekar numbers under (base10)1,000,000"
+base = 17
+1.upto(1_000_000) do |decimal|
+  if result = kaprekar(decimal, base)
+    puts "%7s  %5s  %9s  %s + %s" % [decimal, *result]
+  end
+end
--- a/Task/Kaprekar-numbers/Run-BASIC/kaprekar-numbers.basic
+++ b/Task/Kaprekar-numbers/Run-BASIC/kaprekar-numbers.basic
@ -0,0 +1,7 @@
+for i   = 1 to 5000
+  x$    = str$(i * i)
+  if i  = 1 then x$ = "10"
+  for j = 1 to len(x$) - 1
+   if (val(left$(x$,j)) + val(mid$(x$,j+1)) = i and val(mid$(x$,j+1)) <> 0) or i = 1  then print "Kaprekar :";left$(x$,j);" + ";mid$(x$,j+1);" = ";i
+  next j
+next i
--- a/Task/Kaprekar-numbers/SPL/kaprekar-numbers.spl
+++ b/Task/Kaprekar-numbers/SPL/kaprekar-numbers.spl
@ -0,0 +1,20 @@
+kap,n = getkap(1000000)
+> i, 1..n
+  << kap[i]!<10000
+  #.output(kap[i])
+<
+#.output(n," Kaprekar numbers < 1000000")
+
+getkap(x)=
+  > k, 1..x
+    n = #.lower(#.log10(k^2))+1
+    > i, 1..n
+      r = k^2%10^i
+      << r>k
+      >> r=0
+      l = #.lower(k^2/10^i)
+      ? r+l=k, kap[#.size(kap,1)+1] = k
+    <
+  <
+  <= kap,#.size(kap,1)
+.
--- a/Task/Kaprekar-numbers/Scala/kaprekar-numbers.scala
+++ b/Task/Kaprekar-numbers/Scala/kaprekar-numbers.scala
@ -0,0 +1,39 @@
+object Kaprekar extends App {
+
+  def isKaprekar(n: Int, base: Int = 10):Option[Triple[String,String,String]] = {
+    val check: Long => Option[Triple[String,String,String]] = n => {
+      val split: Pair[String, Int] => Pair[String, String] = p => (p._1.slice(0,p._2),p._1.slice(p._2,p._1.size).padTo[Char,String](1,'0'))
+      val pwr = n*n
+      val sN = java.lang.Long.toString(n, base)
+      val sPwr = java.lang.Long.toString(pwr, base)
+      for (i <- 1 to sPwr.size) {
+        val (a, b) = split(sPwr,i)
+        val la = java.lang.Long.parseLong(a, base)
+        val lb = java.lang.Long.parseLong(b, base)
+        if (lb==0) return None
+        if (la+lb==n) return Some(Triple(sPwr,a,b))
+      }
+      None
+    }
+    n match {
+      case 1 => Some(Triple("1","0","1"))
+      case n if (n>1) => check(n)
+      case _ => None
+    }
+  }
+
+  def kaprekars(n: Int,base: Int=10) = (1 to n).map(isKaprekar(_,base)).zip(1 to n).filter(_._1!=None).map(p=>Triple(base,p._2,p._1 match {case Some(t) => t; case _ => Nil}))
+
+  val k1 = kaprekars(10000)
+  k1 foreach {p=>println(p._2)}
+  println(k1.size + " Kaprekar numbers < 10000 (b:10) for base 10"+"\n"*2)
+
+  val k2 = kaprekars(1000000)
+  k2 foreach {p => println(p._2+"\t"+java.lang.Long.toString(p._2,p._1)+"\t"+p._3.productElement(0)+"\t"+p._3.productElement(1)+" + "+p._3.productElement(2))}
+  println(k2.size + " Kaprekar numbers < 1000000 (b:10) for base 10"+"\n"*2)
+
+  val k3 = kaprekars(1000000,17)
+  k3 foreach {p => println(p._2+"\t"+java.lang.Long.toString(p._2,p._1)+"\t"+p._3.productElement(0)+"\t"+p._3.productElement(1)+" + "+p._3.productElement(2))}
+  println(k3.size + " Kaprekar numbers < 1000000 (b:10) for base 17"+"\n"*2)
+
+}
--- a/Task/Kaprekar-numbers/Scheme/kaprekar-numbers.ss
+++ b/Task/Kaprekar-numbers/Scheme/kaprekar-numbers.ss
@ -0,0 +1,27 @@
+; auxiliary functions : range, filter
+(define (range a b)
+(let loop ((v '()) (i b))
+(if (< i a)
+    v
+    (loop (cons i v)
+          (- i 1)))))
+
+(define (filter p u)
+(if (equal? u '())
+    '()
+    (let ((x (car u)) (v (filter p (cdr u))))
+         (if (p x)
+             (cons x v)
+             v))))
+
+(define (kaprekar? n)
+(or (= n 1)
+    (let ((q (* n n)))
+    (let loop ((p 10))
+         (cond ((> p q) #f)
+               ((let ((a (remainder q p)) (b (quotient q p)))
+                     (and (> a 0) (= n (+ a b)))) #t)
+               (else (loop (* p 10))))))))
+
+(filter kaprekar? (range 1 10000))
+; (1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999)
--- a/Show more
+++ b/Show more
				`@ -0,0 +1 @@`
				print "kaprekar numbers < 10_000: "; println ` kaprekar_list (iota 10000);
				`@ -0,0 +1 @@`
				print "number of kaprekar numbers < 1_000_000: "; println ` len ` kaprekar_list (iota 1000000);