Eine Kaprekar-Zahl ist eine n-stellige Zahl k . Wenn die ersten n oder n-1 Stellen von k ^ 2 zu den zweiten n Stellen von N ^ 2 addiert werden , ist das Ergebnis N.

Beispiele:

9^2 = 81.  8+1 = 9.
45^2 = 2025.  20+25 = 45.
297^2 = 88,209. 88+209 = 297

Die Kaprekar-Sequenz beginnt um 1.

Schreiben Sie ein Programm, das die ersten n Kaprekar-Zahlen berechnet und ausgibt , wobei n im Bereich von 1 bis 100 liegt, aber nicht darauf beschränkt ist. Jede Kaprekar-Zahl muss durch Leerzeichen und nichts anderes getrennt werden.

Weitere Kaprekar-Zahlen können hier gefunden werden , um Ihr Programm zu überprüfen. Diese Ressource darf jedoch NICHT zur Unterstützung der Berechnung verwendet werden - mit anderen Worten, keine Hardcodierung, kein Lesen aus dieser Quelle oder Verwendung in einem anderen Exploit Weise - alle Zahlen müssen von Ihrem Programm generiert werden.

Kürzester Code gewinnt.

Perl - 63 Bytes

#!perl -l
map{1while$l=length++$_,$_**2=~/.{$l}$/,$`+$&^$_;print}($_)x<>

Den Shebang als ein Byte zählen. Die Eingabe wird von übernommen stdin.

Dies hat eine akzeptable Laufzeit für n ≤ 50 , danach wird es etwas langsam.

Beispielnutzung:

$ echo 20 | perl kaprekar.pl
1
9
45
55
99
297
703
999
2223
2728
4950
5050
7272
7777
9999
17344
22222
77778
82656
95121

C 109 106

long long i=1;x=10,n;main(){scanf("%d",&n);for(;n;x*=x<=++i?10:1)(i-i*i/x-i*i%x)||printf("%lld ",i,n--);}

• mit nbis zu 17 wäre es ok das zu entfernen long long,
• Der überschüssige printf-Parameter wird missbraucht :)
• Warum kann im ternären Operator keine leere Anweisung verwendet werden? die beiden 1sind albern ...
• Vielen Dank an Josh für weitere 3 Charaktere ...

Mathematica 144 154

k@m_:=((x=m^2)-(w=FromDigits[Take[IntegerDigits@x,y=-IntegerLength@m]]))*10^y+w==m;
g@n_:=(s={};i=0;While[Length@s<n,If[k@i,s=Append[s,i]];i++];s)   

Prüfung

g[14]

0
1
9
45
55
99
297
703
999
2223
2728
4950
5050
7272

Javascript 96

for(i=0,n=prompt(s='');n;i++){t=''+i*i;if(t.substr(0,l=t.length/2)==i-t.substr(‌​l))n--,s+=i+' '}s

Ausgabe :

0 1 9 45 55 99 297 703 999 2223 2728 4950 5050 7272 7777 9999 17344 22222 77778 82656 95121 99999 142857 148149 181819 187110 208495 318682 329967 351352 356643 390313 461539 466830 499500 500500 533170 538461 609687 643357 648648 670033 681318 791505 812890 818181 851851 857143 961038 994708 999999 

Python - 98

Ich habe ein paar nette Python-Schnitte benutzt, um ein paar Zeichen zu entfernen.

i=n=0
while n<20:
 i+=1;s=str(i**2);l=-len(str(i))
 if int("0"+s[:l])+int(s[l:])==i:print(i);n+=1

255 Zeichen.

int x=100;decimal k=0;while(x>0){k++;decimal d=k*k;string s=d.ToString("n").Replace(",","").Split('.')[0];int g=k.ToString().Length;int h=s.Length;if(k==d||(h!=g&&long.Parse(s.Substring(h-g))+long.Parse(s.Substring(0,h-g))==k)){Console.Write(k+" ");x--;}}

x ist die Anzahl der Kaprekar-Nummern, die der Code finden soll. Dies wurde im Bereich von 1 bis 100 getestet, sollte aber viel mehr unterstützen. Die Rückkehr von 100 Nummern dauerte zweieinhalb Stunden, während die ersten 50 nur etwa eine Sekunde dauerten - danach verlangsamte sich die Geschwindigkeit allmählich.

Ausgabe:

1 9 45 55 99 297 703 999 2223 2728 4950 5050 7272 7777 9999 17344 22222 77778 
82656 95121 99999 142857 148149 181819 187110 208495 318682 329967 351352 356643 
390313 461539 466830 499500 500500 533170 538461 609687 643357 648648 670033 
681318 791505 812890 818181 851851 857143 961038 994708 999999 4444444 4927941 
5072059 5555556 9372385 9999999 11111112 13641364 16590564 19273023 19773073 
24752475 25252525 30884184 36363636 38883889 44363341 44525548 49995000 50005000 
55474452 55636659 61116111 63636364 69115816 74747475 75247525 80226927 80726977 
83409436 86358636 88888888 91838088 94520547 99999999 234567901 332999667 
432432432 567567568 667000333 765432099 999999999 1111111111 1776299581 2020202020 
3846956652 3888938889 4090859091 4132841328 4756047561

Der Code sieht wie folgt aus:

        int x = 100;
        decimal k = 0; 
        while (x > 0) 
        {
            k++;
            decimal d = k * k;
            string s = d.ToString("n").Replace(",", "").Split('.')[0];
            int g = k.ToString().Length; 
            int h = s.Length; 

            if (k == d || (h != g && long.Parse(s.Substring(h - g)) + long.Parse(s.Substring(0, h - g)) == k) )
            { 
                Console.Write(k + " "); x--; 
            } 
        }

Ich würde gerne wissen, ob dies weiter verkürzt werden kann.

C 90 76 75 Bytes

long long d,r=1;k(n){for(;++d/r?r*=10:--n;d-d*d/r-d*d%r||printf("%d ",d));}

Python 2.7, 144 (einschließlich Newlines)

def c(c):
 l="1";i=2;u=1
 while u<c:
  r=str(i**2);w=len(r)
  if w>1:
   if i==int(r[:w/2])+int(r[w/2:]):
    l+=" "+str(i);u+=1
  i+=1
 print l

Ausgabe für c = 10:

1 9 45 55 99 297 703 999 2223 2728

Ausgabe für u = 20:

1 9 45 55 99 297 703 999 2223 2728 4950 5050 7272 7777 9999 17344 22222 77778 82656 95121

R, 99 Zeichen

k=n=0;N=scan();while(n<N){k=k+1;j=k^2;i=10^ceiling(nchar(j)/2);if(k==j%/%i+j%%i){cat(k," ");n=n+1}}

Bei ider halben Anzahl von k^2aufgerundeten Stellen erfolgt die Bewertung von k als Kaprekar - Zahl hier durch Addition des Quotienten und des Restes der ganzzahligen Division von k^2durch 10^i(wobei der Quotient die linke Hälfte der abgerundeten Stellen und die Zahl ist) Rest die rechte Hälfte aufgerundet).

Bash + Sed, 75 Zeichen

Bash führt nur Ganzzahlarithmetik durch und stellt Zahlen als Dezimalzeichenfolgen dar; Diese Attribute sind hilfreich, um diese Herausforderung zu meistern. Außerdem wird angenommen, dass nicht deklarierte / nicht zugewiesene Variablen beim Rechnen den Wert 0 haben.

for((;s=++i*i,l=${#s}/2,1;));{
((${s:0:l}+10#${s:l}-i))||echo $i
}|sed $1q

Es ärgerte mich, das 10#da rein zu legen , aber so etwas ist notwendig, wenn die zweite Hälfte des Split mit einem beginnt 0. Wenn Sie rechnen, schlagen Sie behandelt solche Zahlen als oktal, es sei denn, die Basis wird ausdrücklich angegeben.

$ ./kaprekar.sh 10
1
9
45
55
99
297
703
999
2223
2728
$ 

Python 3.3 - 117 Zeichen

n=int(input())
p=1
while n>0:
    v=str(p**2)
    l=len(v)
    if p==int(v[l//2:])+int('0'+v[:l//2]):
        print(p)
        n-=1
    p+=1

Jede Einrückungsstufe und jede neue Zeile mit Ausnahme der letzten zählt für 1 Zeichen. Ich denke, das ist fair für Python-Code. Das Skript erwartet, dass der Benutzer die Anzahl der zu berechnenden Kaprekar-Zahlen eingibt.

J - 64

Etwas hässlich, aber trotzdem. Es prüft alle Zahlen bis zu einer Million und nimmt nsie dann auf, so dass es nur für n <= 50 funktioniert.

n{.}.I.(]=+/&;&:(10&#.&.>)&(<.@-:@#({.;}.)])&(10&#.inv@*:))i.1e6

n ist der Ort, an dem die Eingabe erfolgen soll