Kaprekar numbers: Difference between revisions

*   [[Casting out nines]]

<br><br>

 

=={{header|360 Assembly}}==

{{trans|PL/I}}

KAPREKAR CSECT

USING KAPREKAR,R13 base register

PG DC CL80' ' buffer

YREGS

{{out}}

<pre>

so i chose base 17 (17 ** 6).

 

with Ada.Strings.Fixed;

 

end loop;

Ada.Text_IO.Put_Line (" Total:" & Integer'Image (Count));

 

{{out}}

 

=={{header|ALGOL 68}}==

 

# returns TRUE if n is a Kaprekar number, FALSE otherwise #

print( ( newline ) );

print( ( "There are ", whole( k count, 0 ), " Kaprekar numbers below ", whole( max number, 0 ), newline ) )

{{out}}

<pre>

There are 54 Kaprekar numbers below 1000000

</pre>

 

=={{header|AutoHotkey}}==

Function:

Loop, % L + ( C := 0 ) {

S := ( N := A_Index ) ** 2

}

Return C " Kaprekar numbers in [1-" L "]:`n" SubStr(R,3)

Usage:

{{out}}

<pre>17 Kaprekar numbers in [1-10000]:

 

=={{header|AWK}}==

# syntax: GAWK -f KAPREKAR_NUMBERS.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

 

=={{header|Batch File}}==

@echo off

setlocal enabledelayedexpansion

set /a tempcount+=1

goto lengthloop

{{out}}

<pre>

</pre>

 

{{works with|BBC BASIC for Windows}}

n% = 0

FOR i% = 1 TO 999999

IF s-n = INT(s/t)*(t-1) THEN = TRUE

UNTIL FALSE

{{out}}

<pre>

 

=={{header|Bracmat}}==

& 1:?count

& out$(!count 1)

)

& out$(str$("There are " !count " kaprekar numbers less than 1000000"))

{{out}}

<pre>1 1

 

=={{header|Brat}}==

results = []

 

 

p "Number of Kaprekar numbers below 1,000,000:"

 

{{out}}

=={{header|C}}==

Sample for extra extra credit:

#include <stdint.h>

typedef uint64_t ulong;

 

return 0;

{{out}}

<pre>base 10:

===Factorization===

Kaprekar numbers for base <math>b</math> can be directly generated by factorization of <math>b^n - 1</math> and multiplicative inverse of its unitary divisors. The speed largely depends on how easy the factorization part is, though it's not a problem for relatively small numbers (up to 32-bits, for example).

#include <stdlib.h>

#include <stdint.h>

 

return 0;

 

=={{header|C sharp}}==

using System.Collections.Generic;

 

}

 

 

{{out}}

=={{header|C++}}==

===Using String Manipulation (very slow)===

#include <string>

#include <iostream>

<< " Kaprekar numbers less than one million!\n" ;

return 0 ;

{{out}}

<pre>Kaprekar numbers up to 10000:

The code <code>"if ((k*(k-1))%(Base-1) == 0)"</code> is explained here: [[Casting out nines]].

 

// Generate Kaperkar Numbers

//

return 0;

}

Produces:

<pre>1: 1 is 0 + 1 and squared is 1. It is a member of Residual Set 1

54: 999999 is 999998 + 1 and squared is 999998000001. It is a member of Residual Set 0</pre>

The code may be modified to use a base other than 10:

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";

Which produces:

<pre>1: 1 is 0 + 1 and squared is 1. It is a member of Residual Set 1

===Casting Out Nines C++11 For Each Generator (v.fast)===

For details of ran and co9 see: http://rosettacode.org/wiki/Casting_out_nines#C.2B.2B11_For_Each_Generator

//

// Nigel Galloway. July 13th., 2012

const double nr = k*(B-k)/(B-1);

const int q = k-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;

Produces:

<pre>1: 1 is 0 + 1 and squared is 1. It is a member of Residual Set 1

54: 999999 is 999998 + 1 and squared is 999998000001. It is a member of Residual Set 0</pre>

Changing main:

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";

Produces:

<pre>1: 1 is 0 + 1 and squared is 1. It is a member of Residual Set 1

40: e6e6 is d042 + 16a4 and squared is d04216a4. It is a member of Residual Set a

41: ffff is fffe + 1 and squared is fffe0001. It is a member of Residual Set 0</pre>

 

=={{header|CoffeeScript}}==

{{trans|Kotlin}}

ans = [ str.substring(0, idx), str.substring(idx) ]

if ans[0] == ""

console.log i, i.toString(base), s, p.join '+'

count++

{{out}}

<pre>1 '1' '1' '0+1'

=={{header|Common Lisp}}==

=== Fast solution using casting out nines filter ===

;; numbers n where n mod (base - 1) == n^2 mod (base - 1)

(defun res-list (base)

(terpri)

(ktest 1000000 17)

{{out}}

<pre>

</pre>

===In the style of the C++ generator===

;; Generate Kaprekar Numbers using Casting Out Nines Generator

;;

(format t "~3d: ~8d is ~8d + ~8d and squared is ~8d~&" (incf Paddy_cnt) N q nr kk))

(if (> B kk) (return)))))))))))))

{{out}}

<pre>

=={{header|D}}==

===Straightforward Version===

 

bool isKaprekar(in long n) pure /*nothrow*/ @safe

iota(1, 10_000).filter!isKaprekar.writeln;

iota(1, 1_000_000).count!isKaprekar.writeln;

{{out}}

<pre>[1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]

===Faster Version===

Right to left:

ulong powr = n ^^ 2UL;

ulong r, l, tens = 10;

if (i.isKaprekar)

writefln("%d: %d", count++, i);

{{out}}

<pre>1: 1

53: 994708

54: 999999</pre>

 

=={{header|Dart}}==

import 'dart:math';

void main()

 

 

 

=={{header|Elixir}}==

{{trans|Ruby}}

def check(n), do: check(n, 10)

:io.fwrite "~7w ~5s ~9s ~s + ~s~n", [n, Integer.to_string(n,base), a<>b, a, b]

end

 

{{out}}

 

=={{header|Erlang}}==

-mode(compile).

-import(lists, [seq/2]).

CountTo1e6 = length(Numbers) + length([N || N <- seq(10001, 999999), kaprekar(N)]),

io:format("There are ~p Kaprekar numbers < 1,000,000", [CountTo1e6]).

{{out}}

<pre>

{{incorrect|Euler Math Toolbox|4950 and 5050 are missing because j=0 should not return in the loop.}}

 

>function map kaprekarp (n) ...

$ m=n*n;

[ 1 9 45 55 99 297 703 999 2223 2728 4879 5292 7272 7777

9999 17344 22222 38962 77778 82656 95121 99999 ]

 

=={{header|F Sharp}}==

 

// Count digits in number

let digits x =

[1 .. 10000]

|> List.filter (float >> isKaprekar)

 

=={{header|Factor}}==

This solution is based on the following Haskell code: [https://dev.to/heikodudzus/comment/1cl6].

math.ranges prettyprint sequences ;

 

 

1,000,000 [1,b] [ kaprekar? ] filter dup . length

{{out}}

<pre>

=={{header|Forth}}==

This one takes the internal Forth variable BASE into account. Since Forth is perfectly suited to work with any base between 2 and 36, this works just fine.

 

\ Return nonzero if n is a Kaprekar number for tens, where tens is a

repeat

r> drop 1 = and ;

 

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

if (printnums .eqv. .false.) write(*, "(i0)") c

end subroutine

{{out}}

<pre>1

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Kaprekar numbers below 10000

 

54 numbers below 1000000 are Kaprekar numbers</pre>

 

=={{header|GAP}}==

local a, b, p, q;

if n = 1 then

# 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

 

=={{header|Go}}==

Using the Ada interpretation of 1000000 base 17:

 

import (

str, sq, sq[:split], sq[split:]) // optional extra extra credit

}

{{out}}

<pre>Kaprekar numbers < 10000:

=={{header|Groovy}}==

{{trans|Java}}

private static String[] splitAt(String str, int idx) {

String[] ans = new String[2]

System.out.println(count + " Kaprekar numbers < 1000000 (base 10) in base " + base)

}

{{out}}

<pre>1 1 1 0 + 1

 

=={{header|Haskell}}==

import Data.Maybe (mapMaybe)

import Numeric (showIntAtBase)

putStrLn ""

putStrLn $ heading 17

{{out}}

<pre> # Value (base 10) Sum (base 10) Square

 

Generating Kaprekar numbers by factorizing b^n - 1:

import Data.List (group, nub, sort)

 

 

main :: IO ()

 

=={{header|Icon}} and {{header|Unicon}}==

 

if ( n = 1 ) |

( n^2 ? ( n = move(1 to *&subject-1) + (0 ~= tab(0)) | fail )) then

every (count := 0, is_kaprekar(1 to 999999), count +:= 1) # stretch goal

write ("Number of Kaprekar numbers less than 1000000 is ", count)

 

{{out}}

=={{header|J}}==

'''Solution:'''

 

Example use:

 

 

"Extra credit": (text representing numbers left in boxes for alignment purposes)

]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

├─────┼─────────┼─────┤

│33334│a2c52a07g│2a07g│

 

The fastest times can be obtained by two optimizations: first, partitions with over half of the digits on the left (i.e. more than 3 for a 5-digit number) will not be considered because the left half is mathematically guaranteed to be greater than the original number in this case. Second, the numbers are computed in groups corresponding to the number of digits in their squares to allow isKap to be computed at full rank. Note that this method excludes 1, so it must be added manually to the list of solutions.

isKapGroup=: [: +./"1 (((0 < {:"1@]) *. [ = +/"1@]) (kapbase@{: #:"2 0 ])@:*:)

6!:2 'a=.1, I. ([:; (<@isKapGroup/.~ 10<.@^.*:)) i.1e6'

12.3963

#a

 

'''Alternative solution:'''

The following is a more naive, mechanical solution

allSplits=: (i.&.<:@# splitNum"0 1 ])@":

sumValidSplits=: +/"1@:(#~ 0 -.@e."1 ])

 

Example use:

0 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999

#filterKaprekar i. 1e6

 

=={{header|Java}}==

private static String[] splitAt(String str, int idx){

String[] ans = new String[2];

System.out.println(count + " Kaprekar numbers < 1000000 (base 10) in base "+base);

}

{{out}} (base 10, shortened):

<pre>1 1 1 0 + 1

=={{header|JavaScript}}==

'''This string version'''

if ( n < 1 ) return false

if ( n == 1 ) return true

}

return false

'''or this numeric version'''

if ( n < 1 ) return false

if ( n == 1 ) return true

}

return false

'''with'''

bs = bs || 10; pbs = pbs || 10

const toString = n => n.toString(pbs).toUpperCase()

kaprekar( 1, 255, 16)

kaprekar( 1, 255, 16, 16)

{{out}}

<pre>

=={{header|jq}}==

{{Works with|jq|1.4}}

def is_kaprekar:

# The helper function acts like a loop:

[ range(1;10000) | select( is_kaprekar ) ],

count( range(1;1000000); is_kaprekar )

{{Out}}

[1,9,45,55,99,297,703,999,2223,2728,4879,4950,5050,5292,7272,7777,9999]

 

=={{header|Julia}}==

{{works with|Julia|1.2}}

 

n == 1 && return true

test(a, b) = n == a + b && b ≠ 0

 

@show filter(iskaprekar, 1:10000)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

import java.lang.Long.toString

 

}

println("$count Kaprekar numbers < $max (base 10) in base $base")

{{out}}

<pre> 1 1 1 0 + 1

 

=={{header|Liberty BASIC}}==

For i = 1 To 10000 '1000000 - Changing to one million takes a long time to complete!!!!

Next i

End Function

 

=={{header|Lua}}==

function numLength (n)

local length = 0

if isKaprekar(n) then count = count + 1 end

end

{{out}}

<pre>1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999

For a number x to be Kaprekar, it must have x^2 congruent to x mod 9.

Which is only achievable when x has remainder 1 or 0 mod 9. So we only check for these cases.

isKaprekar := proc(n::posint)

local holder, square, num_of_digits, k, left, right;

 

showKaprekar(10000);

 

{{out}}

54</pre>

 

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]

{{out}}

<pre>{1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999}

54</pre>

 

=={{header|Maxima}}==

[p, q, a, b],

if n = 1 then true else (

 

length(%);

 

=={{header|ML}}==

==={{header|mLite}}===

val base = 10;

fun kaprekar

| (num :: nums) = kaprekar_list (num :: nums, [])

end

Generate and show all Kaprekar numbers less than 10,000.

Optionally, count (and report the count of) how many Kaprekar numbers are less than 1,000,000.

Output:

<pre>kaprekar numbers < 10_000: [1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT Write,WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nim}}==

let b = parseBiggestInt n2[i .. n2.high]

if b > 0 and a + b == n:

return true

echo toSeq(1..10_000).filter(k)

{{out}}

<pre>[1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]

 

=={{header|PARI/GP}}==

my(D=10^d,DD,t,v=List());

for(n=D/10+1,D-1,

upTo(4)

v=upTo(6);v

{{out}}

<pre>%1 = [1, 9, 45, 55, 99, 297, 703, 999, 2223, 2728, 4879, 4950, 5050, 5292, 7272, 7777, 9999]

=={{header|Perl}}==

===Numeric with casting out nines (fast)===

my $k = shift;

return if $k*($k-1) % 9; # Fast return "casting out nines"

my @kaprekar;

isKap($_) && push @kaprekar,$_ for 1..1_000_000;

{{out}}

<pre>

We can also use the method of [https://cs.uwaterloo.ca/journals/JIS/VOL3/iann2a.html Douglas Iannucci] to get much faster results (the below takes only a few milliseconds). This works for bigints as well.

{{libheader|ntheory}}

 

my %kap;

printf "Kaprekar numbers <= 10^%2d: %5d\n",

$n, scalar(grep { $_ <= $np } @kap);

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|Phixmonti}}==

var n

dup 2 power var s

dup FNkaprekar IF print " " print 1 + else drop endif

endfor

 

=={{header|PHP}}==

 

print_r(array_filter(range(1, 10000), 'isKaprekar'));

}

return false;

 

<pre>Array

)

54</pre>

 

=={{header|PicoLisp}}==

(let L (cons 0 (chop (* N N)))

(for ((I . R) (cdr L) R (cdr R))

(NIL (gt0 (format R)))

{{out}}

<pre>: (filter kaprekar (range 1 10000))

 

=={{header|PL/I}}==

kaprekar: procedure options (main); /* 22 January 2012 */

declare i fixed decimal (9), j fixed binary;

 

end kaprekar;

{{out}}

<pre>

 

=={{header|PowerShell}}==

function Test-Kaprekar ([int]$Number)

{

return $false

}

"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

{{Out}}

<pre>

=={{header|Prolog}}==

Works with SWI-Prolog, uses a list comprehension : [[List comprehensions#Prolog]]

split_number(Z, 10, X).

 

kaprekar(N, V) :-

V <- {X & X <- 1 .. N & ((Z is X * X, kaprekar_(Z, X)); X = 1) }.

{{out}}

<pre> ?- kaprekar(1000, V).

=={{header|PureBasic}}==

{{trans|C}}

nn.q = n*n

tens.q= 1

Print("Press ENTER to exit")

Input()

<pre> 1: 1

2: 9

===Splitting strings in a loop===

(Swap the commented return statement to return the split information).

n2 = str(n**2)

for i in range(len(n2)):

>>> len([x for x in range(1,1000000) if k(x)])

54

 

A stronger code that gives a list of Kaprekar numbers within a range in a given base.

The range must be given as a decimal number.

result = ""

while n:

print 'The number of Kaprekar Numbers found are',

print len(KNumbers)

===Using Casting Out Nines Generator===

See: http://rosettacode.org/wiki/Casting_out_nines#Python for explanation and code for CastOut

Base = 10

N = 6

Paddy_cnt += 1

break

Produces:

<pre>

</pre>

Other bases may be used e.g.:

Base = 16

N = 4

Paddy_cnt += 1

break

Produces:

<pre>

40: e6e6

41: ffff

</pre>

 

=={{header|Racket}}==

#lang racket

(define (kaprekar? n)

 

(filter kaprekar? (range 1 10000))

<pre>

'(1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999)

(formerly Perl 6)

===String version (slow)===

my $sq = $n ** 2;

for 0 ^..^ $sq.chars -> $i {

print 1;

print " $_" if .&kaprekar for ^10000;

{{out}}

<pre>1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999</pre>

===Numeric version (medium)===

my $hi = $n ** 2;

my $lo = 0;

print " $_" if .&kaprekar for ^10_000;

 

(^1_000_000).race.map: { $n++ if kaprekar $_ }

say "\n\nBase 10 Kaprekar numbers < :10<1_000_000> = $n";

}

 

{{out}}

<pre style="height:35ex">1 9 45 55 99 297 703 999 2223 2728 4879 4950 5050 5292 7272 7777 9999

 

===Casting out nines (fast)===

my $base-m1 = $base - 1;

gather loop (my $place = 1; ; ++$place) {

$l17 = '0' x ($s17.chars - $h17.chars - $l17.chars) ~ $l17;

say "$n $n17 $s17 ($h17 + $l17)";

(Same output.)

 

=={{header|REXX}}==

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 /* " " " " " " */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/* [↑] handle case of N being unity.*/

s= j*j /*calculate the square of J (S). */

end /*j*/

say

{{out|output|text=&nbsp; when using the default inputs of: &nbsp; &nbsp; <tt> &nbsp; 10000 &nbsp; -1000000 </tt>}}

<pre>

 

 

</pre>

 

=={{header|Ring}}==

nr = 0

for i = 1 to 200

end

return (n = 1)

Output:

<pre>

5 : 99

total kaprekar numbers under 200 = 5

</pre>

 

=={{header|Ruby}}==

with extra extra credit

return [1, 1, 1, ""] if n == 1

return if n*(n-1) % (base-1) != 0 # casting out nine

puts "%7s %5s %9s %s + %s" % [decimal, *result]

end

 

{{out}}

 

=={{header|Run BASIC}}==

x$ = str$(i * i)

if i = 1 then x$ = "10"

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

Kaprekar :8 + 1 = 9

Kaprekar :20 + 25 = 45

=={{header|Scala}}==

{{works with|Scala|2.9.1}}

 

def isKaprekar(n: Int, base: Int = 10):Option[Triple[String,String,String]] = {

println(k3.size + " Kaprekar numbers < 1000000 (b:10) for base 17"+"\n"*2)

 

{{out}}

<pre style="height: 40ex; overflow: scroll">1

 

=={{header|Scheme}}==

(define (range a b)

(let loop ((v '()) (i b))

 

(filter kaprekar? (range 1 10000))

 

=={{header|Seed7}}==

include "bigint.s7i";

 

end if;

end for;

 

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

 

for n in (1..15) {

var k = (10**n - 1)

printf("Kaprekar numbers <= 10^%2d: %5d\n", n, kapr.count_by { .<= k })

 

{{out}}

 

=={{header|SPL}}==

> i, 1..n

<< kap[i]!<10000

<

<= kap,#.size(kap,1)

{{out}}

<pre>

 

=={{header|Tcl}}==

proc kaprekar n {

if {$n == 1} {return 1}

incr kcount [kaprekar $i]

}

{{out}}

<pre>

=={{header|Ursala}}==

First we define a function <code>kd</code> parameterized by a pair of functions <code>p</code> and <code>r</code> for printing and reading natural numbers, which takes a natural number to its Kaprekar decomposition if any.

#import nat

 

#cast %nLnX

 

The <code>kd</code> function parameterized by the built in decimal printing and reading functions is applied to the sequences from zero to 10000 and zero to 1000000, with the results filtered according to whether the decomposition exists. The inputs in the former case and the length in the latter are shown.

<pre>

</pre>

For the rest of the task, functions <code>p</code> and <code>r</code> are defined for numbers in base 17.

 

r = sum^|(~&,product/17)=>0+ *x -$/digits--'abcdefg' iota17

#show+

 

The <code>kd</code> function is parameterized by them and a table of results for numbers between 1 and 1000000 is displayed.

<pre>

=={{header|Visual Basic .NET}}==

{{trans|FreeBASIC}}

 

ReadOnly max As ULong = 1000000

End Sub

 

{{out}}

<pre>Kaprekar numbers below 10000

 

54 numbers below 1000000 are kaprekar numbers</pre>

 

=={{header|Wortel}}==

isKap &n [

@var s +'' *n n

!console.log "Number of Kaprekar numbers below 1000000: {#!-isKap @to 1M}"

]

{{out}}

<pre>Kaprekar numbers below 10000: 1,9,45,55,99,297,703,999,2223,2728,4879,4950,5050,5292,7272,7777,9999

{{trans|Go}}

{{libheader|Wren-fmt}}

 

var kaprekar = Fn.new { |n, base|

Fmt.print("$8d $7s $12s $6s + $s", m, str, sq, sq[0...split], sq[split..-1])

}

 

{{out}}

numbers up to 1,000,000. Floating point (double) provides 15 decimal digits of precision.

 

 

func Kaprekar(N, B); \Returns 'true' if N is a Kaprekar number in base B

[Text(0, " "); IntOut(0, N)];

CrLf(0);

 

{{out}}

=={{header|Yabasic}}==

{{trans|BBC BASIC}}

n = 0

FOR i = 1 TO 999999

loop

return (n=1)

 

=={{header|zkl}}==

{{trans|D}}

powr:=n*n;

r:=l:=0; tens:=b;

}

return(False);

[1..].filter(T(isKaprekarB, fcn(n){ if(n>=10000) Void.Stop else True })));

 

kbs:=[1..].filter(T(isKaprekarB.fp1(17),

fcn(n){ if(n>=0d1_000_000) Void.Stop else True }));

{{out}}

<pre>