Untuk menghormati berapa banyak perwakilan yang saya miliki beberapa jam yang lalu, ketika saya pertama kali memikirkan tantangan ini:

Angka-angka seperti ini yang terdiri dari pengulangan satu digit disebut repdigits . Repdigits itu menyenangkan! Setiap orang akan lebih senang jika jumlah rep yang mereka miliki adalah repdigit ¹ , tetapi saya tidak sabar, jadi Anda perlu membantu saya menemukan cara tercepat untuk sampai ke repdigit.

Inilah tantangan Anda:

Dengan bilangan bulat positif yang mewakili reputasi, berikan jumlah minimum rep yang harus mereka peroleh untuk mencapai repdigit. Misalnya, pada saat menulis tantangan ini, pengguna Martin Ender memiliki 102.856 rep. Rep-digit terdekat adalah 111,111, jadi dia harus mendapatkan: 8255 rep untuk berada di repdigit.

Karena orang tidak suka kehilangan perwakilan, kami hanya akan mempertimbangkan perubahan non-negatif. Ini berarti bahwa, misalnya, jika seseorang pada 12 rep, daripada kehilangan 1 rep, solusinya adalah mendapatkan 10 rep. Ini memungkinkan '0' menjadi output yang valid, karena siapa pun yang memiliki 111 rep sudah berada di repdigit.

Input dan output dapat dalam format yang masuk akal , dan karena tidak mungkin memiliki kurang dari 1 rep di situs Stack Exchange, Anda dapat mengasumsikan tidak ada input yang kurang dari 1.

Satu cornercase yang perlu diperhatikan:

Jika pengguna memiliki kurang dari 10 rep, mereka sudah di repdigit, dan mereka juga membutuhkan '0'.

Tes IO:

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

Celah standar berlaku, dan solusi terpendek dalam byte menang!

Jelly , 6 byte

DE$1#_

Output adalah array tunggal.

Cobalah online! atau verifikasi sebagian besar kasus uji . Test case 87654321 terlalu lambat untuk TIO.

Bagaimana itu bekerja

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

Cobalah online

Brachylog , 9 byte

:.#++#==,

Cobalah online!

Ini cukup efisien karena menggunakan batasan aritmatika.

Penjelasan

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

Bukan pendekatan terpendek, tetapi sangat efisien. Uji di Ideone .

Bagaimana itu bekerja

Untuk 10**len(`n`)putaran input n hingga daya terdekat 10 . Setelah itu, kami membagi hasilnya dengan 9 . Ini mengembalikan repdigit 1 ... 1 yang memiliki digit sebanyak n . Kami menyimpan hasilnya di r . Misalnya, jika n = 87654321 , maka r = 11111111 .

Repdigit yang diinginkan akan berupa beberapa atau r . Untuk memutuskan mana, kami melakukan pembagian plafon n oleh r . Karena /lantai operator divisi Python 2 , ini dapat dicapai dengan -n/r, yang akan menghasilkan nilai absolut yang benar, dengan tanda negatif. Misalnya, jika n = 87654321 , ini akan mengembalikan -8 .

Akhirnya, kita mengalikan hasil bagi yang dihitung dengan -r untuk mengulang hasil bagi satu digit untuk setiap digit dalam n . Misalnya, jika n = 87654321 , ini mengembalikan 88888888 , yang merupakan repdigit yang diinginkan.

Akhirnya, untuk menghitung kenaikan yang diperlukan, kami mengurangi n dari hasil sebelumnya. Sebagai contoh kita n = 87654321 , ini mengembalikan 1234567 , seperti yang diinginkan.

Python 2, 37 byte

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

Uji di Ideone . Perhatikan bahwa pendekatan ini terlalu tidak efisien untuk kasus uji 87654321 .

Bagaimana itu bekerja

Jika n sudah menjadi repdigit, 1-len(set(`n`))akan mengembalikan 0 karena panjang himpunan digit n pada basis 10 akan menjadi 1 . Dalam kasus ini, f mengembalikan 0 .

Jika n bukan repdigit, f(n+1)panggil f secara f dengan nilai n berikutnya yang mungkin . -~menambah nilai kembali f ( 0 ketika repdigit ditemukan) dengan 1 setiap kali f disebut secara rekursif, sehingga nilai pengembalian akhir sama dengan jumlah kali f telah dipanggil, yaitu, berapa kali n harus ditingkatkan untuk dapatkan repdigit.

Perl 6 , 23 byte

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

Lambda yang mengambil nomor input sebagai argumen, dan mengembalikan hasilnya.

Penjelasan:

1. Menggunakan ...operator urutan untuk menambah nomor input hingga mencapai repdigit (diuji dengan memecah representasi string menjadi karakter dan melihat apakah semuanya sama) .
2. Kurangi satu dari panjang urutan.

Java 7, 116 76 byte

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

Digunakan pendekatan luar biasa @Dennis ' untuk menurunkan byte-count dengan kekalahan 40 byte.

Kasus yang tidak disatukan & uji:

Coba di sini.

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

Keluaran:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 byte

1 byte terima kasih kepada @FryAmTheEggman.

-f@F`TQ

Cobalah online.

Sangat tidak efisien, loop melalui semua angka dari input ke repdigit berikutnya.

Brain-Flak 690 358 byte

Ini dia

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

Cobalah secara Online

Penjelasan

Mulailah dengan membuat salinan input kedua yang kurang dari aslinya. Kami akan menggunakan salinan untuk mencari repdigit berikutnya. Kami mengurangi satu jika nomor itu sendiri adalah repdigit

(({})[()])

Dorong satu untuk memenuhi lingkaran yang akan datang. (tidak harus menjadi salah satu bukan nol)

(())

Loop ini akan berjalan sampai ada repdigit di atas tumpukan

{

Pop omong kosong. Mereka adalah "boolean" di atas yang menggerakkan loop, karena tidak diperlukan lagi kita pop itu.

{}

Tambahkan satu dan duplikat bagian atas. Salinan akan diuraikan menjadi digit-digitnya.

(({}()))

Sementara salinannya bukan nol ...

{

Salin lagi

(({}))

Mod 10 dan pindah ke tumpukan lainnya

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

Membagi dengan 10 (divisi Integer)

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

}

Letakkan angka nol yang merupakan salinan kami

{}

Kami sekarang telah mendekomposisi angka menjadi basis 10 digit, Jadi kami bertukar ke tumpukan dengan semua digit.

<>

Sedangkan digit terdepan tidak nol

{

Kami mengambil salinan ketinggian tumpukan (yaitu jumlah digit) ...

(([])<

Kurangi satu dari setiap nomor di tumpukan secara diam-diam

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

Masukkan tinggi tumpukan yang kami ambil. (dan bertukar ke tumpukan lain)

><>)

Kami menggunakan ketinggian tumpukan untuk menarik semua digit yang kami tempatkan di tumpukan lainnya kembali ke tumpukan yang tepat.

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

Letakkan nol yang setinggi tumpukan kami

{}

Tukar kembali ke tumpukan dengan digit (atau berapa digit)

<>

Akhiri lingkaran

}

Sekarang kita telah mengurangi digit teratas dari semua digit lainnya. Jika semua digit nol angka asli (bukan input tetapi nomor yang kami periksa) adalah repdigit. ^[rujukan?] . Jadi kita perlu memeriksa bukan-nol.

Sementara tinggi tumpukan tidak nol

([])
{
{}

Jika digit bukan nol pindahkan ke tumpukan lain dan ganti dengan nol.

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

Pop itu (sekarang nol)

{}

Akhiri lingkaran

([])
}
{}

Tukar ke tumpukan lain (ya ..)

<>

Raih diri kami salinan tinggi tumpukan minus dua

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

Sedangkan tinggi tumpukan tidak dua (asli dan akumulator)

{
{}

Pop bagian atas

{}

Akhiri sementara

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

Letakkan salinan tinggi tumpukan kami minus dua. Ini akhirnya menjadi jumlah digit yang tidak sama dengan digit pertama. Dengan kata lain jika nol, itu adalah repdigit.

>)

Jika loop ini berakhir, kami telah menemukan repdigit

}

Pop the "boolean"

{}

Kurangi yang asli dari repdigit

({}[{}])

Python 2, 52 byte

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

Python 2 memiliki beberapa trik yang membuat ini lebih pendek. Misalnya, input berupa angka, jadi kita tidak perlu melakukan cast ke int. (-5 byte) Kami juga tidak perlu menempatkan tanda kurung di sekitar a-b(-1 byte)

Gunakan skrip ini untuk memverifikasi semua kasus uji:

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

Anda juga dapat mencobanya online!

GNU sed, 223 +1 (r flag) = 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

Menjalankan:

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

Keluaran:

110

Ini adalah solusi sed murni , aritmatika disimulasikan menggunakan ekspresi reguler saja. Algoritma bekerja sebagai berikut:

1. format ruang pola diatur ke ^current_reputation:needed_reputation%$
2. di setiap iterasi dari loop utama pemisah diaktifkan:
   a) %:menerapkan kenaikan untuk diperlukan_reputasi
   b) :%menerapkan kenaikan untuk current_reputation
3. jika current_reputation adalah "repdigit" , reputasi yang diperlukan dicetak dan program berakhir

Jawa, 74 72 byte

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

(Jika entri Java lainnya adalah 76 byte, ini adalah74 72, karena itu dua empat byte lebih pendek).

Ngomong-ngomong, tambah saja inputnya sampai menjadi repdigit sambil menambah penghitung. Kembalikan konter.

Ya, itu adalah tiga plus berturut-turut, dua untuk menambah input, satu untuk merangkai string kosong untuk menjadikannya string.
Tidak, saya tidak berpikir itu akan sah tanpa ruang di antara keduanya, tetapi begitulah. Itulah yang salah ketik akan lakukan untuk Anda: satu byte lebih pendek.

Menggunakan for-loop alih-alih sementara waktu membutuhkan banyak byte:

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

Edit:

Versi sebelumnya harus matches("^(\\d)\\1*$")memeriksa repdigit, tetapi karena kita baru saja mengonversi int menjadi string, menggunakan .kecocokan sudah cukup.

Kasus yang tidak disatukan & uji:

Coba di sini.

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

}

Keluaran:

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

Tidak Disatukan:

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

Mengacaukan dengan format ( as.numericdanas.character ) menambahkan beberapa byte, tetapi R tidak benar-benar fleksibel!

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

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

Jika mencetak apa pun alih-alih 0ketika nomor sudah repdigit dapat diterima, maka 37 byte sudah cukup:

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

Jalankan dengan -n(1 byte) dan -Eatau -M5.010(gratis):

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

Penjelasan : ada dua bagian utama dalam kode: /^(.)\1*$/&&say$vdan $_++&&++$v&&redo. Tes pertama jika $_repdigit; jika ya itu mencetak nomor yang kami tambahkan ke nomor asli untuk menjadikannya repdigit ( $v), dan jika tidak, kami memiliki 1 untuk keduanya $_dan $v, dan memulai dari awal.

JavaScript (ES6), 42 byte

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

Penjelasan: Menghitung secara rekursif psebagai kekuatan berikutnya 10setelah n. Digit yang akan diulang kemudian dihitung sebagai 1+floor(9n/p), dan repunitnya sederhana (p-1)/9, dari mana hasilnya mengikuti.

05AB1E , 10 6 byte

∞.Δ+Ë

Cobalah online!

Penjelasan

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

Pyke, 13 11 byte

o+`}ltIr)ot

Coba di sini!

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

Sebenarnya, 15 byte

;D;WXu;$╔l1<WX-

Cobalah online!

Penjelasan:

;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

Ubur-ubur , 20 byte

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

Cobalah online! TIO tidak dapat menangani kasus uji yang lebih lama, tetapi mengingat waktu dan memori yang cukup, mereka harus bekerja juga.

Penjelasan

• iadalah input, dan <menurunkannya. Nilai ini diumpankan ke fungsi di sebelah kiri.
• \> menambah nilai (setidaknya sekali) sampai fungsi ke kanan memberikan nilai yang benar.
• Fungsi tes adalah komposisi (oleh &s) dari empat fungsi.
• 0~j dikonversi ke string.
• u menghapus digit duplikat.
• > menghapus kepala string yang dihasilkan.
• Nadalah negasi logis: memberikan 1untuk string kosong, dan 0untuk non-kosong. Dengan demikian fungsi tes untuk rep-digit, dan hasilnya \adalah penghitungan rep-digit berikutnya <i.
• )-kurangi hasil dari input fungsi, yaitu <i,.
• Perbedaan ini tidak aktif satu per satu, jadi <kurangi. Akhirnya, pcetak hasilnya.

PowerShell v2 +, 66 byte

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

Pengecoran PowerShell yang biasanya sangat bagus untuk golf adalah kejatuhan besar di sini.

Mengambil input $nsebagai string, dan memasuki forlingkaran. Untuk langkah pengaturan, kami mengekstrak karakter pertama $n[0], tetapi harus mengubahnya kembali menjadi string "$(...)"sebelum memasukkan sebagai int +dan menyimpannya $x. Jika tidak, aritmatika nanti akan menggunakan nilai ASCII dari kode-char.

Pengecekan bersyarat apakah string yang dibuat dari $n.length "$x"s, disimpan sementara $y, kurang dari $n. Selama tidak, kami menambah $x++, menyiapkan persyaratan untuk loop berikutnya.

Sebagai contoh, untuk input 123, nilai $ysaat kondisi pertama kali diperiksa akan menjadi 111, yang kurang dari $n, sehingga loop berlanjut. Tidak ada apa pun di badan loop, sehingga kenaikan langkah terjadi $x++, maka kondisional diperiksa lagi. Waktu ini $ysama dengan 222, yang lebih besar dari $n, sehingga loop berakhir. Jika input sudah menjadi repdigit, syaratnya tidak terpenuhi, karena pada saat $yitu sama dengan $n.

Setelah keluar dari loop, kita dilemparkan $yke integer +, lalu kurangi $n. Hasil itu ditinggalkan di jalur pipa dan hasilnya tersirat.

PHP 5.6, 59 53 51 50 byte

Disimpan 6 8 byte berkat @manatwork.

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

Tes dengan:

php test.php 11132

The count_chars()fungsi dengan 3 sebagai parameter kedua mengembalikan sebuah string dengan karakter yang berbeda dalam sebuah string. Ketika string ini panjangnya 1 karakter ( [1]akan mengembalikan false ketika panjangnya 1) lalu gema $b, jika tidak, tambahkan $bdan putar lagi.

MATL , 10 byte

q`QtVda}G-

Cobalah online!

Ini terus menambah input sampai semua digit sama, jadi lambat. Kasing uji untuk 87654321waktu input habis di kompiler 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 karakter

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

Mengharapkan input string.

Contoh dijalankan:

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

Ruby, 39 karakter

Panggilan rekursif, berjalan ke "SystemStackError: level stack terlalu dalam" pada hasil yang lebih besar.

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

Contoh dijalankan:

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 byte

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

Karena loop sementara itu agak lambat ...

Penjelasan

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

Menyimpan satu byte berkat @Luis Mendo .

Excel, 85 79 byte

Masukkan formula berikut ke sel mana pun kecuali sel Nkarena itu nama untuk referensi sel input:

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

Penjelasan:

• N adalah input dan juga nama sel referensi .
• LEFT(N) ambil digit pertama dari nilai input.
• LEN(N) mengembalikan panjang nilai input.
• REPT(LEFT(N),LEN(N)) ulangi digit pertama dari nilai input LEN(N) kali dan kalikan dengan 1 untuk mengonversi format teks ke format angka sehingga kita dapat menggunakannya untuk perbandingan angka.
• Sintaks untuk fungsi IF di Microsoft Excel adalah: IF (kondisi, [value_if_true], [value_if_false]) , karenanya membuat seluruh rumus cukup jelas.

Brachylog v2, 6 byte

;.+=∧ℕ

Cobalah online!

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

5-byte +↙.=∧lolos dari penghilangan ℕkarena tidak mencoba output non-positif sama sekali, tetapi juga gagal ketika diberi nomor yang sudah repdigit karena tidak mencoba output non-positif sama sekali.

Java, 59 byte

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

(Saya masih tidak yakin bagaimana cara menghitung entri Java, tetapi menurut standar yang ditetapkan oleh entri Java pertama , entri ini adalah 59 byte, karena ini lebih pendek 17 byte).

Lagi pula, jika kita memiliki repdigit, kembalikan 0, jika tidak tambahkan 1 ke input, panggil sendiri dan tambahkan 1 ke hasilnya.

Kasus yang tidak disatukan & uji:

Coba di sini.

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

Keluaran:

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

Seperti yang Anda lihat, entri terakhir kehabisan memori sebelum dapat selesai. (Sangat sesuai) StackOverflowErrordilempar dari java.util.regex.Pattern.sequence(Pattern.java:2134), tapi saya cukup yakin tidak ada yang salah dengan regex itu sendiri, karena itu sama dengan yang saya gunakan pada entri saya sebelumnya .

C #, 82 byte

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

C, 84 byte

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

Tes utama:

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 byte

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.

Cobalah online!