私が数時間前にこの挑戦を最初に考えたとき、私がどれだけ多くの担当者を持っていたかに敬意を表して：

1桁の繰り返しで構成されるこのような番号は、repdigitsと呼ばれます。Repdigitsは楽しいです！すべてのボディは、彼らが持っていた担当者の量がぞろ目であった場合、より幸せになる¹が、あなたは私がぞろ目に取得するための最速の方法を見つける手助けする必要があるので、私は、せっかちです。

ここにあなたの挑戦があります：

レピュテーションを表す正の整数が与えられた場合、repdigitに到達するために獲得する必要のある最小量の担当者を出力します。たとえば、この課題の執筆時点で、ユーザーMartin Enderの担当者は102,856人でした。最も近いrep-digitは111,111なので、彼は得る必要があります：repdigitになるには8255 rep。

人々が担当者を失うことを嫌うので、ネガティブでない変更のみを考慮します。これは、たとえば、1人の担当者を失うのではなく、12人の担当者がいる場合、解決策は10人の担当者を獲得することであることを意味します。111 repを持っている人はすでに repdigitにいるので、これにより「0」が有効な出力になります。

入力と出力は任意の合理的な形式であり、Stack Exchangeサイトで担当者を1人未満にすることはできないため、入力が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バイト

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

オンラインで試す

Brachylog、9バイト

:.#++#==,

オンラインでお試しください！

これは、制約演算を利用するため、かなり効率的です。

説明

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

パイソン2、41の 40バイト

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

最短のアプローチではありませんが、非常に効率的です。Ideoneでテストします。

使い方

入力のための10**len(`n`)ラウンドn個の最も近いパワーまで10。その後、結果を9で除算します。これは、nと同じ桁数のrepdigit 1…1を返します。結果をrに保存します。たとえば、n = 87654321の場合、r = 11111111です。

望ましいrepdigitは、倍数またはrになります。どちらを決定するために、nをrで天井除算します。Python 2の除算演算子の下限は、で/実現できます-n/r。これにより、負の符号を持つ正しい絶対値が得られます。たとえば、n = 87654321の場合、これは-8を返します。

最後に、計算された商に-rを乗算して、nの各桁に対して商を1回繰り返します。たとえば、n = 87654321の場合、これは88888888を返します。これは目的のrepdigitです。

最後に、必要な増分を計算するために、前の結果からnを引きます。n = 87654321の例では、必要に応じて1234567を返します。

Python 2、37バイト

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

Ideoneでテストします。このアプローチは、テストケース87654321には非効率的であることに注意してください。

使い方

場合nは既にぞろ目で、1-len(set(`n`))戻ります0の組の長さがNベース10の数字になります1。この場合、fは0を返します。

場合Nぞろ目ではない、f(n+1)再帰呼び出しFを次の可能な値とN。fが再帰的に呼び出されるたびに、f-~の戻り値（repdigitが見つかった場合は0）を1ずつインクリメントするため、最終的な戻り値はfが呼び出された回数、つまりnをインクリメントする必要がある回数に等しくなりますrepdigitを取得します。

Perl 6、23バイト

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

入力番号を引数として受け取り、結果を返すラムダ。

説明：

1. ...シーケンス演算子を使用して、repdigitに達するまで入力番号をインクリメントします（文字列表現を文字に分割し、それらがすべて等しいかどうかを確認してテストします）。
2. シーケンスの長さから1を引きます。

Java 7、116 76バイト

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

@Dennisの驚くべきアプローチを使用して、バイト数をなんと40バイト減らしました。

未ゴルフ＆テストケース：

ここで試してみてください。

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

出力：

0
11
109
1234567
2
2222
11090

Pyth、9 8 7バイト

@FryAmTheEggmanのおかげで1バイト。

-f@F`TQ

オンラインでお試しください。

非常に非効率的で、入力から次のrepdigitまでのすべての数値をループします。

Brain-Flak 690 358バイト

ここに私が行く

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

オンラインで試す

説明

元の入力より1つ少ない入力の2番目のコピーを作成することから始めます。コピーを使用して、次のrepdigitを検索します。数値自体がrepdigitである場合、1を減算します

(({})[()])

1つプッシュして、次のループを満たします。（ゼロではなく、1つである必要はありません）

(())

このループは、スタックの最上位にrepdigitが現れるまで実行されます

{

がらくたをポップします。それらはループを駆動する「ブール」です。これは、ループをポップする必要がなくなったためです。

{}

1つ追加して、上部を複製します。コピーは数字に分解されます。

(({}()))

コピーはゼロではありませんが...

{

もう一度コピー

(({}))

Mod 10および他のスタックに移動

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

10で除算（整数除算）

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

}

コピーしたゼロをポップします

{}

これで数値を10桁に分解したので、すべての桁でスタックにスワップします。

<>

先頭の数字はゼロではありませんが

{

スタックの高さ（つまり、桁数）のコピーを取得します...

(([])<

スタック上のすべての数値から1を静かに減算します

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

ピックアップしたスタックの高さを下げます。（および他のスタックにスワップ）

><>)

スタックの高さを使用して、他のスタックに配置したすべての数字を適切なスタックに戻します。

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

スタックの高さであるゼロをポップします

{}

数字（または数字）を使用してスタックにスワップバックします

<>

終了ループ

}

これで、他のすべての数字から最上位の数字を引きました。すべての桁がゼロの場合、元の番号（入力ではなくチェックする番号）はrepdigitでした。^[要出典]。したがって、非ゼロをチェックする必要があります。

スタックの高さはゼロではありませんが

([])
{
{}

数字がゼロでない場合、他のスタックに移動してゼロに置き換えます。

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

ポップします（現在はゼロです）

{}

終了ループ

([])
}
{}

他のスタックにスワップオーバー（duh ..）

<>

スタックの高さから2を引いたコピーを手に入れます

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

スタックの高さは2ではありません（オリジナルとアキュムレーター）

{
{}

トップをポップ

{}

しばらくして

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

スタックの高さから2を引いたもののコピーを書き留めます。これは、最初の桁とは異なる桁数になります。つまり、ゼロの場合、repdigitです。

>)

このループが終了すると、repdigitが見つかりました

}

「ブール」をポップ

{}

repdigitからオリジナルを減算します

({}[{}])

Python 2、52バイト

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

Python 2には、これを短くするいくつかのトリックがあります。たとえば、入力は数値であるため、intにキャストする必要はありません。（-5バイト）また、a-b（-1バイト）を括弧で囲む必要もありません。

このスクリプトを使用して、すべてのテストケースを検証します。

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

オンラインで試すこともできます！

GNU sed、223 + 1（rフラグ）= 224バイト

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

実行：

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

出力：

110

これは純粋なsedソリューションです。算術は正規表現のみを使用してシミュレートされます。アルゴリズムは次のように機能します。

1. パターンスペースの形式は ^current_reputation:needed_reputation%$
2. メインループの各反復においてセパレータが切り替えられる：
   A）は、%:に増分を適用needed_reputationの
   B）:%に増分を適用current_reputation
3. 場合current_reputationは「ぞろ目」、であるneeded_reputationが印刷され、プログラムが終了

Java、 74 72バイト

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

（他のJavaエントリが76バイトの場合、これは74 72、 二 4バイト短縮）。

とにかく、カウンターをインクリメントしながら、それがrepdigitになるまで入力をインクリメントします。カウンターを返します。

はい、それらは連続した3つのプラスです。2つは入力をインクリメントし、1つは空の文字列を連結して文字列にします。
いいえ、間にスペースがないと合法だとは思いませんでしたが、そこに行きます。それはタイプミスがあなたのためにすることです：1バイト短くなります。

whileの代わりにforループを使用すると、正確に同じバイト数がかかります。

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

編集：

以前のバージョンではmatches("^(\\d)\\1*$")repdigitをチェックする必要がありましたが、intを文字列に変換したばかりなので、a .to match を使用すれば十分です。

未ゴルフ＆テストケース：

ここで試してみてください。

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

}

出力：

0
11
109
1234567
2
2222
11090

R、102 98 91バイト

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

アンゴルフド：

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

フォーマット（as.numericおよびas.character）をいじると、いくつかのバイトが追加されますが、Rは実際には柔軟性がありません！

Perl、40 + 1（-n）= 41バイト

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

0番号がすでにrepdigit である場合ではなく、何も印刷しない場合は、37バイトで十分です：

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

-n（1バイト）-Eまたは-M5.010（無料）で実行します。

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

説明：2つの主要部分がコードにあります/^(.)\1*$/&&say$vと$_++&&++$v&&redo。最初のテスト$_は、repdigitです。はいの場合、元の番号に追加した番号を出力して、それを繰り返し桁（$v）にします。いいえの場合は、との両方に1が$_あり$v、最初からやり直します。

JavaScript（ES6）、42バイト

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

説明：after pの次の累乗として再帰的に計算します。繰り返される数字はとして計算され、repunitは単にであり、そこから結果が続きます。10n1+floor(9n/p)(p-1)/9

05AB1E、10 6バイト

∞.Δ+Ë

オンラインでお試しください！

説明

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

パイク、13 11バイト

o+`}ltIr)ot

ここで試してみてください！

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

実際には、15バイト

;D;WXu;$╔l1<WX-

オンラインでお試しください！

説明：

;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

クラゲ、20バイト

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

オンラインでお試しください！ TIOは長いテストケースを処理できませんが、十分な時間とメモリがあれば、それらも機能するはずです。

説明

• i入力であり、<デクリメントします。この値は左側の関数に送られます。
• \> 右側の関数が真の値を与えるまで、値を（少なくとも1回）増分します。
• テスト関数は、&4つの関数の構成（s）です。
• 0~j 文字列に変換します。
• u 重複する数字を削除します。
• > 結果の文字列の先頭を削除します。
• N論理否定です。1空の文字列と空でない文字列を提供し0ます。したがって、関数はrep-digitをテストし、の結果は\からカウントする次のrep-digit <iです。
• )-関数入力から結果を減算し<iます。つまり、です。
• この違いは1つずれているため、<減少させます。最後にp、結果を出力します。

PowerShell v2 +、66バイト

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

PowerShellの通常はゴルフに適した非常に緩やかなキャストは、ここでの大きな失敗です。

入力$nを文字列として受け取り、forループに入ります。セットアップ手順では、最初の文字を抽出します$n[0]が"$(...)"、intとしてキャストしてに+保存する前に、文字列に変換し直す必要があります$x。それ以外の場合、後の算術演算では文字コードのASCII値が使用されます。

条件は、から$n.length "$x"一時的に保存され$y、から構築された文字列がより小さいかどうかをチェックします$n。そうでない限り、インクリメント$x++し、次のループの条件を設定します。

たとえば、input 123の$y場合、条件が最初にチェックされるときの値はになり111、これはより小さい$nため、ループが継続します。ループ本体には何もないため、ステップの増分が発生し$x++、条件が再度チェックされます。この時間$yはに等しく222、これはより大きい$nため、ループは終了します。入力が既にrepdigitである場合、条件は満たされません。その時点で$yはに等しいため$nです。

ループから出たら$y、整数+にキャストしてからを減算し$nます。その結果はパイプラインに残り、出力は暗黙的です。

PHP 5.6、59の 53 51 50バイト

保存された6 8は@manatworkのおかげでバイト。

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

でテストする：

php test.php 11132

count_chars()2番目のパラメータとして3を持つ関数は、文字列内の異なる文字の文字列を返します。この文字列[1]の長さが1文字の場合（長さが1の場合はfalseを返します）、echo $b、そうでない場合はインクリメント$bしてループします。

MATL、10バイト

q`QtVda}G-

オンラインでお試しください！

これにより、すべての数字が等しくなるまで入力が増加し続けるため、時間がかかります。87654321オンラインコンパイラでの入力タイムアウトのテストケース。

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

ルビー、42文字

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

文字列の入力が必要です。

サンプル実行：

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

ルビー、39文字

再帰呼び出し、より大きな結果で「SystemStackError：stack level too deep」に遭遇します。

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

サンプル実行：

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バイト

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

whileループのため、かなり遅いです...

説明

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

@Luis Mendoのおかげで1バイト節約できました。

Excel、85 79バイト

N入力の参照セルの名前であるため、セルを除く任意のセルに次の数式を入力します。

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

説明：

• Nは入力であり、参照セルの名前でもあります。
• LEFT(N) 入力値の最初の桁を取得します。
• LEN(N) 入力値の長さを返します。
• REPT(LEFT(N),LEN(N))入力値の最初の桁をLEN(N)何回も繰り返し、1 を乗算してテキスト形式を数値形式に変換し、数値比較に使用できるようにします。
• Microsoft ExcelのIF関数の構文は、IF （condition、[value_if_true]、[value_if_false]）であるため、式全体が一目瞭然になります。

Brachylog v2、6バイト

;.+=∧ℕ

オンラインでお試しください！

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

5バイト+↙.=∧は、ℕ非正の出力をまったく試行しないため、省略して逃げますが、非正の出力をまったく試行しないため、すでにレプディジットである数値を指定しても失敗します。

Java、59バイト

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

（Javaエントリのカウント方法はまだわかりませんが、最初のJavaエントリによって設定された標準に従っていますで、このエントリは17バイト短いため59バイトです）。

とにかく、repdigitがある場合は0を返し、そうでない場合は入力に1を追加し、それ自体を呼び出して結果に1を追加します。

未ゴルフ＆テストケース：

ここで試してみてください。

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

出力：

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

ご覧のとおり、最後のエントリは終了する前にメモリを使い果たします。（非常に適切な）StackOverflowErrorがスローjava.util.regex.Pattern.sequence(Pattern.java:2134)されますが、前のエントリで使用したものと同じであるため、正規表現自体に何の問題もないと確信しています。

C＃、82バイト

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

C、84バイト

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

メインテスト：

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

プロローグ、120バイト

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.

オンラインでお試しください！