In onore di quanto rappresentante avevo diverse ore fa, quando ho pensato per la prima volta a questa sfida:

Numeri come questo che sono composti da una singola cifra ripetuta sono chiamati repdigits . Le riprese sono divertenti! Ogni corpo sarebbe più felice se la quantità di rep che avevano era un rimprovero ¹ , ma io sono impaziente, quindi devi aiutarmi a scoprire il modo più veloce per arrivare a un rimpatrio.

Ecco la tua sfida:

Dato un numero intero positivo che rappresenta la reputazione, genera l'ammontare minimo di rappresentante necessario per ottenere una modifica. Ad esempio, al momento di scrivere questa sfida, l'utente Martin Ender aveva 102.856 rappresentanti. La cifra rep più vicina è 111.111, quindi avrebbe bisogno di guadagnare: 8255 rep per essere in fase di riconfigurazione.

Poiché alle persone non piace perdere il rappresentante, prenderemo in considerazione solo cambiamenti non negativi. Ciò significa che, ad esempio, se qualcuno ha 12 ripetizioni, anziché perdere 1 rep, la soluzione è guadagnare 10 rep. Ciò consente a "0" di essere un output valido, dal momento che chiunque abbia 111 rep è già in fase di modifica.

L'input e l'output possono essere in qualsiasi formato ragionevole e poiché è impossibile avere meno di 1 rappresentante su qualsiasi sito di Stack Exchange, si può presumere che nessun input sia inferiore a 1.

Una maiuscola da notare:

Se un utente ha meno di 10 rappresentanti, è già in fase di modifica e quindi ha bisogno anche di '0'.

Test IO:

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

Si applicano scappatoie standard e vince la soluzione più breve in byte!

Gelatina , 6 byte

DE$1#_

L'output è un array singleton.

Provalo online! o verifica la maggior parte dei casi di test . Il test case 87654321 è troppo lento per TIO.

Come funziona

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

Provalo online

Brachylog , 9 byte

:.#++#==,

Provalo online!

Questo è piuttosto efficace in quanto utilizza i vincoli aritmetici.

Spiegazione

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

Non è l'approccio più breve, ma molto efficiente. Provalo su Ideone .

Come funziona

Per 10**len(`n`)round di input n fino alla potenza più vicina di 10 . Successivamente, dividiamo il risultato per 9 . Questo restituisce la modifica 1 ... 1 che ha tante cifre quanti sono n . Salviamo il risultato in r . Ad esempio, se n = 87654321 , quindi r = 11111111 .

Il repdigit desiderato sarà multiplo o r . Per decidere quale, eseguiamo la divisione del soffitto di n per r . Dal momento che l'operatore di divisione di Python 2 è a terra /, questo può essere ottenuto con -n/r, che produrrà il valore assoluto corretto, con segno negativo. Ad esempio, se n = 87654321 , questo restituirà -8 .

Infine, moltiplichiamo il quoziente calcolato per -r per ripetere il quoziente una volta per ogni cifra in n . Ad esempio, se n = 87654321 , questo restituisce 88888888 , che è la modifica desiderata.

Infine, per calcolare l'incremento richiesto, sottraggiamo n dal risultato precedente. Per il nostro esempio n = 87654321 , questo restituisce 1234567 , come desiderato.

Python 2, 37 byte

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

Provalo su Ideone . Si noti che questo approccio è troppo inefficiente per il test case 87654321 .

Come funziona

Se n è già una riconfigurazione, 1-len(set(`n`))restituirà 0 poiché la lunghezza dell'insieme di n cifre nella base 10 sarà 1 . In questo caso, f restituisce 0 .

Se n non è un riporto, f(n+1)chiama ricorsivamente f con il successivo valore possibile di n . -~incrementa il valore di ritorno di f ( 0 quando viene trovata una modifica) di 1 ogni volta che f viene chiamato in modo ricorsivo, quindi il valore di ritorno finale è uguale al numero di volte in cui è stato chiamato f , vale a dire, il numero di volte che n ha dovuto essere incrementato a ottenere una riprogettazione.

Perl 6 , 23 byte

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

Un lambda che accetta il numero di input come argomento e restituisce il risultato.

Spiegazione:

1. Utilizza l' ...operatore di sequenza per incrementare il numero di input fino a quando non raggiunge una modifica (testato dividendo la sua rappresentazione in stringhe in caratteri e vedendo se sono tutti uguali) .
2. Sottrae uno dalla lunghezza della sequenza.

Java 7, 116 76 byte

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

Utilizzato lo straordinario approccio di @Dennis per ridurre il numero di byte di ben 40 byte.

Casi non testati e test:

Provalo qui.

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

Produzione:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 byte

1 byte grazie a @FryAmTheEggman.

-f@F`TQ

Provalo online.

Molto inefficiente, scorre tutti i numeri dall'input alla successiva modifica.

Brain-Flak 690 358 byte

Ecco il mio tentativo

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

Provalo online

Spiegazione

Inizia facendo una seconda copia dell'input che è una in meno rispetto all'originale. Useremo la copia per cercare la prossima modifica. Ne sottraggiamo uno nel caso in cui il numero stesso fosse una modifica

(({})[()])

Spingine uno per soddisfare il prossimo loop. (non deve essere uno solo non zero)

(())

Questo ciclo verrà eseguito fino a quando non vi sarà una riprogettazione in cima allo stack

{

Fai schifo. Il loro è un "booleano" in cima che guida il loop, poiché non è più necessario lo pop.

{}

Aggiungine uno e duplica la parte superiore. La copia verrà scomposta in cifre.

(({}()))

Mentre la copia non è zero ...

{

Copia di nuovo

(({}))

Mod 10 e passa all'altro stack

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

Dividi per 10 (Divisione intera)

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

}

Pop lo zero che era la nostra copia

{}

Ora abbiamo scomposto il numero nella sua base di 10 cifre, quindi passiamo allo stack con tutte le cifre.

<>

Mentre la cifra iniziale non è zero

{

Prendiamo una copia dell'altezza della pila (cioè il numero di cifre) ...

(([])<

Sottrai silenziosamente uno da ogni numero in pila

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

Metti l'altezza della pila che abbiamo raccolto. (e passare all'altro stack)

><>)

Usiamo l'altezza della pila per riportare tutte le cifre che abbiamo posizionato sull'altra pila nella pila corretta.

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

Pop lo zero che era la nostra altezza dello stack

{}

Scambia di nuovo sulla pila con le cifre (o quali erano le cifre)

<>

End loop

}

Ora abbiamo sottratto la cifra superiore da tutte le altre cifre. Se tutte le cifre sono pari a zero, il numero originale (non l'input ma il numero che stiamo controllando) era una modifica.^{[citazione necessaria]} . Quindi dobbiamo verificare la presenza di valori diversi da zero.

Mentre l'altezza della pila non è zero

([])
{
{}

Se la cifra non è zero, spostarla sull'altro stack e sostituirla con uno zero.

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

Pop (ora è uno zero)

{}

End loop

([])
}
{}

Scambia sull'altro stack (duh ..)

<>

Prendi una copia dell'altezza della pila meno due

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

Mentre l'altezza della pila non è due (l'originale e l'accumulatore)

{
{}

Pop in alto

{}

Termina il tempo

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

Metti giù la nostra copia dell'altezza della pila meno due. Questo finisce per essere il numero di cifre che non corrispondono alla prima cifra. In altre parole, se è zero, è una riprogettazione.

>)

Se questo ciclo termina, abbiamo trovato una riprogettazione

}

Pop il "booleano"

{}

Sottrai l'originale dalla modifica

({}[{}])

Python 2, 52 byte

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

Python 2 ha diversi trucchi che lo rendono più breve. Ad esempio, l'input è numerico, quindi non è necessario eseguire il cast in int. (-5 byte) Inoltre non è necessario mettere la parentesi attorno al a-b(-1 byte)

Utilizzare questo script per verificare tutti i casi di 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])

Puoi anche provarlo online!

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

Correre:

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

Produzione:

110

Questa è una soluzione sed pura , l'aritmetica viene simulata usando solo espressioni regolari. L'algoritmo funziona come segue:

1. il formato dello spazio modello è impostato su ^current_reputation:needed_reputation%$
2. in ogni iterazione del ciclo principale i commutatori sono commutati:
   a) %:applica l'incremento a necessario_reputation
   b) :%applica l'incremento a corrente_reputation
3. se current_reputation è un "repdigit", la necessario_reputation viene stampata e il programma termina

Giava, 74 72 byte

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

(Se l'altra voce Java è 76 byte, questa è74 72, dal momento che lo è Due quattro byte più brevi).

Ad ogni modo, basta incrementare l'input fino a quando non è una modifica mentre si incrementa un contatore. Restituisci il contatore.

Sì, questi sono tre vantaggi di fila, due per aumentare l'input, uno per concatenare una stringa vuota per renderla una stringa.
No, non pensavo che sarebbe stato legale senza uno spazio tra i due, ma il gioco è fatto. Ecco cosa farà un refuso per te: un byte più breve.

L'utilizzo di un ciclo for anziché un po 'richiede esattamente quanti byte:

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

Modificare:

Una versione precedente doveva matches("^(\\d)\\1*$")verificare una riprogettazione, ma poiché abbiamo appena convertito un int in una stringa, .è sufficiente usare a per abbinare.

Casi non testati e test:

Provalo qui.

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

}

Produzione:

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

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

Giocare con il formato (as.numeric eas.character ) aggiunge alcuni byte, ma R non è davvero flessibile!

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

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

Se non è possibile stampare nulla invece di 0quando il numero è già un riporto, sono sufficienti 37 byte:

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

Esegui con -n(1 byte) e -Eo-M5.010 (gratuito):

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

Spiegazioni : ci sono due parti principali nel codice: /^(.)\1*$/&&say$ve $_++&&++$v&&redo. Il primo test if $_è un repdigit; in caso affermativo stampa il numero che abbiamo aggiunto al numero originale per renderlo un repdigit ( $v), e se no, ne avevamo 1 per entrambi $_e $v, e ricominciare da capo.

JavaScript (ES6), 42 byte

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

Spiegazione: calcola ricorsivamente pcome la potenza successiva di 10after n. La cifra da ripetere viene quindi calcolata come 1+floor(9n/p), e la repunit è semplicemente (p-1)/9, dalla quale segue il risultato.

05AB1E , 10 6 byte

∞.Δ+Ë

Provalo online!

Spiegazione

∞<      # 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

Provalo qui!

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

In realtà, 15 byte

;D;WXu;$╔l1<WX-

Provalo online!

Spiegazione:

;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

Meduse , 20 byte

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

Provalo online! TIO non è in grado di gestire i casi di test più lunghi, ma dato il tempo e la memoria sufficienti, dovrebbero funzionare anche.

Spiegazione

• iviene immesso e lo <decrementa. Questo valore viene inviato alla funzione a sinistra.
• \> incrementa il valore (almeno una volta) fino a quando la funzione a destra fornisce un valore di verità.
• La funzione di test è una composizione (per &) di quattro funzioni.
• 0~j converte in stringa.
• u rimuove le cifre duplicate.
• > rimuove la testa della stringa risultante.
• Nè una negazione logica: dà 1per una stringa vuota e 0per non vuota. Pertanto la funzione verifica una cifra rep e il risultato di \è la prossima cifra rep da contare<i .
• )- sottrae il risultato dall'input della funzione, ovvero <i .
• Questa differenza è ridotta di una, quindi la <diminuisce. Infine, pstampa il risultato.

PowerShell v2 +, 66 byte

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

Il casting molto sciolto di solito per golf di PowerShell è una grande caduta qui.

Prende l'input $ncome stringa ed entra in un forciclo. Per la fase di installazione, estraiamo il primo carattere $n[0], ma dobbiamo riconvertirlo in una stringa "$(...)"prima di lanciarlo come int +e salvarlo in$x . In caso contrario, l'aritmetica successiva utilizzerà il valore ASCII del codice char.

Il condizionale controlla se una stringa costruita da $n.length "$x"s, temporaneamente memorizzata in $y, è minore di $n. Finché non lo è, incrementiamo$x++ , impostando il condizionale per il ciclo successivo.

Ad esempio, per l'input 123, sarà il valore di $yquando viene controllato per la prima volta il condizionale 111, che è minore di $n, quindi il ciclo continua. Non c'è nulla nel corpo del loop, quindi si verifica l'incremento del passo $x++, quindi il condizionale viene ricontrollato. Questa volta è $yuguale a 222, che è maggiore di $n, quindi il ciclo termina. Se l'input è già un riporto, il condizionale non è soddisfatto, perché a quel punto $yè uguale a $n.

Una volta fuori dal ciclo, eseguiamo il cast $ysu un numero intero +, quindi sottraggiamo $n. Tale risultato viene lasciato sulla pipeline e l'output è implicito.

PHP 5.6, 59 53 51 50 byte

Risparmiato 6 8 byte grazie a @manatwork.

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

Prova con:

php test.php 11132

La count_chars()funzione con 3 come secondo parametro restituisce una stringa con i caratteri distinti in una stringa. Quando questa stringa è lunga 1 carattere ( [1]restituirà false quando è lunghezza 1), quindi echo $b, altrimenti incrementa $be ricomincia.

MATL , 10 byte

q`QtVda}G-

Provalo online!

Questo continua ad aumentare l'input fino a quando tutte le cifre sono uguali, quindi è lento. Il caso di test per l'input 87654321scade nel compilatore 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

Rubino, 42 caratteri

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

Si aspetta un input da stringa.

Esecuzione di esempio:

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

Rubino, 39 personaggi

Chiamata ricorsiva, si verifica in "SystemStackError: livello dello stack troppo profondo" per risultati più grandi.

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

Esecuzione di esempio:

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)

A causa del ciclo while è piuttosto lento ...

Spiegazione

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

Salvataggio di un byte grazie a @Luis Mendo .

Excel, 85 79 byte

Inserisci la seguente formula in qualsiasi cella tranne la cella Npoiché è un nome per la cella di riferimento di input:

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

Spiegazione:

• Nè l'input e anche il nome della cella di riferimento .
• LEFT(N) prende la prima cifra del valore di input.
• LEN(N) restituisce la lunghezza del valore di input.
• REPT(LEFT(N),LEN(N))ripetere la prima cifra dei LEN(N)tempi del valore di input e moltiplicarla per 1 per convertire il formato del testo in formato numerico in modo da poterlo utilizzare per il confronto dei numeri.
• La sintassi per la funzione IF in Microsoft Excel è: IF (condition, [value_if_true], [value_if_false]) , quindi rende l'intera formula autoesplicativa.

Brachylog v2, 6 byte

;.+=∧ℕ

Provalo online!

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

Il 5 byte se ne +↙.=∧va omettendo ℕperché non prova affatto uscite non positive, ma fallisce anche quando viene dato un numero che è già una riconfigurazione perché non prova affatto uscite non positive.

Java, 59 byte

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

(Non sono ancora sicuro di come contare le voci Java, ma secondo lo standard impostato dalla prima voce Java , questa voce è di 59 byte, poiché è più corta di 17 byte).

Ad ogni modo, se abbiamo una riprogettazione, restituisce 0, altrimenti aggiungi 1 all'input, chiama se stesso e aggiungi 1 al risultato.

Casi non testati e test:

Provalo qui.

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

Produzione:

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

Come puoi vedere, l'ultima voce esaurisce la memoria prima che possa finire. Il (molto appropriato) StackOverflowErrorviene lanciato da java.util.regex.Pattern.sequence(Pattern.java:2134), ma sono abbastanza sicuro che non ci sia nulla di sbagliato nel regex stesso, poiché è lo stesso che ho usato nella mia voce precedente .

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

Test principale:

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.

Provalo online!