В честь того, сколько повторений у меня было несколько часов назад, когда я впервые подумал об этом вызове:

Подобные числа, состоящие из повторяющихся однозначных чисел, называются репигитами . Repdigits это весело! Каждое тело было бы более счастливым , если сумма повторении они имели , было репдигиты ¹ , но я нетерпелив, так что вам нужно , чтобы помочь мне выяснить , самый быстрый способ добраться до репдигитов.

Вот ваш вызов:

С учетом положительных целых чисел, представляющих репутацию, выведите минимальное количество повторений, которое они должны получить, чтобы получить репутацию. Например, на момент написания этого задания у пользователя Мартина Эндера было 102 856 респ. Ближайшая цифра повторения - 111 111, поэтому ему нужно набрать 8255 повторений, чтобы быть на повторной цифре.

Поскольку людям не нравится терять репутацию, мы будем рассматривать только неотрицательные изменения. Это означает, что, например, если кто-то находится на 12 повторениях, а не теряет 1 повтор, решение состоит в том, чтобы получить 10 повторений. Это позволяет '0' быть допустимым выводом, так как любой, у кого есть 111 повторений, уже находится в повторном представлении.

Ввод и вывод могут быть в любом приемлемом формате , и поскольку на любом сайте Stack Exchange невозможно иметь менее 1 повторения, можно предположить, что входные данные не будут меньше 1.

Один уголок для заметки:

Если у пользователя менее 10 повторений, он уже набрал повторную цифру, и поэтому ему также нужно «0».

Тест IO:

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

Применяются стандартные лазейки, и выигрывает самое короткое решение в байтах!

Желе , 6 байт

DE$1#_

Выход - одноэлементный массив.

Попробуйте онлайн! или проверьте большинство тестовых случаев . Тестовый случай 87654321 слишком медленный для TIO.

Как это работает

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)>>=(-)

Try it online

Brachylog, 9 bytes

:.#++#==,

Try it online!

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.

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.

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.

Python 2, 37 bytes

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

Test it on Ideone. 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.

Perl 6, 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.

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 to lower the byte-count by a whopping 40 bytes.

Ungolfed & test cases:

Try it here.

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

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

Here's my go at it

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

Try It Online

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

({}[{}])

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!

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

Java, 74 72 bytes

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

(If the other Java entry 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.

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

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 !

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.

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.

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!