[Question]
  [
In honor of how much rep I had several hours ago, when I first thought of this challenge:
[![enter image description here](https://i.stack.imgur.com/HftMG.png)](https://i.stack.imgur.com/HftMG.png)
Numbers like this that are made up of a single digit repeating are called [repdigits](https://en.wikipedia.org/wiki/Repdigit). Repdigits are fun! Every body would be more happy if the amount of rep they had was a repdigit[¹](https://xkcd.com/285/), but I am impatient, so you need to help me find out the fastest way to get to a repdigit.
Here is your challenge:
Given a positive integers representing reputation, output the minimum amount of rep they need to *gain* to get to a repdigit. For example, at the time of writing this challenge, user [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender) had 102,856 rep. The nearest rep-digit is 111,111, so he would need to gain: 8255 rep to be at a repdigit.
Since people dislike losing rep, we will only consider non-negative changes. This means that, for example, if someone is at 12 rep, rather than losing 1 rep, the solution is to gain 10 rep. This allows '0' to be a valid output, since anyone who has 111 rep is *already* at a repdigit.
Input and output can be in [any reasonable format](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods), and since it is impossible to have less than 1 rep on any Stack Exchange site, you can assume no inputs will be less than 1.
One cornercase to note:
If a user has less than 10 rep, they are already at a repdigit, and so they also need '0'.
# Test IO:
```
#Input      #Ouput
8           0
100         11
113         109
87654321    1234567
42          2
20000       2222
11132       11090
```
Standard loopholes apply, and the shortest solution in bytes wins!
  
[Answer]
# Haskell, 39 bytes
```
until(((==).head>>=all).show)(+1)>>=(-)
```
[Try it online](http://ideone.com/fork/Xz4qy3)
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 9 bytes
```
:.#++#==,
```
[Try it online!](http://brachylog.tryitonline.net/#code=Oi4jKysjPT0s&input=ODc2NTQzMjE&args=Wg)
This is pretty efficent as it makes use of constraints arithmetic.
### Explanation
```
:.            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.
```
[Answer]
# Python 2, ~~41~~ 40 bytes
```
def f(n):r=10**len(`n`)/9;print-n/r*-r-n
```
Not the shortest approach, but very efficient. Test it on [Ideone](http://ideone.com/KEo0kt).
### How it works
For input `10**len(`n`)` rounds **n** up to the nearest power of **10**. Afterwards, we divide the result by **9**. This returns the repdigit **1…1** that has as many digits as **n**. We save the result in **r**. For example, if **n = 87654321**, then **r = 11111111**.
The desired repdigit will be a multiple or **r**. To decide which, we perform ceiling division of **n** by **r**. Since Python 2's division operator `/` floors, this can be achieved with `-n/r`, which will yield the correct absolute value, with negative sign. For example, if **n = 87654321**, this will return **-8**.
Finally, we multiply the computed quotient by **-r** to repeat the quotient once for each digit in **n**. For example, if **n = 87654321**, this returns **88888888**, which is the desired repdigit.
Finally, to calculate the required increment, we subtract **n** from the previous result. For our example **n = 87654321**, this returns **1234567**, as desired.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
DE$1#_
```
Output is a singleton array.
[Try it online!](http://jelly.tryitonline.net/#code=REUkMSNf&input=&args=MTEz) or [verify most test cases](http://jelly.tryitonline.net/#code=REUkMSNfCjsiw4figqxH&input=&args=OCwgMTAwLCAxMTMsIDQyLCAyMDAwMCwgMTExMzI). Test case **87654321** is too slow for TIO.
### How it works
```
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.
```
[Answer]
# Python 2, 37 bytes
```
f=lambda n:1-len(set(`n`))and-~f(n+1)
```
Test it on [Ideone](http://ideone.com/1rF6OB). Note that this approach is too inefficient for test case **87654321**.
### How it works
If **n** is already a repdigit, `1-len(set(`n`))` will return **0** since the length of the set of **n**'s digits in base 10 will be **1**. In this case, **f** returns **0**.
If **n** is not a repdigit, `f(n+1)` recursively calls **f** with the next possible value of **n**. `-~` increments the return value of **f** (**0** when a repdigit is found) by **1** each time **f** is called recursively, so the final return value equals the number of times **f** has been called, i.e., the number of times **n** had to be incremented to get a repdigit.
[Answer]
# [Perl 6](http://perl6.org/), 23 bytes
```
{($_...{[==] .comb})-1}
```
A lambda that takes the input number as argument, and returns the result.
Explanation:
1. Uses the `...` sequence operator to increment the input number until it reaches a repdigit *(tested by splitting its string representation into characters and seeing if they're all equal)*.
2. Subtracts one from the length of the sequence.
[Answer]
# Java 7, ~~116~~ 76 bytes
```
int c(int i){int r=(int)Math.pow(10,(i+"").length())/9;return(-i/r-1)*-r-i;}
```
Used [*@Dennis*' amazing approach](https://codegolf.stackexchange.com/a/90900/52210) to lower the byte-count by a whopping 40 bytes.
**Ungolfed & test cases:**
[Try it here.](https://ideone.com/febPRq)
```
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));
  }
}
```
**Output:**
```
0
11
109
1234567
2
2222
11090
```
[Answer]
# Pyth, ~~9~~ ~~8~~ 7 bytes
*1 byte thanks to @FryAmTheEggman.*
```
-f@F`TQ
```
[Try it online.](http://pyth.herokuapp.com/?code=-f%40F%60TQ&input=113)
Very inefficient, loops through all numbers from the input to the next repdigit.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak) ~~690~~ 358 bytes
Here's my go at it
```
(({})[()])(()){{}(({}())){(({}))(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)}{}<>{(([])<{{}({}[()]<>)<>([])}{}><>){({}[()]<({}<>)<>>)}{}<>}([]){{}{(<({}<>)<>>)}{}([])}{}<>(([][()()])<{{}{}([][()()])}{}>)}{}({}[{}])
```
[Try It Online](http://brain-flak.tryitonline.net/#code=KCh7fSlbKCldKSgoKSl7e30oKHt9KCkpKXsoKHt9KSkoPCgoKCkoKSgpKCkoKSl7fTw-KT4pPD57KHt9WygpXSk8Pigoe30oKVsoe30pXSkpe3t9KDwoe30oe30pKT4pfXt9PD59e308Pih7fTx7fT4pPD4oPCgoKCkoKSgpKCkoKSl7fSg8PikpPik8Pnsoe31bKCldKTw-KCh7fSgpWyh7fTwoe30oKSk-KV0pKXt7fSg8KHt9KHt9PCh7fVsoKV0pPikpPil9e308Pn17fTw-e317fSh7fTw-KX17fTw-eygoW10pPHt7fSh7fVsoKV08Pik8PihbXSl9e30-PD4peyh7fVsoKV08KHt9PD4pPD4-KX17fTw-fShbXSl7e317KDwoe308Pik8Pj4pfXt9KFtdKX17fTw-KChbXVsoKSgpXSk8e3t9e30oW11bKCkoKV0pfXt9Pil9e30oe31be31dKQ&input=MTEy)
### Explanation
Start by making a second copy of the input that is one less than the original. We will use the copy to search for the next repdigit. We subtract one in case the number itself was a repdigit
```
(({})[()])
```
Push one to satisfy the coming loop. (doesn't have to be one just not zero)
```
(())
```
This loop will run until there is a repdigit on top of the stack
```
{
```
Pop the crap. Their is a "boolean" on top that drives the loop, since it is no longer needed we pop it.
```
{}
```
Add one and duplicate the top. The copy will be decomposed into its digits.
```
(({}()))
```
While the copy is not zero...
```
{
```
Copy again
```
(({}))
```
Mod 10 and move to the other stack
```
(<((()()()()()){}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}{}<>({}<{}>)<>
```
Divide by 10 (Integer division)
```
(<((()()()()()){}(<>))>)<>{({}[()])<>(({}()[({}<({}())>)])){{}(<({}({}<({}[()])>))>)}{}<>}{}<>{}{}({}<>)
}
```
Pop the zero that was our copy
```
{}
```
We have now decomposed the number into its base 10 digits, So we swap over to the stack with all the digits.
```
<>
```
While the leading digit is not zero
```
{
```
We pick up a copy of the stack height (i.e. the number of digits)...
```
(([])<
```
Silently subtract one from every number on the stack
```
{
{}
({}[()]<>)<>
([])
}
{}
```
Put the stack height we picked up down. (and swap to the other stack)
```
><>)
```
We use the stack height to pull all the digits we placed on the other stack back onto the proper stack.
```
{
({}[()]<({}<>)<>>)
}
```
Pop the zero that was our stack height
```
{}
```
Swap back onto the stack with the digits (or what were the digits)
```
<>
```
End loop
```
}
```
Now we have subtracted the top digit from all the other digits. If all the digits are zero the orginal number (not the input but the number we are checking) was a repdigit.[citation needed]. So we need to check for non-zeroes.
While the stack height is not zero
```
([])
{
{}
```
If the digit is not zero move it to the other stack and replace it with a zero.
```
{
(<({}<>)<>>)
}
```
Pop it (now it is a zero)
```
{}
```
End loop
```
([])
}
{}
```
Swap over onto the other stack (duh..)
```
<>
```
Grab our selves a copy of the stack height minus two
```
(([][()()])<
```
While the stack height is not two (the original and the accumulator)
```
{
{}
```
Pop the top
```
{}
```
End the while
```
([][()()])
}
{}
```
Put down our copy of the stack height minus two. This ends up being the number of digits that are not the same as the first digit. In other words if it is zero it is a repdigit.
```
>)
```
If this loop ends we have found a repdigit
```
}
```
Pop the "boolean"
```
{}
```
Subtract the original from the repdigit
```
({}[{}])
```
[Answer]
# Python 2, 52 bytes
```
a=b=input()
while len(set(str(a)))!=1:a+=1
print a-b
```
Python 2 has several tricks that make this shorter. For example, input is numeric, so we don't need to cast to int. (-5 bytes) We also don't need to put parenthesis around the `a-b` (-1 byte)
Use this script to verify all test cases:
```
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])
```
You may also [try it online!](https://ideone.com/7ZVxZq)
[Answer]
## 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
```
**Run:**
```
sed -rf repdigit.sed <<< "112"
```
**Output:**
```
110
```
This is a **pure sed solution**, the arithmetic is simulated using regular expressions only. The algorithm works as follows:
1. the pattern space format is set to `^current_reputation:needed_reputation%$`
2. in each iteration of the main loop the separators are switched:  
a) `%:` applies the increment to *needed\_reputation*  
b) `:%` applies the increment to *current\_reputation*
3. if the *current\_reputation* is a "repdigit", the *needed\_reputation* is printed and the program ends
[Answer]
## 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](https://support.office.com/en-us/article/Define-and-use-names-in-formulas-4d0f13ac-53b7-422e-afd2-abd7ff379c64).
* `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.
[Answer]
## 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.
[Answer]
# Java, ~~74~~ 72 bytes
```
int c(int i){int n=0;while(!(i+++"").matches("^(.)\\1*$"))n++;return n;}
```
*(If [the other Java entry](https://codegolf.stackexchange.com/a/90903/14150) is 76 bytes, this one is ~~74~~ 72, since it's ~~two~~ four bytes shorter).*
Anyway, just increment the input until it's a repdigit while incrementing a counter. Return the counter.
Yes, those are three pluses in a row, two to increment the input, one to concatenate an empty string to make it a string.  
No, I didn't think it would be legal without a space in between either, but there you go. That's what a typo will do for you: one byte shorter.
Using a for-loop instead of a while takes exactly as many bytes:
```
int c(int i){int n=0;for(;!(i+++"").matches("^(.)\\1*$");n++);return n;}
```
---
## *Edit:*
*An earlier version had `matches("^(\\d)\\1*$")` to check for a repdigit, but since we've just converted an int to a string, using a `.` to match is enough.*
---
**Ungolfed & test cases:**
[Try it here.](https://ideone.com/WxwK24)
```
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));
  }
```
}
**Output:**
```
0
11
109
1234567
2
2222
11090
```
[Answer]
# 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
```
Messing around with the format (~~`as.numeric` and `as.character`~~) adds some bytes, but **R** is not really flexible !
[Answer]
## Perl, 40 + 1 (`-n`) = 41 bytes
```
/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo
```
If printing nothing instead of `0` when the number is already a repdigit is acceptable, then 37 bytes are enough :
```
/^(.)\1*$/&&say$v or$_++&&++$v&&redo
```
Run with `-n` (1 byte) and `-E` or `-M5.010` (free) :
```
perl -nE '/^(.)\1*$/&&say($v|0) or$_++&&++$v&&redo'
```
**Explanations** : there are two major parts in the code : `/^(.)\1*$/&&say$v` and `$_++&&++$v&&redo`. The first one test if `$_` is a repdigit; if yes it prints the number we added to the original number to make it a repdigit (`$v`), and if no, we had 1 to both `$_` and `$v`, and start over.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~10~~ 6 bytes
```
∞.Δ+Ë
```
[Try it online!](https://tio.run/##yy9OTMpM/f//Ucc8vXNTtA93//9vaGhobAQA "05AB1E – 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
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 6 bytes
```
λ?+≈;ṅ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%CE%BB%3F%2B%E2%89%88%3B%E1%B9%85&inputs=113&header=&footer=)
[Answer]
## Pyke, ~~13~~ 11 bytes
```
o+`}ltIr)ot
```
[Try it here!](http://pyke.catbus.co.uk/?code=o%2B%60%7DltIr%29ot&input=13&warnings=0)
```
            - o = 0
o+          -     o++ + input
  `         -    str(^)
   }        -   deduplicate(^)
    lt      -  len(^)-1
      I )   - if ^:
       r    -  goto_start()
         ot - o++ -1
```
[Answer]
## Actually, 15 bytes
```
;D;WXu;$╔l1<WX-
```
[Try it online!](http://actually.tryitonline.net/#code=O0Q7V1h1OyTilZRsMTxXWC0&input=MTAw)
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
```
[Answer]
## [Jellyfish](https://github.com/iatorm/jellyfish), 20 bytes
```
p
<
)\&&&~j<i
->N>u0
```
[Try it online!](http://jellyfish.tryitonline.net/#code=cAo8CilcJiYmfmo8aQotPk4-dTA&input=MTExMzI)
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.
[Answer]
# 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.
[Answer]
# [MATL](http://github.com/lmendo/MATL), 10 bytes
```
q`QtVda}G-
```
[Try it online!](http://matl.tryitonline.net/#code=cWBRdFZkYX1HLQ&input=MTEz)
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
```
[Answer]
# 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](https://codegolf.stackexchange.com/a/90903/14150), 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.](https://ideone.com/ls3LWd)
```
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](https://codegolf.stackexchange.com/a/90960/14150).
[Answer]
# 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
```
[Answer]
## 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](https://codegolf.stackexchange.com/users/36398/luis-mendo).*
[Answer]
## JavaScript (ES6), 42 bytes
```
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.
[Answer]
## 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!](http://swish.swi-prolog.org/p/PCG%3Arepdigit.pl)
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog) v2, 6 bytes
```
;.+=∧ℕ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6OmpgggXwPIs47QLlfSVHq4q7P24dYJ/631tG0fdSx/1DL1//9oCx1DAwMdQ0NjHQtzM1MTYyNDHRMjHSMDA7CoobFRLAA "Brachylog – Try It Online")
```
  +       The sum of
          the input
;         and
 .        the output
   =      is a repdigit,
    ∧     and
          the output
     ℕ    is a whole number.
```
The 5-byte [`+↙.=∧`](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRu/6htw6OmpgggXwPIs47QLlfSVHq4q7P24dYJ/7Uftc3Us33Usfz//2gLHUMDAx1DQ2MdC3MzUxNjI0MdEyMdIwMDsKihsVEsAA) 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.
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 54 bytes
```
: f 0 over s>f flog f>s 1+ 0 do 10 * 1- loop mod abs ;
```
[Try it online!](https://tio.run/##LYzLDoIwEEX3fMUJSw2kQ1EbSfgXFYsLzDQF/f06JG7OfUzmRs3bq5njLqVciTj0@8ysYyQuOhPHFTlaPSniOCANi2rirRO3@8pgb4npkwi0mbaGZqS2qZZHZqgCqRLndoo3hsv51PtOzPadoXPufxVvmfID "Forth (gforth) – Try It Online")
### Explanation
* Gets the smallest repdigit of the same length as the input.
* Negates the result and gets the remainder of dividing the input by that number.
* Returns the absolute value of the result (since positive modulo negative is negative)
### Code Explanation
```
: f                \ start a new word definition
  0 over           \ place 0 on stack and copy input back to top
  s>f flog f>s     \ move number to floating point stack, get log10, move back to stack (truncate)
  1+               \ add 1 to get number of digits
  0 do             \ start a loop from 0 to number of digits - 1
    10 * 1-        \ repeatedly multiply by 10 and subtract 1 to get smallest repdigit of that size
  loop             \ end loop
  mod abs          \ get that absolute value of input modulo result
;                  \ end the word definition
   
 
```
]