Zu Ehren, wie viel Wiederholung ich vor einigen Stunden hatte, als ich zum ersten Mal über diese Herausforderung nachdachte:

Zahlen wie diese, die sich aus einer einzelnen Ziffer zusammensetzen, werden repdigits genannt . Repdigits machen Spaß! Jeder Körper wäre froh, wenn die Anzahl der Wiederholungen eine Wiederholungszahl wäre ¹ , aber ich bin ungeduldig. Sie müssen mir also helfen, den schnellsten Weg zu einer Wiederholungszahl zu finden.

Hier ist Ihre Herausforderung:

Geben Sie bei positiven Ganzzahlen, die den Ruf repräsentieren, die Mindestanzahl an Wiederholungen aus, die erforderlich sind, um zu einer Wiederholungsziffer zu gelangen. Zum Zeitpunkt der Erstellung dieser Challenge hatte der Benutzer Martin Ender beispielsweise 102.856 Mitarbeiter. Die nächste Wiederholungsziffer ist 111.111, daher müsste er gewinnen: 8255 Wiederholungen, um eine Wiederholungsziffer zu haben.

Da die Leute es nicht mögen, Repräsentanten zu verlieren, werden wir nur nicht negative Veränderungen berücksichtigen. Dies bedeutet, dass zum Beispiel, wenn jemand 12 Wiederholungen hat, anstatt 1 Wiederholung zu verlieren, die Lösung darin besteht, 10 Wiederholungen zu gewinnen. Dies ermöglicht, dass '0' eine gültige Ausgabe ist, da jeder, der 111 Wiederholungen hat, bereits eine Wiederholungsziffer hat.

Die Eingabe und Ausgabe kann in jedem vernünftigen Format erfolgen , und da es unmöglich ist, weniger als eine Wiederholung auf einer Stack Exchange-Site zu haben, können Sie davon ausgehen, dass keine Eingabe weniger als 1 ist.

Ein Eckfall zu beachten:

Wenn ein Benutzer weniger als 10 Wiederholungen hat, hat er bereits eine Wiederholungsziffer und benötigt daher auch '0'.

Test IO:

#Input      #Ouput
8           0
100         11
113         109
87654321    1234567
42          2
20000       2222
11132       11090

Es gelten Standardlücken, und die kürzeste Lösung in Bytes gewinnt!

Gelee , 6 Bytes

DE$1#_

Die Ausgabe ist ein Singleton-Array.

Probieren Sie es online! oder überprüfen Sie die meisten Testfälle . Der Testfall 87654321 ist für TIO zu langsam.

Wie es funktioniert

DE$1#_  Main link. Argument: n

   1#   Call the link to the left with argument k = n, n + 1, n + 2, etc. until one
        match is found, then return the matching k.
  $       Combine the two links to the left into a monadic chain.
D           Convert k to base 10.
 E          Test if all decimal digits are equal.
     _  Subtract n from the result.

Haskell, 39 Bytes

until(((==).head>>=all).show)(+1)>>=(-)

Probieren Sie es online aus

Brachylog , 9 Bytes

:.#++#==,

Probieren Sie es online!

Dies ist ziemlich effizient, da es sich der arithmetischen Bedingungen bedient.

Erläuterung

:.            The list [Input, Output].
  #+          Both elements must be positive or zero.
    +         The sum of those two elements…
     #=       …must result in an integer where all digits are the same.
       =,     Assign a value that matches those constraints.

Python 2, 41 40 Bytes

def f(n):r=10**len(`n`)/9;print-n/r*-r-n

Nicht der kürzeste Ansatz, aber sehr effizient. Teste es auf Ideone .

Wie es funktioniert

Für die Eingabe 10**len(`n`)Runden n bis zur nächsten Leistung von 10 . Anschließend teilen wir das Ergebnis durch 9 . Dies gibt die repdigit 1… 1 zurück , die so viele Ziffern wie n hat . Wir speichern das Ergebnis in r . Wenn beispielsweise n = 87654321 , dann ist r = 11111111 .

Die gewünschte Nachkommastelle ist ein Vielfaches oder r . Um zu entscheiden, welche, führen wir eine Deckenteilung von n durch r durch . Seit Python 2's Division Operator /Floors kann dies -n/rmit negativem Vorzeichen erreicht werden , was den korrekten Absolutwert ergibt. Wenn beispielsweise n = 87654321 ist , wird -8 zurückgegeben .

Schließlich multiplizieren wir den berechneten Quotienten mit -r , um den Quotienten einmal für jede Ziffer in n zu wiederholen . Wenn beispielsweise n = 87654321 , kehrt diese 88888888 , der die gewünschte Schnapszahl ist.

Um das erforderliche Inkrement zu berechnen, subtrahieren wir schließlich n vom vorherigen Ergebnis. Für unser Beispiel ist n = 87654321 , dieser kehrt 1234567 , je nach Wunsch.

Python 2, 37 Bytes

f=lambda n:1-len(set(`n`))and-~f(n+1)

Teste es auf Ideone . Beachten Sie, dass dieser Ansatz für den Testfall 87654321 zu ineffizient ist .

Wie es funktioniert

Wenn n bereits eine Nachkommastelle ist, 1-len(set(`n`))wird 0 zurückgegeben, da die Länge der Menge der Ziffern von n in der Basis 10 1 ist . In diesem Fall f Erträge 0 .

Wenn n kein Wert ist, wird ff(n+1) rekursiv mit dem nächstmöglichen Wert von n aufgerufen . Inkremente den Rückgabewert von f ( 0 , wenn ein Schnapszahl gefunden wird) um 1 jedes Mal f wird rekursiv aufgerufen, so dass der endgültige Rücklaufwert die Anzahl von Malen gleich f , dh aufgerufen wurde, die Anzahl von Malen n mußten werden inkrementierten ein repdigit bekommen.-~

Perl 6 , 23 Bytes

{($_...{[==] .comb})-1}

Ein Lambda, das die eingegebene Zahl als Argument verwendet und das Ergebnis zurückgibt.

Erläuterung:

1. Verwendet den ...Sequenzoperator, um die Eingabenummer zu erhöhen, bis eine neue Ziffer erreicht ist (getestet, indem die Zeichenfolgendarstellung in Zeichen aufgeteilt und geprüft wird, ob alle gleich sind) .
2. Subtrahiert eins von der Länge der Sequenz.

Java 7, 116 76 Bytes

int c(int i){int r=(int)Math.pow(10,(i+"").length())/9;return(-i/r-1)*-r-i;}

Verwendete @Dennis 'erstaunlichen Ansatz , um die Byteanzahl um satte 40 Bytes zu senken.

Ungolfed & Testfälle:

Probieren Sie es hier aus.

class Main{
  static int c(int i){
    int r = (int)Math.pow(10, (i+"").length()) / 9;
    return (-i / r - 1) * -r - i;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(87654321));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(11132));
  }
}

Ausgabe:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 Bytes

1 Byte danke an @FryAmTheEggman.

-f@F`TQ

Probieren Sie es online aus.

Sehr ineffizient, durchläuft alle Zahlen von der Eingabe bis zur nächsten Stelle.

Brain-Flak 690 358 Bytes

Hier ist mein Versuch

(({})[()])(()){{}(({}())){(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)}{}<>{(([])<{{}({}[()]<>)<>([])}{}><>){({}[()]<({}<>)<>>)}{}<>}([]){{}{(<({}<>)<>>)}{}([])}{}<>(([][()()])<{{}{}([][()()])}{}>)}{}({}[{}])

Probieren Sie es online

Erläuterung

Beginnen Sie, indem Sie eine zweite Kopie der Eingabe erstellen, die um eine Kopie geringer ist als die des Originals. Wir werden die Kopie verwenden, um nach dem nächsten Nachkomma zu suchen. Wir subtrahieren eins, falls die Zahl selbst eine Umstellung war

(({})[()])

Drücken Sie eine, um die kommende Schleife zu erfüllen. (muss nicht eins sein, nur nicht null)

(())

Diese Schleife wird solange ausgeführt, bis sich eine neue Ziffer auf dem Stapel befindet

{

Pop den Mist. Oben ist ein "Boolescher Wert", der die Schleife ansteuert, da er nicht mehr benötigt wird. Wir platzieren ihn.

{}

Fügen Sie einen hinzu und duplizieren Sie den oberen. Die Kopie wird in ihre Ziffern zerlegt.

(({}()))

Während die Kopie nicht Null ist ...

{

Kopieren Sie erneut

(({}))

Mod 10 und gehe zum anderen Stapel

(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>

Teilen durch 10 (Ganzzahlige Division)

(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)

}

Pop die Null, die unsere Kopie war

{}

Wir haben die Zahl nun in ihre 10-stelligen Basiszahlen zerlegt und wechseln mit allen Ziffern zum Stapel.

<>

Während die führende Ziffer nicht Null ist

{

Wir nehmen eine Kopie der Stapelhöhe (dh die Anzahl der Stellen) ...

(([])<

Subtrahieren Sie still von jeder Zahl auf dem Stapel eine

{
{}
({}[()]<>)<>
([])
}
{}

Stellen Sie die Stapelhöhe, die wir aufgenommen haben, auf den Tisch. (und zum anderen Stapel wechseln)

><>)

Wir verwenden die Stapelhöhe, um alle Ziffern, die wir auf dem anderen Stapel platziert haben, wieder auf den richtigen Stapel zu ziehen.

{
({}[()]<({}<>)<>>)
}

Pop die Null, die unsere Stapelhöhe war

{}

Tausche mit den Ziffern (oder was waren die Ziffern) zurück auf den Stapel

<>

Schleife beenden

}

Jetzt haben wir die oberste Ziffer von allen anderen Ziffern abgezogen. Wenn alle Ziffern Null sind, war die ursprüngliche Nummer (nicht die Eingabe, sondern die Nummer, die wir überprüfen) eine neue Ziffer. ^{[Zitat benötigt]} . Wir müssen also nach Nicht-Nullen suchen.

Während die Stapelhöhe nicht Null ist

([])
{
{}

Wenn die Ziffer nicht Null ist, verschieben Sie sie auf den anderen Stapel und ersetzen Sie sie durch eine Null.

{
(<({}<>)<>>)
}

Pop it (jetzt ist es eine Null)

{}

Schleife beenden

([])
}
{}

Wechseln Sie auf den anderen Stapel (duh ..)

<>

Nehmen Sie sich eine Kopie der Stapelhöhe minus zwei

(([][()()])<

Während die Stapelhöhe nicht zwei ist (das Original und der Akku)

{
{}

Pop die Spitze

{}

Beende die Weile

([][()()])
}
{}

Legen Sie unsere Kopie der Stapelhöhe minus zwei ab. Dies ist die Anzahl der Ziffern, die nicht mit der ersten Ziffer übereinstimmen. Mit anderen Worten, wenn es Null ist, handelt es sich um eine Neuziffer.

>)

Wenn diese Schleife endet, haben wir eine neue Ziffer gefunden

}

Pop der "Boolesche"

{}

Subtrahieren Sie das Original von der Umstellziffer

({}[{}])

Python 2, 52 Bytes

a=b=input()
while len(set(str(a)))!=1:a+=1
print a-b

Python 2 hat mehrere Tricks, die dies verkürzen. Zum Beispiel ist die Eingabe numerisch, sodass wir nicht nach int umwandeln müssen. (-5 bytes) Wir müssen auch keine Klammern um das setzena-b (-1 byte) setzen

Verwenden Sie dieses Skript, um alle Testfälle zu überprüfen:

def f(i):
    a=b=i
    while len(set(str(a)))!=1:a+=1
    return a-b

inputs = [8, 100, 113, 87654321, 42, 20000, 11132]
outputs = [0, 11, 109, 1234567, 2, 2222, 11090]

for i in range(len(inputs)):
    print(f(inputs[i]) == outputs[i])

Sie können es auch online ausprobieren!

GNU sed, 223 + 1 (r Flag) = 224 Bytes

s/$/:0%/
:;y/:%/%:/
/^(.)\1*%/{s/.*%(.*):/\1/;q}
:f;s/9(@*:)/@\1/;tf
s/8(@*:)/9\1/;s/7(@*:)/8\1/
s/6(@*:)/7\1/;s/5(@*:)/6\1/
s/4(@*:)/5\1/;s/3(@*:)/4\1/
s/2(@*:)/3\1/;s/1(@*:)/2\1/
s/0(@*:)/1\1/;s/(^|%)(@*:)/\11\2/
y/@/0/;t

Lauf:

sed -rf repdigit.sed <<< "112"

Ausgabe:

110

Dies ist eine reine sed-Lösung , die Arithmetik wird nur mit regulären Ausdrücken simuliert. Der Algorithmus funktioniert wie folgt:

1. Das Musterraumformat ist auf eingestellt ^current_reputation:needed_reputation%$
2. In jeder Iteration der Hauptschleife werden die Trennzeichen umgeschaltet:
   a) Wendet%: das Inkrement auf needed_reputation an.
   b) Wendet:% das Inkrement auf an current_reputation
3. wenn die aktuelle_reputation eine "repdigit" ist, wird die benötigte_reputation gedruckt und das Programm beendet

Java, 74 72 Bytes

int c(int i){int n=0;while(!(i+++"").matches("^(.)\\1*$"))n++;return n;}

(Wenn der andere Java-Eintrag 76 Byte umfasst, ist dies der Fall74 72, da es ist zwei vier Bytes kürzer).

Inkrementieren Sie die Eingabe einfach, bis sie eine neue Ziffer ist, während Sie einen Zähler inkrementieren. Senden Sie den Zähler zurück.

Ja, das sind drei Pluszeichen in einer Reihe, zwei, um die Eingabe zu erhöhen, eines, um eine leere Zeichenfolge zu verketten, um sie zu einer Zeichenfolge zu machen.
Nein, ich hätte nicht gedacht, dass es legal wäre, wenn dazwischen kein Leerzeichen wäre, aber los geht's. Das ist, was ein Tippfehler für Sie tun wird: ein Byte kürzer.

Die Verwendung einer for-Schleife anstelle einer while-Schleife benötigt genau so viele Bytes:

int c(int i){int n=0;for(;!(i+++"").matches("^(.)\\1*$");n++);return n;}

Bearbeiten:

Eine frühere Version musste matches("^(\\d)\\1*$")nach einem Repdigit suchen, aber da wir gerade ein Int in einen String konvertiert haben, reicht es aus, ein To .Match zu verwenden.

Ungolfed & Testfälle:

Probieren Sie es hier aus.

class Main{
  static int c(int i){
    int n=0;
    while(!(i++ + "").matches("^(.)\\1*$")) {
      n++;
    }
    return n;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(87654321));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(11132));
  }

}

Ausgabe:

0
11
109
1234567
2
2222
11090

R, 102 98 91 Bytes

a=scan(,'');i=0;while(length(unique(strsplit(a,"")[[1]]))!=1){a=paste(strtoi(a)+1);i=i+1};i

Ungolfed:

a=scan(,'') #Asks for input
i=0         #Initialize i to 0, surprisingly

while(length(unique(strsplit(a,"")[[1]]))!=1) 
    #Splits the input into its digits,  
    #compute the length of the vector created by the function `unique`, which gives all the digits once.
    #as long as the this length is different from one :
{
a=paste(strtoi(a)+1) #Increases by one the value of the input (while messing around with its format)
i=i+1                           #Increases by one the value of the counter
}

i #Outputs the counter

Das Herumspielen mit dem Format ( as.numericundas.character ) fügt einige Bytes hinzu, aber R ist nicht wirklich flexibel!

Perl, 40 + 1 ( -n) = 41 Bytes

/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo

Wenn nichts gedruckt werden soll, anstatt 0dass die Zahl bereits ein Neudigit ist, sind 37 Bytes ausreichend:

/^(.)\1*$/&&say$v or$_++&&++$v&&redo

Führen Sie mit -n(1 Byte) und -Eoder -M5.010(frei) aus:

perl -nE '/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo'

Erklärungen : Der Code besteht aus zwei Hauptteilen: /^(.)\1*$/&&say$vund $_++&&++$v&&redo. Der erste Test $_ist ein Repdigit; Wenn ja, wird die Nummer gedruckt, die wir zur ursprünglichen Nummer hinzugefügt haben, um sie zu einem repdigit ( $v) zu machen , und wenn nein, hatten wir eine 1 für beide $_und $vund fangen von vorne an.

JavaScript (ES6), 42 Byte

f=(n,p=1)=>n<p?-~(n*9/p)*~-p/9-n:f(n,p*10)

Erläuterung: Wird rekursiv pals nächste Potenz von 10after berechnet n. Die zu wiederholende Ziffer wird dann berechnet als 1+floor(9n/p)und die Wiederholung ist einfach (p-1)/9, woraus das Ergebnis folgt.

05AB1E , 10 6 Bytes

∞.Δ+Ë

Probieren Sie es online!

Erläuterung

∞<      # from the infinite list of non-negative integers
  .Δ    # find the first number where
     Ë  # all digits are equal
    +   # after adding the input

Pyke, 13 11 Bytes

o+`}ltIr)ot

Probieren Sie es hier aus!

            - o = 0
o+          -     o++ + input
  `         -    str(^)
   }        -   deduplicate(^)
    lt      -  len(^)-1
      I )   - if ^:
       r    -  goto_start()
         ot - o++ -1

Eigentlich 15 Bytes

;D;WXu;$╔l1<WX-

Probieren Sie es online!

Erläuterung:

;D;WXu;$╔l1<WX-
;                dupe
 D;              decrement, dupe
   WXu;$╔l1<W    while top of stack is truthy:
    X              discard
     u             increment
      ;            dupe
       $╔l1<       1 if len(str(TOS)) > 1 else 0 (check if the string representation of the TOS contains only one unique digit)
                 after the loop, the stack will be [1 repdigit input]
             X   discard
              -  subtract input from repdigit

Qualle , 20 Bytes

p
<
)\&&&~j<i
->N>u0

Probieren Sie es online! TIO kann die längeren Testfälle nicht bewältigen, sollte aber bei genügend Zeit und Speicher auch funktionieren.

Erläuterung

• i eingegeben wird, und < dekrementiert. Dieser Wert wird der Funktion auf der linken Seite zugeführt.
• \> erhöht den Wert (mindestens einmal), bis die Funktion rechts einen Wahrheitswert ergibt.
• Die Testfunktion ist eine Zusammensetzung (von &s) von vier Funktionen.
• 0~j Konvertiert in einen String.
• u Entfernt doppelte Ziffern.
• > Entfernt den Kopf der resultierenden Zeichenfolge.
• Nist logische Negation: Es gibt 1für eine leere Zeichenfolge und 0für nicht leer. Somit prüft die Funktion auf eine Wiederholungsziffer, und das Ergebnis von \ist die nächste Wiederholungsziffer, die ab zählt <i.
• )-subtrahiert das Ergebnis von der Funktionseingabe, d. h <i.
• Dieser Unterschied wird um eins <verringert. Zum Schluss wird pdas Ergebnis gedruckt.

PowerShell v2 +, 66 Byte

param($n)for($x=+"$($n[0])";($y="$x"*$n.length)-lt$n;$x++){}+$y-$n

Das normalerweise sehr lockere Casting von PowerShell, das für das Golfen gut ist, ist hier ein schwerwiegender Nachteil.

Nimmt Eingaben $nals Zeichenfolge und gibt eine forSchleife ein. Für den Setup-Schritt extrahieren wir das erste Zeichen $n[0], müssen es jedoch wieder in einen String konvertieren, "$(...)"bevor wir es als int umwandeln +und in speichern $x. Andernfalls verwendet die spätere Arithmetik den ASCII-Wert des Zeichencodes.

Die Bedingung prüft, ob eine Zeichenkette, die aus $n.length "$x"s aufgebaut ist und in der sie zwischengespeichert $yist, kleiner als ist $n. Solange dies nicht der Fall ist $x++, erhöhen wir die Bedingung für die nächste Schleife.

Bei der Eingabe 123ist beispielsweise der Wert für $ydie erste Prüfung der Bedingung 111kleiner als $n, sodass die Schleife fortgesetzt wird. Da sich nichts im Schleifenkörper befindet, wird das Schrittinkrement ausgeführt $x++und die Bedingung erneut überprüft. $yIst diese Zeit 222größer als $n, wird die Schleife beendet. Wenn die Eingabe bereits ein Repdigit ist, ist die Bedingung nicht erfüllt, da an diesem Punkt $ygleich ist $n.

Sobald wir die Schleife verlassen haben, werden wir $yzu einer ganzen Zahl umgewandelt +und dann subtrahieren $n. Dieses Ergebnis verbleibt in der Pipeline und die Ausgabe ist implizit.

PHP 5.6, 59 53 51 50 Bytes

Gespeichert 6 8 Bytes dank @manatwork.

while(count_chars($argv[1]+$b,3)[1])$b++;echo$b?:0

Testen Sie mit:

php test.php 11132

Die count_chars()Funktion mit 3 als zweitem Parameter gibt eine Zeichenfolge mit den verschiedenen Zeichen in einer Zeichenfolge zurück. Wenn diese Zeichenfolge 1 Zeichen lang ist ( [1]wird false zurückgeben, wenn sie 1 Zeichen lang ist ), wird ein Echo ausgegeben $b, andernfalls wird inkrementiert $bund die Schleife erneut ausgeführt.

MATL , 10 Bytes

q`QtVda}G-

Probieren Sie es online!

Dadurch wird die Eingabe so lange inkrementiert, bis alle Ziffern gleich sind. Daher ist die Eingabe langsam. Der Testfall für die Eingabe 87654321läuft im Online-Compiler ab.

q      % Take input implicitly. Subtract 1
`      % Do...while loop
  Q    %   Increment top of the stack
  tV   %   Duplicate and convert to string (i.e. digits of the number)
  d    %   Difference between consecutive digits
  a    %   True if any such difference is nonzero. This is the loop condition
}      % Finally (execute on loop exit)
  G-   %   Subtract input. This is the final result, to be (implicitly) displayed
       % End loop implicitly. If loop condition (top of the stack) is truthy: proceeds 
       % with next iteration. Else: executes the "finally" block and exits loop
       % Display implicitly

Ruby, 42 Zeichen

->n{i=0;n.next!&&i+=1while n.squeeze[1];i}

Erwartet eine Zeichenfolgeeingabe.

Probelauf:

irb(main):019:0> ->n{i=0;n.next!&&i+=1while n.squeeze[1];i}['87654321']
=> 1234567

Ruby, 39 Zeichen

Rekursiver Aufruf, führt zu "SystemStackError: Stapelebene zu tief" bei größeren Ergebnissen.

r=->n,i=0{n.squeeze[1]?r[n.next,i+1]:i}

Probelauf:

irb(main):001:0> r=->n,i=0{n.squeeze[1]?r[n.next,i+1]:i}
=> #<Proc:0x00000002367ca0@(irb):10 (lambda)>

irb(main):002:0> r['20000']
=> 2222

Matlab, 65 64 Bytes

t=input('');i=0;while nnz(diff(+num2str(t+i)))
i=i+1;end
disp(i)

Wegen der while-Schleife ist es ziemlich langsam ...

Erläuterung

t=input('')  -- takes input
i=0          -- set counter to 0
while 
          num2str(t+i)   -- convert number to string 
         +               -- and then to array of corresponding ASCII codes
    diff(             )  -- produce vector of differences (all zeros for 'repdigit')
nnz(                   ) -- and count non-zero entries
i=i+1                    -- while not all digits are the same increase the counter
end          -- end while loop
disp(i)      -- print the counter

Ein Byte sparen dank sparen @Luis Mendo .

Excel, 85 79 Bytes

Fügen Sie die folgende Formel in eine beliebige Zelle mit Ausnahme der Zelle ein N da dies ein Name für die Referenzzelle der Eingabe ist:

=IF(1*(REPT(LEFT(N),LEN(N)))<N,REPT(LEFT(N)+1,LEN(N))-N,REPT(LEFT(N),LEN(N))-N)

Erläuterung:

• N ist der Eingang und auch Name der Referenzzelle .
• LEFT(N) nimm die erste Ziffer des Eingabewerts.
• LEN(N) Gibt die Länge des Eingabewerts zurück.
• REPT(LEFT(N),LEN(N)) Wiederholen Sie die erste Ziffer des Eingabewerts LEN(N) und multiplizieren Sie sie mit 1, um das Textformat in das Zahlenformat umzuwandeln, damit wir es für den Zahlenvergleich verwenden können.
• Die Syntax für die IF-Funktion in Microsoft Excel lautet: IF (Bedingung, [value_if_true], [value_if_false]) , daher ist die gesamte Formel selbsterklärend.

Brachylog v2, 6 Bytes

;.+=∧ℕ

Probieren Sie es online!

  +       The sum of
          the input
;         and
 .        the output
   =      is a repdigit,
    ∧     and
          the output
     ℕ    is a whole number.

Das 5-Byte-System +↙.=∧kommt mit dem Weglassen davon, ℕweil es überhaupt keine positiven Ausgaben versucht, aber es schlägt auch fehl, wenn eine Zahl angegeben wird, die bereits eine neue Ziffer ist, weil es überhaupt keine positiven Ausgaben versucht.

Java, 59 Bytes

int c(int i){return(i+"").matches("^(.)\\1*$")?0:c(i+1)+1;}

(Ich bin mir immer noch nicht sicher, wie ich Java - Einträge zählen soll, aber gemäß dem Standard von den ersten Java-Eintrag festgelegt wurde ist dieser Eintrag 59 Byte lang, da er 17 Byte kürzer ist).

Wie auch immer, wenn wir eine repdigit haben, geben Sie 0 zurück, fügen Sie 1 zur Eingabe hinzu, rufen Sie sich selbst auf und fügen Sie 1 zum Ergebnis hinzu.

Ungolfed & Testfälle:

Probieren Sie es hier aus.

class Main{
  static int c(int i) {
    return
      (i+"").matches("^(.)\\1*$")
      ? 0
      : c(i+1) + 1;
  }

  public static void main(String[] a){
    System.out.println(c(8));
    System.out.println(c(100));
    System.out.println(c(113));
    System.out.println(c(42));
    System.out.println(c(20000));
    System.out.println(c(19122));
    // Entry below will run out of memory
    System.out.println(c(19121));
  }
}

Ausgabe:

Runtime error   time: 0.09 memory: 321152 signal:-1
0
11
109
2
2222
3100

Wie Sie sehen, hat der letzte Eintrag nicht mehr genügend Speicher, bevor er beendet werden kann. Das (sehr passende) StackOverflowErrorist weggeworfen java.util.regex.Pattern.sequence(Pattern.java:2134), aber ich bin mir ziemlich sicher, dass an der Regex selbst nichts auszusetzen ist, da es das gleiche ist, das ich in meinem vorherigen Eintrag verwendet habe .

82 Bytes

using System.Linq;n=>{int i=n;while((i+"").Distinct().Count()!=1)++i;return i-n;};

C 84 Bytes

d,n,l,f;F(i){for(n=0;1;){l=i+n++;d=l%10;f=0;while(l/=10)f|=l%10-d;if(!f)return--n;}}

Testleitung:

int main() {
  printf("%d\n", F(8));
  printf("%d\n", F(100));
  printf("%d\n", F(113));
  printf("%d\n", F(87654321));
  printf("%d\n", F(47));
  printf("%d\n", F(20000));
  printf("%d\n", F(11132));
}

Prolog, 120 Bytes

r([H|T]):-r(H,[H|T]).
r(H,[H|T]):-r(H,T).
r(_,[]).
g(N,0):-number_chars(N,L),r(L).
g(N,X):-N1 is N+1,g(N1,X1),X is X1+1.

Probieren Sie es online!