En l'honneur du nombre de représentants que j'avais il y a plusieurs heures, lorsque j'ai pensé à ce défi pour la première fois:

Des nombres comme celui-ci qui sont constitués d'un seul chiffre répétitif sont appelés repdigits . Les chiffres sont amusants! Chaque corps serait plus heureux si la quantité de représentant qu'ils avaient était un nombre uniforme ¹ , mais je suis impatient, alors vous devez me aider à trouver le meilleur moyen d'arriver à un nombre uniforme.

Voici votre défi:

Compte tenu d' un représentant des nombres entiers positifs réputation, sortie le montant minimum de représentant dont ils ont besoin pour gagner pour arriver à un nombre uniforme. Par exemple, au moment d'écrire ce défi, l'utilisateur Martin Ender avait 102 856 représentants. Le chiffre de rep le plus proche est 111,111, il devrait donc gagner: 8255 rep pour être à un chiffre de rep.

Étant donné que les gens n'aiment pas perdre leur représentant, nous ne considérerons que les changements non négatifs. Cela signifie que, par exemple, si quelqu'un est à 12 répétitions, plutôt que de perdre 1 répétition, la solution est de gagner 10 répétitions. Cela permet à «0» d'être une sortie valide, car toute personne ayant 111 rep est déjà à un chiffre rep.

L'entrée et la sortie peuvent être dans n'importe quel format raisonnable , et comme il est impossible d'avoir moins de 1 représentant sur un site Stack Exchange, vous pouvez supposer qu'aucune entrée ne sera inférieure à 1.

Une valise d'angle à noter:

Si un utilisateur a moins de 10 répétitions, il est déjà à un chiffre de répétition et a donc également besoin de «0».

Test IO:

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

Les failles standard s'appliquent et la solution la plus courte en octets l'emporte!

Gelée , 6 octets

DE$1#_

La sortie est un tableau singleton.

Essayez-le en ligne! ou vérifiez la plupart des cas de test . Le cas de test 87654321 est trop lent pour TIO.

Comment ça marche

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 octets

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

Essayez-le en ligne

Brachylog , 9 octets

:.#++#==,

Essayez-le en ligne!

C'est assez efficace car il utilise l'arithmétique des contraintes.

Explication

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

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

Pas l'approche la plus courte, mais très efficace. Testez-le sur Ideone .

Comment ça marche

Pour les 10**len(`n`)tours d' entrée n jusqu'à la puissance la plus proche de 10 . Ensuite, nous divisons le résultat par 9 . Cela renvoie le chiffre 1 à 1 qui contient autant de chiffres que n . Nous enregistrons le résultat dans r . Par exemple, si n = 87654321 , alors r = 11111111 .

Le chiffre souhaité sera un multiple ou un r . Pour décider lequel, nous effectuons la division du plafond de n par r . Depuis les /étages de l' opérateur de division de Python 2 , cela peut être réalisé avec -n/r, ce qui donnera la valeur absolue correcte, avec un signe négatif. Par exemple, si n = 87654321 , cela renverra -8 .

Enfin, nous multiplions le quotient calculé par -r pour répéter le quotient une fois pour chaque chiffre de n . Par exemple, si n = 87654321 , cela renvoie 88888888 , qui est le chiffre souhaité.

Enfin, pour calculer l'incrément requis, on soustrait n du résultat précédent. Pour notre exemple n = 87654321 , cela renvoie 1234567 , comme souhaité.

Python 2, 37 octets

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

Testez-le sur Ideone . Notez que cette approche est trop inefficace pour le cas de test 87654321 .

Comment ça marche

Si n est déjà un chiffre, 1-len(set(`n`))renverra 0 puisque la longueur de l'ensemble des n chiffres de la base 10 sera 1 . Dans ce cas, f renvoie 0 .

Si n n'est pas un chiffre, f(n+1)appelle récursivement f avec la prochaine valeur possible de n . -~incrémente la valeur de retour de f ( 0 lorsqu'un chiffre est trouvé) de 1 chaque fois que f est appelé récursivement, de sorte que la valeur de retour finale est égale au nombre de fois que f a été appelé, c'est-à-dire que le nombre de fois où n a dû être incrémenté à obtenir un repdigit.

Perl 6 , 23 octets

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

Un lambda qui prend le numéro d'entrée comme argument et renvoie le résultat.

Explication:

1. Utilise l' ...opérateur de séquence pour incrémenter le numéro d'entrée jusqu'à ce qu'il atteigne un chiffre (testé en divisant sa représentation sous forme de chaîne en caractères et en voyant s'ils sont tous égaux) .
2. Soustrait un de la longueur de la séquence.

Java 7, 116 76 octets

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

Utilisé l'approche étonnante de @Dennis pour réduire le nombre d'octets de 40 octets.

Cas non testés et testés:

Essayez ici.

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

Sortie:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 octets

1 octet grâce à @FryAmTheEggman.

-f@F`TQ

Essayez-le en ligne.

Très inefficace, boucle tous les nombres de l'entrée au chiffre suivant.

Brain-Flak 690358 octets

Voici mon coup

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

Essayez-le en ligne

Explication

Commencez par faire une deuxième copie de l'entrée qui est une de moins que l'original. Nous utiliserons la copie pour rechercher le prochain chiffre. Nous soustrayons un au cas où le nombre lui-même était un chiffre

(({})[()])

Appuyez sur l'un pour satisfaire la boucle à venir. (ne doit pas nécessairement être un, mais pas zéro)

(())

Cette boucle s'exécutera jusqu'à ce qu'il y ait un chiffre de répétition au-dessus de la pile

{

Pop the merde. C'est un "booléen" sur le dessus qui pilote la boucle, car il n'est plus nécessaire de le faire éclater.

{}

Ajoutez-en un et dupliquez le haut. La copie sera décomposée en ses chiffres.

(({}()))

Alors que la copie n'est pas nulle ...

{

Copiez à nouveau

(({}))

Mod 10 et passez à l'autre pile

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

Diviser par 10 (division entière)

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

}

Pop the zero that was our copy

{}

Nous avons maintenant décomposé le nombre en ses 10 chiffres de base, nous allons donc basculer sur la pile avec tous les chiffres.

<>

Alors que le premier chiffre n'est pas zéro

{

On récupère une copie de la hauteur de pile (ie le nombre de chiffres) ...

(([])<

Soustrayez silencieusement un de chaque nombre sur la pile

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

Mettez la hauteur de pile que nous avons ramassée. (et permutez sur l'autre pile)

><>)

Nous utilisons la hauteur de la pile pour ramener tous les chiffres que nous avons placés sur l'autre pile sur la pile appropriée.

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

Pop le zéro qui était notre hauteur de pile

{}

Retournez sur la pile avec les chiffres (ou quels étaient les chiffres)

<>

Boucle de fin

}

Maintenant, nous avons soustrait le chiffre supérieur de tous les autres chiffres. Si tous les chiffres sont nuls, le numéro d'origine (pas l'entrée mais le numéro que nous vérifions) était un chiffre nouveau. ^{[citation nécessaire]} . Nous devons donc vérifier les non-zéros.

Alors que la hauteur de pile n'est pas nulle

([])
{
{}

Si le chiffre n'est pas zéro, déplacez-le vers l'autre pile et remplacez-le par un zéro.

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

Pop it (maintenant c'est un zéro)

{}

Boucle de fin

([])
}
{}

Échangez sur l'autre pile (duh ..)

<>

Prenez-nous une copie de la hauteur de pile moins deux

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

Alors que la hauteur de la pile n'est pas deux (l'original et l'accumulateur)

{
{}

Pop the top

{}

Fin du temps

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

Déposez notre copie de la hauteur de pile moins deux. Cela finit par être le nombre de chiffres qui ne sont pas les mêmes que le premier chiffre. En d'autres termes, s'il est nul, c'est un chiffre.

>)

Si cette boucle se termine, nous avons trouvé un repdigit

}

Pop le "booléen"

{}

Soustrayez l'original du repdigit

({}[{}])

Python 2, 52 octets

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

Python 2 a plusieurs astuces qui raccourcissent cela. Par exemple, l'entrée est numérique, nous n'avons donc pas besoin de transtyper en int. (-5 octets) Nous n'avons pas non plus besoin de mettre de parenthèses autour du a-b(-1 octet)

Utilisez ce script pour vérifier tous les cas de test:

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

Vous pouvez également l' essayer en ligne!

GNU sed, 223 + 1 (drapeau r) = 224 octets

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

Courir:

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

Sortie:

110

Il s'agit d'une solution pure sed , l'arithmétique est simulée à l'aide d'expressions régulières uniquement. L'algorithme fonctionne comme suit:

1. le format d'espace de motif est défini sur ^current_reputation:needed_reputation%$
2. à chaque itération de la boucle principale, les séparateurs sont commutés:
   a) %:applique l'incrément à required_reputation
   b) :%applique l'incrément à current_reputation
3. si current_reputation est un "repdigit", la required_reputation est imprimée et le programme se termine

Java, 74 72 octets

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

(Si l'autre entrée Java fait 76 octets, celle-ci est74 72, puisqu'il est deux quatre octets de moins).

Quoi qu'il en soit, il suffit d'incrémenter l'entrée jusqu'à ce qu'il s'agisse d'un nouveau chiffre tout en incrémentant un compteur. Retournez le comptoir.

Oui, ce sont trois avantages consécutifs, deux pour incrémenter l'entrée, un pour concaténer une chaîne vide pour en faire une chaîne.
Non, je ne pensais pas que ce serait légal sans un espace entre les deux, mais voilà. C'est ce qu'une faute de frappe fera pour vous: un octet plus court.

L'utilisation d'une boucle for au lieu d'un certain temps prend exactement autant d'octets:

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

Modifier:

Une version antérieure devait matches("^(\\d)\\1*$")vérifier un repdigit, mais comme nous venons de convertir un int en chaîne, utiliser un .pour correspondre suffit.

Cas non testés et testés:

Essayez ici.

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

}

Sortie:

0
11
109
1234567
2
2222
11090

R, 102 98 91 octets

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

Jouer avec le format ( as.numericetas.character ) ajoute quelques octets, mais R n'est pas vraiment flexible!

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

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

Si l'impression de rien au lieu de 0lorsque le nombre est déjà un chiffre est acceptable, alors 37 octets suffisent:

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

Exécuter avec -n(1 octet) et -Eou -M5.010(gratuit):

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

Explications : le code comporte deux parties principales: /^(.)\1*$/&&say$vet $_++&&++$v&&redo. Le premier teste if $_est un repdigit; si oui, il imprime le numéro que nous avons ajouté au numéro d'origine pour en faire un repdigit ( $v), et si non, nous avons eu 1 pour les deux $_et $v, et recommencer.

JavaScript (ES6), 42 octets

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

Explication: Calcule récursivement pla puissance suivante de l' 10after n. Le chiffre à répéter est ensuite calculé comme 1+floor(9n/p), et la répétition est simplement (p-1)/9, dont le résultat suit.

05AB1E , 10 6 octets

∞.Δ+Ë

Essayez-le en ligne!

Explication

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

Pyke, 13 11 octets

o+`}ltIr)ot

Essayez-le ici!

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

En fait, 15 octets

;D;WXu;$╔l1<WX-

Essayez-le en ligne!

Explication:

;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

Méduse , 20 octets

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

Essayez-le en ligne! TIO ne peut pas gérer les cas de test plus longs, mais avec suffisamment de temps et de mémoire, ils devraient également fonctionner.

Explication

• iest entrée et la <décrémente. Cette valeur est envoyée à la fonction de gauche.
• \> incrémente la valeur (au moins une fois) jusqu'à ce que la fonction de droite donne une valeur véridique.
• La fonction de test est une composition (par &s) de quatre fonctions.
• 0~j convertit en chaîne.
• u supprime les chiffres en double.
• > supprime la tête de la chaîne résultante.
• Nest une négation logique: elle donne 1pour une chaîne vide, et 0pour non-vide. Ainsi, la fonction teste un chiffre de répétition, et le résultat de \est le chiffre de répétition suivant à partir de <i.
• )-soustrait le résultat de l'entrée de fonction, c'est-à-dire <i.
• Cette différence est réduite d'un, donc la <diminue. Enfin, pimprime le résultat.

PowerShell v2 +, 66 octets

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

Le casting très lâche habituellement bon pour le golf de PowerShell est une chute majeure ici.

Prend l'entrée $nsous forme de chaîne et entre dans une forboucle. Pour l'étape de configuration, nous extrayons le premier caractère $n[0], mais devons le reconvertir en chaîne "$(...)"avant de le convertir en entier +et de l'enregistrer $x. Sinon, l'arithmétique ultérieure utilisera la valeur ASCII du code de caractère.

Le conditionnel vérifie si une chaîne construite à partir de $n.length "$x"s, stockée temporairement dans $y, est inférieure à $n. Tant que ce n'est pas le cas, nous incrémentons $x++, en configurant le conditionnel pour la prochaine boucle.

Par exemple, pour l'entrée 123, la valeur de $yla première vérification du conditionnel sera 111inférieure à $n, de sorte que la boucle continue. Il n'y a rien dans le corps de la boucle, donc l'incrément de pas se produit $x++, puis le conditionnel est vérifié à nouveau. Ce temps $yest égal à 222, ce qui est supérieur à $n, donc la boucle se termine. Si l'entrée est déjà un repdigit, le conditionnel n'est pas satisfait, car à ce point $yest égal à $n.

Une fois hors de la boucle, nous transtypons $yen un entier +, puis soustrayons $n. Ce résultat est laissé sur le pipeline et la sortie est implicite.

PHP 5.6, 59 53 51 50 octets

Enregistré 6 8 octets grâce à @manatwork.

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

Testez avec:

php test.php 11132

La count_chars()fonction avec 3 comme deuxième paramètre renvoie une chaîne avec les caractères distincts dans une chaîne. Lorsque cette chaîne contient 1 caractère ( [1]renvoie false lorsqu'elle est de longueur 1), alors écho $b, sinon incrémentez $bet bouclez à nouveau.

MATL , 10 octets

q`QtVda}G-

Essayez-le en ligne!

Cela continue à incrémenter l'entrée jusqu'à ce que tous les chiffres soient égaux, donc c'est lent. Le cas de test pour les 87654321délais d'expiration dans le compilateur en ligne.

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 caractères

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

Attend une entrée de chaîne.

Échantillon échantillon:

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

Ruby, 39 caractères

Appel récursif, s'exécute dans «SystemStackError: niveau de pile trop profond» sur des résultats plus importants.

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

Échantillon échantillon:

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 octets

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

À cause de la boucle while, c'est plutôt lent ...

Explication

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

Enregistrement d'un octet grâce à @Luis Mendo .

Excel, 85 79 octets

Mettez la formule suivante dans n'importe quelle cellule, sauf la cellule, Ncar il s'agit d'un nom pour la cellule de référence d'entrée:

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

Explication:

• Nest l'entrée et également le nom de la cellule de référence .
• LEFT(N) prendre le premier chiffre de la valeur d'entrée.
• LEN(N) renvoie la longueur de la valeur d'entrée.
• REPT(LEFT(N),LEN(N))répétez le premier chiffre des LEN(N)temps de valeur d'entrée et multipliez-le par 1 pour convertir le format de texte en format numérique afin que nous puissions l'utiliser pour la comparaison des nombres.
• La syntaxe de la fonction IF dans Microsoft Excel est: IF (condition, [value_if_true], [value_if_false]) , ce qui rend la formule entière explicite.

Brachylog v2, 6 octets

;.+=∧ℕ

Essayez-le en ligne!

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

Le 5 octets +↙.=∧s'en sort en omettant ℕcar il n'essaie pas du tout de sorties non positives, mais il échoue également lorsqu'il reçoit un nombre qui est déjà un chiffre car il n'essaie pas du tout de sorties non positives.

Java, 59 octets

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

(Je ne sais toujours pas comment compter les entrées Java, mais selon la norme définie par la première entrée Java , cette entrée est de 59 octets, car elle est de 17 octets plus courte).

Quoi qu'il en soit, si nous avons un chiffre rep, renvoyez 0, sinon ajoutez 1 à l'entrée, appelez-vous et ajoutez 1 au résultat.

Cas non testés et testés:

Essayez ici.

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

Sortie:

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

Comme vous pouvez le voir, la dernière entrée manque de mémoire avant de pouvoir se terminer. Le (très approprié) StackOverflowErrorest jeté java.util.regex.Pattern.sequence(Pattern.java:2134), mais je suis assez confiant qu'il n'y a rien de mal avec le regex lui-même, car c'est le même que j'ai utilisé dans mon entrée précédente .

C #, 82 octets

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

C, 84 octets

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

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 octets

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.

Essayez-le en ligne!