Bu meydan okumayı ilk düşündüğümde, birkaç saat önce ne kadar temsilci olduğumun onuruna:

Tek basamaklı bir tekrarlamadan oluşan bu sayılara repdigit denir . Repdigitler eğlencelidir! Her vücut oldukları temsilcisi miktarı repdigit olsaydı daha mutlu olurdu ¹ ama beni bir repdigit almak için en hızlı yolu bulmalarına yardımcı olmak için ihtiyaç yüzden, sabırsızım.

İşte zorluk:

İtibarı temsil eden pozitif bir tamsayılar verildiğinde, bir repdigit için elde etmek için ihtiyaç duydukları asgari rep miktarını elde edin. Örneğin, bu zorluğun yazıldığı sırada, Martin Ender kullanıcısı 102.856 temsilcisine sahipti. En yakın tekrar basamağı 111,111, bu yüzden kazanması gerekecek: bir repdigitte olmak için 8255 temsilci.

İnsanlar itibar kaybetmekten hoşlanmadıklarından, yalnızca olumsuz olmayan değişiklikleri dikkate alacağız. Bu, örneğin, eğer birileri 1 rep kaybetmek yerine 12 rep ise, çözüm 10 rep elde edecek demektir. Bu, '0'ın geçerli bir çıktı olmasını sağlar, çünkü 111 rep'e sahip olan bir kişi zaten bir repdigittedir.

Giriş ve çıkış herhangi bir makul formatta olabilir ve herhangi bir Yığın Değişim sitesinde 1'den daha az tekrar olması imkansız olduğundan, hiçbir girişin 1'den az olmayacağını varsayabilirsiniz.

Dikkat edilecek bir köşe kılıfı:

Bir kullanıcının 10'dan daha az temsilcisi varsa, zaten bir bölmededir ve bu nedenle de '0' a ihtiyaçları vardır.

Test IO:

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

Standart boşluklar uygulanır ve bayt cinsinden en kısa çözüm kazanır!

Jöle , 6 bayt

DE$1#_

Çıktı bir singleton dizisidir.

Çevrimiçi deneyin! veya çoğu test vakasını doğrulayın . Test durumu 87654321 , TIO için çok yavaş.

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin

Brachylog , 9 bayt

:.#++#==,

Çevrimiçi deneyin!

Kısıtlamalar aritmetik kullandığı için bu oldukça etkilidir.

açıklama

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

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

En kısa yaklaşım değil, ama çok verimli. İdeone üzerinde test et .

Nasıl çalışır

Giriş 10**len(`n`)devirleri için 10 en yakın güce kadar n . Daha sonra sonucu 9'a böleriz . Bu , n kadar rakam içeren 1… 1 repdigitini döndürür . Sonucu r olarak kaydederiz . Örneğin, eğer n = 87654321 , o zaman r = 11111111 .

Arzu edilen repdigit bir çoklu veya r olacaktır . Hangisini kararlaştırmak için n'nin r tarafından tavan bölünmesini gerçekleştiririz . Python 2'nin bölme operatörü /zeminden bu yana -n/r, doğru mutlak değeri verecek olan negatif işaretiyle bu başarılabilir . Örneğin, n = 87654321 ise , bu -8 döndürür .

Son olarak, biz çarpın tarafından hesaplanan bölüm -r kez her hane icin katsayısı tekrarlamak n . Örneğin, n = 87654321 ise , bu istenen repdigit olan 88888888 değerini döndürür .

Son olarak, gerekli artışı hesaplamak için önceki sonucu n'yi çıkarırız . Örneğimizde n = 87654321 , bu istenildiği gibi 1234567 döndürür .

Python 2, 37 bayt

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

İdeone üzerinde test et . Bu yaklaşımın 87654321 numaralı test vakası için çok yetersiz olduğuna dikkat edin .

Nasıl çalışır

Eğer n, daha önce bir repdigit olup, 1-len(set(`n`))geri dönecek 0 kümesinin uzunluğu büyük olduğu takdirde , n 10 tabanına 'in basamak olacaktır 1 . Bu durumda, f 0 döndürür .

Eğer n bir repdigit değil, f(n+1)yinelemeli çağırır f sonraki olası değeri ile n . f-~ dönüş değerini artırır ( 0 ile repdigit bulunduğunda) , 1 her f son dönüş değeri sayısını eşit olacak şekilde, ardışık olarak adlandırılır f , adı olmuştur, yani sayısı n artırılır gerekiyordu repdigit al.

Perl 6 , 23 bayt

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

Girdi numarasını argüman olarak alan ve sonucu döndüren bir lambda.

Açıklama:

1. ...Girdi numarasını bir repdiite ulaşana kadar artırmak için dizi operatörünü kullanır (dize gösterimini karakterlere bölerek ve hepsinin eşit olup olmadığına bakarak test edilir) .
2. Dizinin uzunluğundan bir tane çıkarır.

Java 7, 116 76 bayt

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

Kullanılan @Dennis 'şaşırtıcı yaklaşım bir kuyruklu 40 bayt tarafından bayt sayısını düşürmek amacıyla.

Ungolfed ve test durumları:

Burada dene.

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

Çıktı:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 bayt

@FryAmTheEggman sayesinde 1 bayt.

-f@F`TQ

Çevrimiçi deneyin.

Çok verimsiz, girişten bir sonraki repdigit'e kadar tüm sayılar arasında geçiş yapar.

Brain-Flak 690 358 bayt

İşte benim gidiyorum

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

Çevrimiçi Deneyin

açıklama

Girişin orijinalinden bir küçük harfin ikinci kopyasını alarak başlayın. Bir sonraki repdigit'i aramak için kopyayı kullanacağız. Sayının kendisinin repdigit olması durumunda birini çıkarırız

(({})[()])

Gelecek döngüyü tatmin etmek için birini itin. (bir sıfır değil bir olmak zorunda değildir)

(())

Bu döngü yığının üstünde bir repdigit olana kadar çalışacaktır.

{

Bok patlat. Bunların üstünde bir "boolean" var, artık döngüyü tahrik ediyorlar, çünkü artık gerekmiyor.

{}

Bir tane ekleyin ve üst kısmı çoğaltın. Kopya, rakamlarına ayrıştırılacaktır.

(({}()))

Kopya sıfır olmasa da ...

{

Tekrar kopyala

(({}))

Mod 10 ve diğer yığına geç

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

10'a böl (Tam sayı bölümü)

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

}

Kopyamız olan sıfırı aç

{}

Şimdi sayıyı 10 basamak bazında çözdük, böylece tüm basamaklarla yığının üzerine geçiyoruz.

<>

Baştaki rakam sıfır değilken

{

İstif yüksekliğinin bir kopyasını alıyoruz (rakamların sayısı) ...

(([])<

Yığındaki her sayıdan birini sessizce çıkart

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

Aldığımız yığının yüksekliğini koy. (ve diğer yığına geç)

><>)

Diğer yığına yerleştirdiğimiz tüm rakamları doğru yığına geri çekmek için yığın yüksekliğini kullanırız.

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

İstif yüksekliğimiz olan sıfırı aç

{}

Rakamlarla yığına geri dön (veya rakamlar neydi)

<>

Son döngü

}

Şimdi üst basamağı diğer tüm basamaklardan çıkardık. Tüm basamaklar sıfırsa, orijinal sayı (giriş değil, kontrol ettiğimiz sayı) bir eş değerdir.^{[kaynak belirtilmeli]} . Bu yüzden sıfır olmayanları kontrol etmeliyiz.

İstif yüksekliği sıfır değilken

([])
{
{}

Rakam sıfır değilse, diğer yığına getirin ve sıfır ile değiştirin.

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

Pop it (şimdi bir sıfır)

{}

Son döngü

([])
}
{}

Diğer yığına geç (ha ..)

<>

İkiden yığın yüksekliğinin eksi iki kopyasını kendimizden alın

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

Yığın yüksekliği iki değilken (orijinal ve akümülatör)

{
{}

Üst pop

{}

Süreyi bitir

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

İstif yüksekliğinin eksi iki kopyasını indirin. Bu, ilk rakamla aynı olmayan rakamların sayısıyla sonuçlanır. Başka bir deyişle, eğer sıfır ise, bir repdigit.

>)

Bu döngü sona ererse, bir repdigit bulduk

}

"Boole" yu patlat

{}

Orijinali repdigitten çıkartın

({}[{}])

Python 2, 52 bayt

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

Python 2 bunu kısaltan birçok püf noktası var. Örneğin, giriş sayısaldır, bu nedenle int'e atlamamız gerekmez. (-5 bytes) Ayrıca parantezin çevresine parantez koymamız gerekmez.a-b (-1 bayt)

Tüm test durumlarını doğrulamak için bu komut dosyasını kullanın:

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

Ayrıca çevrimiçi deneyebilirsiniz!

GNU sed, 223 + 1 (r bayrağı) = 224 bayt

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

Koşmak:

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

Çıktı:

110

Bu saf bir sed çözümdür , aritmetik sadece normal ifadeler kullanılarak simüle edilir. Algoritma aşağıdaki gibi çalışır:

1. desen alanı formatı ^current_reputation:needed_reputation%$
2. ayırıcılar anahtarlanır ana döngünün her tekrarında:
   a) %:için artış uygulanır needed_reputation
   b) :%için de geçerlidir artış current_reputation
3. Eğer current_reputation bir "repdigit", bir needed_reputation basılır ve program uçlarını

Java, 74 72 bayt

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

( Diğer Java girişi ise 76 bayt ise, bu74 72, çünkü iki dört bayt daha kısa).

Her neyse, sadece bir sayacı artırırken bir repdigit olana kadar girişi arttırın. Sayacı geri ver.

Evet, bunlar arka arkaya üç artı, ikisi girişi artırmak, diğeri boş dize oluşturmak için dizedir.
Hayır, ikisi arasında bir boşluk olmadan yasal olacağını düşünmedim, ama işte gidiyorsunuz. Bir yazım hatası sizin için ne yapacak: bir bayt kısa.

Bir süre yerine for döngüsü kullanmak, tam olarak bayt sayısını alır:

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

Düzenle:

Daha önceki bir sürüm matches("^(\\d)\\1*$")bir repdigit olup olmadığını kontrol etmek zorundaydı, ancak bir int'i bir dizgeye dönüştürdüğümüzden, bir .eşleşme için kullanmak yeterli.

Ungolfed ve test durumları:

Burada dene.

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

}

Çıktı:

0
11
109
1234567
2
2222
11090

R, 102 98 91 bayt

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

Biçimde dolaşmak ( as.numericveas.character ) bazı baytlar ekler, ancak R gerçekten esnek değildir!

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

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

0Sayı zaten bir repdigit olduğunda yerine hiçbir şey yazdırılmazsa , 37 bayt yeterlidir:

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

İle çalıştırın -n(1 byte) ve -Eya -M5.010(serbest):

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

Açıklamalar : Kodda iki ana bölüm vardır: /^(.)\1*$/&&say$vve $_++&&++$v&&redo. İlk test eğer $_bir repdigit ise; evet eğer orijinal sayısına eklenir numara bir repdigit (yapmak yazdırır $v) ve olmaması durumunda, her iki 1 ila vardı $_ve $v, ve baştan başlayın.

JavaScript (ES6), 42 bayt

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

Açıklama: Tekrarladıktan sonra bir psonraki güç olarak hesaplar . Tekrarlanacak rakam daha sonra olarak hesaplanır ve birim, sonuçtan sonra gelen basitçedir .10n1+floor(9n/p)(p-1)/9

05AB1E , 10 6 bayt

∞.Δ+Ë

Çevrimiçi deneyin!

açıklama

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

Pyke, 13 11 bayt

o+`}ltIr)ot

Burada dene!

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

Aslında 15 bayt

;D;WXu;$╔l1<WX-

Çevrimiçi deneyin!

Açıklama:

;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

Denizanası , 20 bayt

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

Çevrimiçi deneyin! TIO daha uzun test vakalarıyla başa çıkamıyor, ancak yeterli zaman ve hafıza verildiğinde, onların da çalışması gerekiyor.

açıklama

• i giriş, ve <giriştir azaltır. Bu değer soldaki işleve beslenir.
• \> sağdaki işlev bir truthy değeri verene kadar değeri (en az bir kez) artırır.
• Test fonksiyonu bir kompozisyondur ( & dört fonksiyondan .
• 0~j dizeye dönüştürür.
• u yinelenen rakamları kaldırır.
• > elde edilen dizenin başını siler.
• Nmantıksal olumsuzlamadır: 1boş bir dize ve 0boş olmayanlar için verir . Böylece fonksiyon bir rakam için test eder ve sonucu bir \sonraki rakam için sayılır <i.
• )-sonucu fonksiyon girişinden çıkarır, yani <i.
• Bu fark birer birer kapalıdır, dolayısıyla <onu azaltır. Sonunda psonucu yazdırır.

PowerShell v2 +, 66 bayt

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

Genellikle golf için iyi olan çok gevşek PowerShell dökümü burada büyük bir düşüş.

Girdiyi $ndize olarak alır ve bir fordöngüye girer . Kurulum adımı için ilk karakteri çıkarırız $n[0], ancak "$(...)"int olarak +kaydetmeden ve kaydetmeden önce onu bir dizgeye dönüştürmeliyiz$x . Aksi takdirde, sonraki aritmetik, karakter kodunun ASCII değerini kullanacaktır.

Koşullu $n.length "$x", geçici olarak depolanan s'den oluşturulan bir dizgiden $ydaha az olup olmadığını kontrol eder $n. Olmadığı sürece $x++, bir sonraki döngü için şartı ayarlayarak artış yaparız .

Örneğin, girdi için 123, $ykoşullu ilk kontrol edildiğinde değeri 111, daha küçük olan olacaktır , bu $nnedenle döngü devam eder. Döngü gövdesinde hiçbir şey yoktur, bu yüzden adım artışı olur $x++, sonra şartlı tekrar kontrol edilir. Bu süre , daha büyük olan $yeşittir 222, bu $nyüzden döngü sona erer. Girdi zaten bir repdigit ise, koşullu yerine getirilmez, çünkü o noktada $yeşittir $n.

Döngünün dışına çıktıktan sonra, $ybir tamsayıya çeviririz +, sonra çıkarırız $n. Bu sonuç boru hattında bırakılır ve çıktı kesindir.

PHP 5.6, 59 53 51 50 bayt

Kaydedilen 6 8 @manatwork sayesinde bayt.

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

Şununla test et:

php test.php 11132

count_chars()İkinci parametre olarak 3 olan işlev, bir dizgede farklı karakterlerle bir dize döndürür. Bu dize 1 karakter uzunluğunda [1]olduğunda (uzunluğu 1 olduğunda false döndürür) sonra eko $b, aksi takdirde $btekrar artırın ve tekrarlayın.

MATL , 10 bayt

q`QtVda}G-

Çevrimiçi deneyin!

Bu, tüm basamaklar eşit oluncaya kadar girişi artırmaya devam eder, bu nedenle yavaş olur. 87654321Çevrimiçi derleyicide giriş için zaman aşımına uğradı.

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

Yakut, 42 karakter

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

Dize girişi bekliyor.

Örnek çalışma:

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

Yakut, 39 karakter

Özyinelemeli çağrı, daha büyük sonuçlarda “SystemStackError: yığın seviyesi çok derin” olarak çalışır.

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

Örnek çalışma:

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 bayt

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

Süre döngüsü nedeniyle oldukça yavaş ...

açıklama

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 sayesinde bir byte tasarrufu .

Excel, 85 79 bayt

Aşağıdaki formülü N, giriş referans hücresi için bir ad olduğundan, hücre dışındaki herhangi bir hücreye yerleştirin:

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

Açıklama:

• NGirdi ve ayrıca referans hücrenin adıdır .
• LEFT(N) giriş değerinin ilk basamağını alın.
• LEN(N) giriş değerinin uzunluğunu döndürün.
• REPT(LEFT(N),LEN(N)) giriş değerinin ilk hanesini tekrarlayın LEN(N)Metin sayı biçimine dönüştürmek için zamanlarının 1 ile çarpın, böylece sayı karşılaştırması için kullanabiliriz.
• Microsoft Excel'deki IF işlevi için sözdizimi şöyledir: IF (koşul, [value_if_true], [value_if_false]) , bu nedenle formülün tamamı açıklayıcıdır.

Brachylog v2, 6 bayt

;.+=∧ℕ

Çevrimiçi deneyin!

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

5-byte +↙.=∧ihmal ile ortadan kalkar, ℕçünkü pozitif olmayan çıktıları hiç denemez, fakat zaten bir repdigit olan bir sayı verildiğinde de başarısız olur çünkü pozitif olmayan çıktıları hiç denemez.

Java, 59 bayt

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

(Java girişlerinin nasıl sayılacağından hala emin değilim, ancak ilk Java girişi tarafından belirlenen standartlara göre bu giriş 59 byte, çünkü 17 byte daha kısa.)

Her neyse, eğer bir repdigitimiz varsa, 0 değerini döndürün, aksi takdirde girişe 1 ekleyin, kendisini arayın ve sonucu 1 ekleyin.

Ungolfed ve test durumları:

Burada dene.

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

Çıktı:

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

Gördüğünüz gibi, son giriş tamamlanmadan önce bellek yetersiz kalır. (Çok uygun) StackOverflowErroratılmış java.util.regex.Pattern.sequence(Pattern.java:2134), ancak regex'in kendisinde yanlış bir şey olmadığından eminim, çünkü önceki girişimde kullandığımla aynı .

C #, 82 bayt

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

C, 84 bayt

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

Ana test:

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 bayt

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.

Çevrimiçi deneyin!