Để vinh danh bao nhiêu đại diện tôi đã có vài giờ trước, khi tôi lần đầu tiên nghĩ về thử thách này:

Số như thế này mà được tạo thành từ một chữ số duy nhất lặp lại được gọi là repdigits . Repdigits là niềm vui! Mỗi cơ thể sẽ được hạnh phúc hơn nếu số lượng đại diện họ đã là một repdigit ¹ , nhưng tôi thiếu kiên nhẫn, vì vậy bạn cần phải giúp tôi tìm ra cách nhanh nhất để có được một repdigit.

Đây là thử thách của bạn:

Với một số nguyên dương đại diện cho danh tiếng, hãy đưa ra số lượng đại diện tối thiểu mà họ cần đạt được để có được một chữ số. Ví dụ, tại thời điểm viết thử thách này, người dùng Martin Ender có 102.856 đại diện. Chữ số gần nhất là 111.111, vì vậy anh ta sẽ cần đạt được: 8255 rep để ở một chữ số.

Vì mọi người không thích mất đại diện, chúng tôi sẽ chỉ xem xét các thay đổi không tiêu cực. Điều này có nghĩa là, ví dụ, nếu ai đó ở mức 12 rep, thay vì mất 1 rep, giải pháp là kiếm được 10 rep. Điều này cho phép '0' là đầu ra hợp lệ, vì bất kỳ ai có 111 rep đều đã có mã số.

Đầu vào và đầu ra có thể ở bất kỳ định dạng hợp lý nào và vì không thể có ít hơn 1 đại diện trên bất kỳ trang web Stack Exchange nào, bạn có thể cho rằng không có đầu vào nào sẽ nhỏ hơn 1.

Một cornercase cần lưu ý:

Nếu người dùng có ít hơn 10 đại diện, họ đã ở một số kỹ thuật số và do đó họ cũng cần '0'.

Kiểm tra IO:

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

Các sơ hở tiêu chuẩn được áp dụng và giải pháp ngắn nhất tính theo byte sẽ thắng!

Thạch , 6 byte

DE$1#_

Đầu ra là một mảng đơn.

Hãy thử trực tuyến! hoặc xác minh hầu hết các trường hợp thử nghiệm . Trường hợp thử nghiệm 87654321 là quá chậm đối với TIO.

Làm thế nào nó hoạt động

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 byte

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

Dùng thử trực tuyến

Brachylog , 9 byte

:.#++#==,

Hãy thử trực tuyến!

Điều này là khá hiệu quả vì nó sử dụng các số học ràng buộc.

Giải trình

:.            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 byte

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

Không phải là cách tiếp cận ngắn nhất, nhưng rất hiệu quả. Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Đối với 10**len(`n`)vòng đầu vào n lên đến công suất gần nhất là 10 . Sau đó, chúng tôi chia kết quả cho 9 . Điều này trả về chữ số 1 số 1 có nhiều chữ số như n . Chúng tôi lưu kết quả trong r . Ví dụ: nếu n = 87654321 , thì r = 11111111 .

Các chữ số mong muốn sẽ là bội số hoặc r . Để quyết định, chúng tôi thực hiện phép chia trần của n theo r . Vì các /tầng toán tử phân chia của Python 2 , điều này có thể đạt được -n/r, sẽ mang lại giá trị tuyệt đối chính xác, với dấu âm. Ví dụ: nếu n = 87654321 , điều này sẽ trả về -8 .

Cuối cùng, chúng tôi nhân thương số được tính bằng -r để lặp lại thương số một lần cho mỗi chữ số trong n . Ví dụ: nếu n = 87654321 , giá trị này trả về 88888888 , đây là chữ số mong muốn.

Cuối cùng, để tính mức tăng yêu cầu, chúng tôi trừ n từ kết quả trước đó. Ví dụ của chúng tôi n = 87654321 , điều này trả về 1234567 , như mong muốn.

Python 2, 37 byte

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

Kiểm tra nó trên Ideone . Lưu ý rằng phương pháp này quá kém hiệu quả đối với trường hợp thử nghiệm 87654321 .

Làm thế nào nó hoạt động

Nếu n đã là một chữ số, 1-len(set(`n`))sẽ trả về 0 vì độ dài của tập hợp các chữ số của n trong cơ sở 10 sẽ là 1 . Trong trường hợp này, f trả về 0 .

Nếu n không phải là số lặp lại, hãy f(n+1)gọi đệ quy f với giá trị có thể tiếp theo là n . -~increments giá trị trở lại của f ( 0 khi một repdigit được tìm thấy) bằng 1 mỗi lần f được gọi là đệ quy, do đó giá trị trả về thức tương đương với số lần f đã được gọi là, ví dụ, số lần n phải được tăng lên đến có được một chữ số.

Perl 6 , 23 byte

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

Một lambda lấy số đầu vào làm đối số và trả về kết quả.

Giải trình:

1. Sử dụng ...toán tử chuỗi để tăng số đầu vào cho đến khi nó đạt đến một chữ số (được kiểm tra bằng cách chia đại diện chuỗi của nó thành các ký tự và xem liệu chúng có bằng nhau không) .
2. Trừ một từ chiều dài của chuỗi.

Java 7, 116 76 byte

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

Đã sử dụng cách tiếp cận tuyệt vời của @Dennis để giảm số lượng byte bằng một con số khổng lồ 40 byte.

Các trường hợp bất ngờ & thử nghiệm:

Hãy thử nó ở đây.

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

Đầu ra:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 bytes

1 byte thanks to @FryAmTheEggman.

-f@F`TQ

Try it online.

Very inefficient, loops through all numbers from the input to the next repdigit.

Brain-Flak 690 358 bytes

Đây là tôi đi

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

Dùng thử trực tuyến

Giải trình

Bắt đầu bằng cách tạo một bản sao thứ hai của đầu vào nhỏ hơn một bản gốc. Chúng tôi sẽ sử dụng bản sao để tìm kiếm các chữ số tiếp theo. Chúng tôi trừ đi một trong trường hợp số đó là một chữ số

(({})[()])

Đẩy một cái để thỏa mãn vòng lặp sắp tới. (không phải là một không chỉ là không)

(())

Vòng lặp này sẽ chạy cho đến khi có một chữ số trên đầu ngăn xếp

{

Pop tào lao. Chúng là một "boolean" trên đầu điều khiển vòng lặp, vì chúng tôi không còn cần thiết nữa.

{}

Thêm một và nhân đôi trên cùng. Bản sao sẽ được phân tách thành các chữ số của nó.

(({}()))

Trong khi bản sao không bằng ...

{

Sao chép lại

(({}))

Mod 10 và chuyển sang stack khác

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

Chia cho 10 (chia số nguyên)

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

}

Pop số 0 đó là bản sao của chúng tôi

{}

Bây giờ chúng tôi đã phân tách số thành 10 chữ số cơ bản của nó, vì vậy chúng tôi trao đổi sang ngăn xếp với tất cả các chữ số.

<>

Trong khi chữ số hàng đầu không bằng không

{

Chúng tôi chọn một bản sao của chiều cao ngăn xếp (tức là số chữ số) ...

(([])<

Âm thầm trừ một từ mỗi số trên ngăn xếp

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

Đặt chiều cao ngăn xếp chúng tôi nhặt lên. (và trao đổi với ngăn xếp khác)

><>)

Chúng tôi sử dụng chiều cao ngăn xếp để kéo tất cả các chữ số chúng tôi đặt trên ngăn xếp khác trở lại ngăn xếp thích hợp.

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

Pop số 0 đó là chiều cao ngăn xếp của chúng tôi

{}

Trao đổi trở lại vào ngăn xếp với các chữ số (hoặc các chữ số là gì)

<>

Kết thúc vòng lặp

}

Bây giờ chúng tôi đã trừ chữ số hàng đầu khỏi tất cả các chữ số khác. Nếu tất cả các chữ số bằng 0, số ban đầu (không phải đầu vào mà là số chúng tôi đang kiểm tra) là một chữ số. ^{[cần dẫn nguồn]} . Vì vậy, chúng ta cần kiểm tra các số không.

Trong khi chiều cao ngăn xếp không bằng không

([])
{
{}

Nếu chữ số không bằng 0, di chuyển nó sang ngăn xếp khác và thay thế bằng số không.

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

Pop nó (bây giờ là số không)

{}

Kết thúc vòng lặp

([])
}
{}

Đổi sang ngăn xếp khác (duh ..)

<>

Lấy bản sao của chúng tôi một bản sao của chiều cao ngăn xếp trừ hai

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

Trong khi chiều cao ngăn xếp không phải là hai (bản gốc và bộ tích lũy)

{
{}

Bật đầu

{}

Kết thúc một lúc

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

Đặt bản sao của chúng tôi về chiều cao ngăn xếp trừ hai. Điều này kết thúc là số chữ số không giống với chữ số đầu tiên. Nói cách khác, nếu nó bằng không, nó là một chữ số.

>)

Nếu vòng lặp này kết thúc, chúng tôi đã tìm thấy một chữ số

}

Pop "boolean"

{}

Trừ bản gốc khỏi chữ số

({}[{}])

Python 2, 52 byte

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

Python 2 có một số thủ thuật làm cho nó ngắn hơn. Ví dụ: đầu vào là số, vì vậy chúng ta không cần truyền sang int. (-5 byte) Chúng tôi cũng không cần đặt dấu ngoặc đơn xung quanh a-b(-1 byte)

Sử dụng tập lệnh này để xác minh tất cả các trường hợp thử nghiệm:

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

Bạn cũng có thể thử nó trực tuyến!

GNU sed, 223 + 1 (cờ r) = 224 byte

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

Chạy:

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

Đầu ra:

110

Đây là một giải pháp sed thuần túy , số học được mô phỏng chỉ sử dụng các biểu thức thông thường. Các thuật toán hoạt động như sau:

1. định dạng không gian mẫu được đặt thành ^current_reputation:needed_reputation%$
2. trong mỗi lần lặp của vòng lặp chính tách được bật:
   a) %:áp dụng thặng dư để needed_reputation
   b) :%áp dụng thặng dư để current_reputation
3. nếu current_reputation là một "repdigit", các needed_reputation được in và chương trình đầu

Java, 74 72 byte

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

(Nếu mục nhập Java khác là 76 byte, thì mục này là74 72, vì nó hai ngắn hơn bốn byte).

Dù sao, chỉ cần tăng đầu vào cho đến khi nó là một chữ số trong khi tăng bộ đếm. Trả lại quầy.

Vâng, đó là ba điểm cộng liên tiếp, hai để tăng đầu vào, một để nối một chuỗi trống để biến nó thành một chuỗi.
Không, tôi không nghĩ nó sẽ hợp pháp nếu không có khoảng trống ở giữa, nhưng bạn sẽ đi. Đó là những gì một lỗi đánh máy sẽ làm cho bạn: ngắn hơn một byte.

Sử dụng vòng lặp for thay vì mất một khoảng thời gian chính xác là nhiều byte:

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

Chỉnh sửa:

Một phiên bản trước đó phải matches("^(\\d)\\1*$")kiểm tra một chữ số, nhưng vì chúng ta chỉ cần chuyển đổi một int thành một chuỗi, sử dụng một .để khớp là đủ.

Các trường hợp bất ngờ & thử nghiệm:

Hãy thử nó ở đây.

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

}

Đầu ra:

0
11
109
1234567
2
2222
11090

R, 102 98 91 byte

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

Ung dung:

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

Loay hoay với định dạng ( as.numericvàas.character ) thêm một số byte, nhưng R không thực sự linh hoạt!

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

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

Nếu in không có gì thay vì 0khi số đã là một chữ số được chấp nhận, thì 37 byte là đủ:

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

Chạy với -n(1 byte) và -Ehoặc -M5.010(miễn phí):

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

Giải thích : có hai phần chính trong mã: /^(.)\1*$/&&say$vvà $_++&&++$v&&redo. Thử nghiệm đầu tiên nếu $_là một kỹ thuật số; nếu có, nó sẽ in số chúng tôi đã thêm vào số ban đầu để biến nó thành số kỹ thuật số ( $v) và nếu không, chúng tôi có 1 cho cả hai $_và $v, và bắt đầu lại.

JavaScript (ES6), 42 byte

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

Explanation: Recursively computes p as the next power of 10 after n. The digit to be repeated is then computed as 1+floor(9n/p), and the repunit is simply (p-1)/9, from which the result follows.

05AB1E, 10 6 bytes

∞.Δ+Ë

Try it online!

Explanation

∞<      # 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

Try it here!

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

Actually, 15 bytes

;D;WXu;$╔l1<WX-

Try it online!

Explanation:

;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

Jellyfish, 20 bytes

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

Try it online! TIO can't handle the longer test cases, but given enough time and memory, they should work too.

Explanation

• i is input, and < decrements it. This value is fed to the function on the left.
• \> increments the value (at least once) until the function to the right gives a truthy value.
• The test function is a composition (by &s) of four functions.
• 0~j converts to string.
• u removes duplicate digits.
• > removes the head of the resulting string.
• N is logical negation: it gives 1 for an empty string, and 0 for non-empty. Thus the function tests for a rep-digit, and the result of \ is the next rep-digit counting from <i.
• )- subtracts the result from the function input, that is, <i.
• This difference is off by one, so < decrements it. Finally, p prints the result.

PowerShell v2+, 66 bytes

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

The usually-good-for-golf very loose casting of PowerShell is a major downfall here.

Takes input $n as a string, and enters a for loop. For the setup step, we extract out the first character $n[0], but have to convert it back to a string "$(...)" before casting as an int + and saving into $x. Otherwise, the later arithmetic will be using the ASCII value of the char-code.

The conditional checks whether a string constructed from $n.length "$x"s, temporarily stored in $y, is less-than $n. So long as it's not, we increment $x++, setting up the conditional for the next loop.

For example, for input 123, the value of $y when the conditional is first checked will be 111, which is less-than $n, so the loop continues. There's nothing in the loop body, so the step increment happens $x++, then the conditional is checked again. This time $y equals 222, which is greater than $n, so the loop terminates. If the input is already a repdigit, the conditional is not satisfied, because at that point $y is equal to $n.

Once out of the loop, we cast $y to an integer +, then subtract $n. That result is left on the pipeline and output is implicit.

PHP 5.6, 59 53 51 50 bytes

Saved 6 8 bytes thanks to @manatwork.

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

Test with:

php test.php 11132

The count_chars() function with 3 as the second parameter returns a string with the distinct characters in a string. When this string is 1 character long ([1] will return false when it's length 1) then echo $b, otherwise increment $b and loop again.

MATL, 10 bytes

q`QtVda}G-

Try it online!

This keeps incrementing the input until all digits are equal, so it's slow. The test case for input 87654321 times out in the online compiler.

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 characters

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

Expects string input.

Sample run:

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

Ruby, 39 characters

Recursive call, runs into “SystemStackError: stack level too deep” on bigger results.

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

Sample run:

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)

Because of the while loop it's rather slow...

Explanation

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

Saving one byte thanks to @Luis Mendo.

Excel, 85 79 bytes

Put the following formula in any cell except cell N since it's a name for reference cell of input:

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

Explanation:

• N is the input and also name of reference cell.
• LEFT(N) take the first digit of input value.
• LEN(N) return the length of input value.
• REPT(LEFT(N),LEN(N)) repeat the first digit of input value LEN(N) times and multiply it by 1 to convert text format to number format so we can use it for number comparison.
• The syntax for the IF function in Microsoft Excel is: IF( condition, [value_if_true], [value_if_false]), hence makes the whole formula is self-explanatory.

Brachylog v2, 6 bytes

;.+=∧ℕ

Try it online!

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

The 5-byte +↙.=∧ gets away with omitting ℕ because it doesn't try non-positive outputs at all, but it also fails when given a number which is already a repdigit because it doesn't try non-positive outputs at all.

Java, 59 bytes

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

(I'm still not sure how to count Java entries, but according to the standard set by the first Java entry, this entry is 59 bytes, since it's 17 bytes shorter).

Anyway, if we have a repdigit, return 0, else add 1 to the input, call itself and add 1 to the result.

Ungolfed & test cases:

Try it here.

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

Output:

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

As you can see, the last entry runs out of memory before it can finish. The (very appropriate) StackOverflowError is thrown from java.util.regex.Pattern.sequence(Pattern.java:2134), but I'm pretty confident there's nothing wrong with the regex itself, since it's the same one I used in my previous entry.

C#, 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;}}

Test main:

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.

Try it online!