Na cześć ilu przedstawicieli miałem kilka godzin temu, kiedy po raz pierwszy pomyślałem o tym wyzwaniu:

Takie liczby, jak te składające się z jednej cyfry, nazywane są powtórkami . Repdigity są fajne! Każde ciało będzie bardziej szczęśliwy, jeśli kwota rep mieli był repdigit ¹ , ale jestem niecierpliwy, więc musisz mi pomóc dowiedzieć się, najszybszy sposób, aby dostać się do repdigit.

Oto twoje wyzwanie:

Biorąc pod uwagę dodatnie liczby całkowite reprezentujące reputację, wypisz minimalną liczbę powtórzeń, jaką muszą uzyskać, aby przejść do rekonstrukcji. Na przykład w momencie pisania tego wyzwania użytkownik Martin Ender miał 102 856 powtórzeń. Najbliższa cyfra powtórzenia to 111 111, więc musiałby zyskać: 8255 powtórzeń, żeby być na reprodukcji.

Ponieważ ludzie nie lubią tracić przedstawiciela, rozważymy tylko zmiany nieujemne. Oznacza to, że na przykład, jeśli ktoś ma 12 powtórzeń, zamiast stracić 1 powtórzenie, rozwiązaniem jest uzyskanie 10 powtórzeń. Dzięki temu „0” może być prawidłowym wyjściem, ponieważ każdy, kto ma 111 powtórzeń, jest już w trakcie repdigit.

Dane wejściowe i wyjściowe mogą mieć dowolny rozsądny format , a ponieważ nie można mieć mniej niż 1 powtórzenia w dowolnej witrynie Stack Exchange, można założyć, że żadne dane wejściowe nie będą mniejsze niż 1.

Jedna walizka do odnotowania:

Jeśli użytkownik ma mniej niż 10 powtórzeń, jest już na repdigit, więc potrzebuje również „0”.

Test IO:

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

Obowiązują standardowe luki, a najkrótsze rozwiązanie w bajtach wygrywa!

Galaretka , 6 bajtów

DE$1#_

Dane wyjściowe to tablica singletonów.

Wypróbuj online! lub zweryfikuj większość przypadków testowych . Przypadek testowy 87654321 jest zbyt wolny dla TIO.

Jak to działa

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 bajtów

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

Wypróbuj online

Brachylog , 9 bajtów

:.#++#==,

Wypróbuj online!

Jest to dość skuteczne, ponieważ wykorzystuje arytmetykę ograniczeń.

Wyjaśnienie

:.            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 bajtów

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

Nie najkrótsze podejście, ale bardzo wydajne. Przetestuj na Ideone .

Jak to działa

Dla 10**len(`n`)zaokrągleń wejściowych n do najbliższej potęgi 10 . Następnie dzielimy wynik przez 9 . Zwraca to reprodukcję 1… 1, która ma tyle cyfr, ile n . Zapisujemy wynik w r . Na przykład, jeśli n = 87654321 , to r = 11111111 .

Pożądana repdigit będzie wielokrotnością lub r . Aby zdecydować, wykonujemy podział sufitu n przez r . Ponieważ /piętra operatora podziału Pythona 2 można to osiągnąć za pomocą -n/r, która da poprawną wartość bezwzględną ze znakiem ujemnym. Na przykład, jeśli n = 87654321 , to zwróci -8 .

Wreszcie, należy pomnożyć przez iloraz obliczona -r powtórzyć iloraz raz dla każdej cyfry n . Na przykład, jeśli n = 87654321 , zwraca 88888888 , co jest pożądanym powtórzeniem.

Na koniec, aby obliczyć wymagany przyrost, odejmujemy n od poprzedniego wyniku. W naszym przykładzie n = 87654321 zwraca 1234567 , zgodnie z potrzebą .

Python 2, 37 bajtów

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

Przetestuj na Ideone . Należy zauważyć, że takie podejście jest zbyt nieefektywne w przypadku testowym 87654321 .

Jak to działa

Jeśli n jest już powtórką, 1-len(set(`n`))zwróci 0, ponieważ długość zestawu cyfr n w bazie 10 będzie wynosić 1 . W takim przypadku f zwraca 0 .

Jeśli n nie jest powtórzeniem, f(n+1)rekurencyjnie wywołuje f z następną możliwą wartością n . -~zwiększa wartość zwracaną f ( 0 po znalezieniu repdigit) o 1 za każdym razem, gdy f jest wywoływana rekurencyjnie, więc końcowa wartość zwrotna jest równa liczbie wywołań f , tj. liczbie razy, do których n trzeba było zwiększyć uzyskać reprogramowanie.

Perl 6 , 23 bajtów

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

Lambda, która przyjmuje liczbę wejściową jako argument i zwraca wynik.

Wyjaśnienie:

1. Używa ...operatora sekwencji do zwiększania liczby wejściowej, dopóki nie osiągnie repdigit (testowane przez podzielenie reprezentacji ciągu znaków na znaki i sprawdzenie, czy wszystkie są równe) .
2. Odejmuje jeden od długości sekwencji.

Java 7, 116 76 bajtów

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

Zastosowano niesamowite podejście @Dennis do obniżenia liczby bajtów o 40 bajtów.

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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));
  }
}

Wydajność:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 bajtów

1 bajt dzięki @FryAmTheEggman.

-f@F`TQ

Wypróbuj online.

Bardzo nieefektywny, przechodzi przez wszystkie liczby od wejścia do następnego repdigit.

Brain-Flak 690 358 bajtów

Oto mój wybór

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

Wypróbuj online

Wyjaśnienie

Zacznij od wykonania drugiej kopii danych wejściowych, która jest o jeden mniejsza niż oryginał. Kopię wykorzystamy do wyszukania następnej repdigit. Odejmujemy jeden w przypadku, gdy sam numer był redygitem

(({})[()])

Naciśnij jeden, aby zaspokoić nadchodzącą pętlę. (nie musi to być jeden, a nie zero)

(())

Ta pętla będzie działać, dopóki na stosie nie pojawi się repdigit

{

Pop bzdury. Ich „boolean” na górze, który napędza pętlę, ponieważ nie jest już potrzebny, pop go.

{}

Dodaj jeden i zduplikuj górę. Kopia zostanie rozłożona na cyfry.

(({}()))

Podczas gdy kopia nie jest zerem ...

{

Skopiuj ponownie

(({}))

Mod 10 i przejdź na drugi stos

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

Podziel przez 10 (dzielenie całkowite)

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

}

Podaj zero, które było naszą kopią

{}

Teraz zdekomponowaliśmy liczbę do jej 10 cyfr, więc zamieniliśmy wszystkie cyfry na stos.

<>

Podczas gdy cyfra wiodąca nie jest zerem

{

Odbieramy kopię wysokości stosu (tj. Liczby cyfr) ...

(([])<

Po cichu odejmij jeden z każdej liczby na stosie

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

Umieść wysokość stosu, którą podnieśliśmy. (i zamień na inny stos)

><>)

Używamy wysokości stosu, aby wyciągnąć wszystkie cyfry umieszczone na drugim stosie z powrotem na odpowiedni stos.

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

Podaj zero, które było naszą wysokością stosu

{}

Zamień z powrotem na stos cyframi (lub jakie były cyfry)

<>

Koniec pętli

}

Teraz odjęliśmy górną cyfrę od wszystkich pozostałych cyfr. Jeśli wszystkie cyfry są zerowe, liczba początkowa (nie liczba wejściowa, ale liczba, którą sprawdzamy) była powtórką.^{[potrzebne źródło]} . Musimy więc sprawdzić niezerowe.

Podczas gdy wysokość stosu nie jest równa zero

([])
{
{}

Jeśli cyfra nie jest równa zero, przenieś ją na drugi stos i zastąp ją zerem.

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

Pop to (teraz jest zero)

{}

Koniec pętli

([])
}
{}

Zamień na drugi stos (duh ..)

<>

Chwyć za siebie kopię wysokości stosu minus dwa

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

Podczas gdy wysokość stosu nie jest równa dwóm (oryginał i akumulator)

{
{}

Pop top

{}

Zakończ chwilę

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

Odłóż naszą kopię wysokości stosu minus dwa. Ostatecznie jest to liczba cyfr, które nie są takie same jak pierwsza cyfra. Innymi słowy, jeśli wynosi zero, jest to zmiana.

>)

Jeśli ta pętla się skończy, znaleźliśmy repdigit

}

Pop „boolean”

{}

Odejmij oryginał z repdigit

({}[{}])

Python 2, 52 bajty

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

Python 2 ma kilka sztuczek, dzięki którym jest to krótsze. Na przykład dane wejściowe są numeryczne, więc nie musimy rzutować na int. (-5 bajtów) Nie musimy również umieszczać nawiasów wokół a-b(-1 bajtów)

Użyj tego skryptu, aby zweryfikować wszystkie przypadki testowe:

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])

Możesz także spróbować online!

GNU sed, 223 + 1 (flaga r) = 224 bajty

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

Biegać:

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

Wydajność:

110

Jest to czyste rozwiązanie sed , arytmetyka jest symulowana przy użyciu tylko wyrażeń regularnych. Algorytm działa w następujący sposób:

1. format przestrzeni wzorów jest ustawiony na ^current_reputation:needed_reputation%$
2. w każdej iteracji głównej pętli separatory są przełączane:
   a) %:stosuje przyrost do potrzebnej_reputacji
   b) :%stosuje przyrost do bieżącej_reputacji
3. jeśli current_reputation jest to „repdigit”, tym needed_reputation jest drukowany i zakończeniem programu

Jawa, 74 72 bajty

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

(Jeśli inny wpis Java ma 76 bajtów, ten jest74 72, ponieważ to jest dwa cztery bajty krótsze).

W każdym razie, po prostu zwiększaj dane wejściowe, aż będzie to zmiana, jednocześnie zwiększając licznik. Zwróć licznik.

Tak, są to trzy plusy z rzędu, dwa do zwiększenia danych wejściowych, jeden do konkatenacji pustego łańcucha w celu utworzenia łańcucha.
Nie, nie sądziłem, że byłoby to legalne bez odstępu między nimi, ale proszę bardzo. To właśnie zrobi literówka: jeden bajt krótszy.

Użycie pętli for zamiast chwil zajmuje dokładnie tyle bajtów:

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

Edytować:

Wcześniejsza wersja musiała matches("^(\\d)\\1*$")sprawdzać poprawność, ale ponieważ właśnie przekonwertowaliśmy int na ciąg, .wystarczy użyć dopasowania.

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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));
  }

}

Wydajność:

0
11
109
1234567
2
2222
11090

R, 102 98 91 bajtów

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

Nie golfowany:

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

Bałagan z formatem ( as.numericias.character ) dodaje kilka bajtów, ale R nie jest tak naprawdę elastyczny!

Perl, 40 + 1 ( -n) = 41 bajtów

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

Jeśli 0akceptowalne jest drukowanie niczego zamiast gdy liczba jest już powtórna, to 37 bajtów wystarczy:

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

Uruchom z -n(1 bajtem) i -Elub -M5.010(za darmo):

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

Objaśnienia : kod składa się z dwóch głównych części: /^(.)\1*$/&&say$vi $_++&&++$v&&redo. Pierwszy sprawdza, czy $_jest to redigit; jeśli tak, wypisuje liczbę dodaną do pierwotnego numeru, aby uczynić go repdigit ( $v), a jeśli nie, mieliśmy 1 do obu $_i $v, i zaczynamy od nowa.

JavaScript (ES6), 42 bajty

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

Objaśnienie: Rekurencyjnie oblicza się pjako następną potęgę 10po n. Cyfra, która ma zostać powtórzona, jest następnie obliczana jako 1+floor(9n/p), a ponowne łączenie jest po prostu (p-1)/9, z którego wynika wynik.

05AB1E , 10 6 bajtów

∞.Δ+Ë

Wypróbuj online!

Wyjaśnienie

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

Pyke, 13 11 bajtów

o+`}ltIr)ot

Wypróbuj tutaj!

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

Właściwie 15 bajtów

;D;WXu;$╔l1<WX-

Wypróbuj online!

Wyjaśnienie:

;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

Meduza , 20 bajtów

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

Wypróbuj online! TIO nie może obsługiwać dłuższych przypadków testowych, ale biorąc pod uwagę wystarczającą ilość czasu i pamięci, one również powinny działać.

Wyjaśnienie

• i jest wejściem, i < zmniejsza go. Ta wartość jest podawana do funkcji po lewej stronie.
• \> zwiększa wartość (przynajmniej raz), dopóki funkcja po prawej stronie nie da prawdziwej wartości.
• Funkcja testowa to kompozycja (wg & -ami) czterech funkcji.
• 0~j konwertuje na ciąg.
• u usuwa zduplikowane cyfry.
• > usuwa nagłówek powstałego ciągu.
• Njest logiczną negacją: daje 1pusty ciąg i 0niepuste. W ten sposób funkcja sprawdza cyfrę powtórzenia, a wynikiem \jest kolejne liczenie powtórzeń od<i .
• )-odejmuje wynik od funkcji wejściowej, to znaczy <i.
• Ta różnica jest <zmniejszona o jeden, więc zmniejsza się. Na koniec pdrukuje wynik.

PowerShell v2 +, 66 bajtów

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

Zwykle dobry do gry w golfa bardzo luźny rzut PowerShell jest tutaj poważnym minusem.

Pobiera dane wejściowe $njako ciąg znaków i wchodzi w forpętlę. W kroku konfiguracji wyodrębniamy pierwszy znak $n[0], ale musimy go przekonwertować z powrotem na ciąg "$(...)"przed rzutowaniem jako int +i zapisaniem w $x. W przeciwnym razie późniejsza arytmetyka będzie używać wartości ASCII kodu char.

Warunkowe sprawdza, czy łańcuch skonstruowany z $n.length "$x"s, tymczasowo przechowywany w $y, jest mniejszy niż $n. Dopóki tak nie jest, zwiększamy$x++ , ustawiając warunek dla następnej pętli.

Na przykład dla danych wejściowych 123wartość $ypierwszego sprawdzenia stanu warunkowego będzie 111mniejsza niż $n, więc pętla będzie kontynuowana. W ciele pętli nie ma nic, więc następuje krok przyrostu $x++, a następnie warunek jest ponownie sprawdzany. Ten czas $yjest równy 222, która jest większa niż $n, więc w wygaśnięciem pętli. Jeśli dane wejściowe są już repdigit, warunek nie jest spełniony, ponieważ w tym momencie $yjest równy$n .

Po wyjściu z pętli rzucamy $yna liczbę całkowitą +, a następnie odejmujemy $n. Ten wynik pozostaje w potoku, a dane wyjściowe są niejawne.

PHP 5.6, 59 53 51 50 bajtów

Zaoszczędź 6 8 bajtów dzięki @manatwork.

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

Testuj z:

php test.php 11132

count_chars()Funkcja z 3, a drugi parametr zwraca łańcuch znaków wyróżniających znaków łańcucha. Gdy ten łańcuch ma 1 znak ( [1]zwróci false, gdy ma długość 1), następnie wykonaj echo $b, w przeciwnym razie zwiększ $bi zapętl ponownie.

MATL , 10 bajtów

q`QtVda}G-

Wypróbuj online!

To zwiększa wartość wejściową, dopóki wszystkie cyfry nie będą równe, więc będzie wolno. Przypadek testowy dla limitów wejściowych 87654321w kompilatorze online.

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 znaki

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

Oczekuje wprowadzenia ciągu.

Przykładowy przebieg:

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

Ruby, 39 znaków

Wywołanie rekurencyjne, działa na „SystemStackError: poziom stosu zbyt głęboki” przy większych wynikach.

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

Przykładowy przebieg:

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 bajtów

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

Z powodu pętli while jest raczej powolna ...

Wyjaśnienie

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

Oszczędność jednego bajtu dzięki @Luis Mendo .

Przewyższać, 85 79 bajtów

Umieść następującą formułę w dowolnej komórce oprócz komórki, Nponieważ jest to nazwa referencyjnej komórki wejściowej:

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

Wyjaśnienie:

• Njest wejściem, a także nazwą komórki odniesienia .
• LEFT(N) weź pierwszą cyfrę wartości wejściowej.
• LEN(N) zwraca długość wartości wejściowej.
• REPT(LEFT(N),LEN(N))powtórz pierwszą cyfrę LEN(N)razy wartość wejściową i pomnóż ją przez 1, aby przekonwertować format tekstu na format liczb, abyśmy mogli go użyć do porównania liczb.
• Składnia funkcji JEŻELI w programie Microsoft Excel jest następująca: JEŻELI (warunek, [wartość_jeśli_prawda], [wartość_jeśli_fałsz]) , dlatego cała formuła jest oczywista.

Brachylog v2, 6 bajtów

;.+=∧ℕ

Wypróbuj online!

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

5-bajtowi +↙.=∧pomija się pomijanie, ℕponieważ w ogóle nie wypróbowuje wyników dodatnich, ale kończy się niepowodzeniem, gdy podano liczbę, która jest już powtórką, ponieważ w ogóle nie wypróbowuje wyników dodatnich.

Java, 59 bajtów

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

(Nadal nie jestem pewien, jak liczyć wpisy Java, ale zgodnie ze standardowym zestawem pierwszego wpisu Java , ten wpis ma 59 bajtów, ponieważ jest 17 bajtów krótszy).

W każdym razie, jeśli mamy powtórkę, zwróć 0, w przeciwnym razie dodaj 1 do wejścia, wywołaj siebie i dodaj 1 do wyniku.

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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));
  }
}

Wydajność:

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

Jak widać, ostatni wpis zabraknie pamięci, zanim będzie mógł się zakończyć. (Bardzo właściwe) StackOverflowErrorjest wyrzucany z java.util.regex.Pattern.sequence(Pattern.java:2134), ale jestem przekonany, nie ma nic złego w samej regex, ponieważ jest to ten sam użyłem w moim poprzednim wpisie .

C #, 82 bajty

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

C, 84 bajtów

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

Test główny:

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 bajtów

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.

Wypróbuj online!