En honor a la repetición que tuve hace varias horas, cuando pensé por primera vez en este desafío:

Los números como este que se componen de un solo dígito que se repite se llaman repdigits . ¡Los repdigits son divertidos! Todo el mundo sería más feliz si la cantidad de repeticiones que tenían era un repdigit ¹ , pero estoy impaciente, por lo que necesita para ayudar a encontrar el camino más rápido para llegar a un repdigit.

Aquí está tu desafío:

Dado un número entero positivo que representa la reputación, genere la cantidad mínima de repeticiones que necesitan ganar para llegar a un digito de rep . Por ejemplo, al momento de escribir este desafío, el usuario Martin Ender tenía 102,856 rep. El dígito de rep más cercano es 111,111, por lo que necesitaría ganar: 8255 rep para estar en un repdigit.

Dado que a las personas no les gusta perder reputación, solo consideraremos cambios no negativos. Esto significa que, por ejemplo, si alguien tiene 12 repeticiones, en lugar de perder 1 repetición, la solución es ganar 10 repeticiones. Esto permite que '0' sea una salida válida, ya que cualquiera que tenga 111 rep ya está en un repdigit.

La entrada y la salida pueden estar en cualquier formato razonable , y dado que es imposible tener menos de 1 repetición en cualquier sitio de Stack Exchange, puede asumir que ninguna entrada será menor que 1.

Una esquina para tener en cuenta:

Si un usuario tiene menos de 10 rep, ya está en un digito de rep, por lo que también necesita '0'.

Prueba IO:

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

Se aplican lagunas estándar, ¡y gana la solución más corta en bytes!

Jalea , 6 bytes

DE$1#_

La salida es una matriz singleton.

Pruébalo en línea! o verificar la mayoría de los casos de prueba . El caso de prueba 87654321 es demasiado lento para TIO.

Cómo funciona

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 bytes

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

Pruébalo en línea

Brachylog , 9 bytes

:.#++#==,

Pruébalo en línea!

Esto es bastante eficiente ya que utiliza restricciones aritméticas.

Explicación

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

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

No es el enfoque más corto, pero muy eficiente. Pruébalo en Ideone .

Cómo funciona

Para 10**len(`n`)rondas de entrada n hasta la potencia más cercana de 10 . Luego, dividimos el resultado entre 9 . Esto devuelve el repdigit 1 ... 1 que tiene tantos dígitos como n . Guardamos el resultado en r . Por ejemplo, si n = 87654321 , entonces r = 11111111 .

El repdigit deseado será un múltiplo o r . Para decidir cuál, realizamos la división del techo de n por r . Desde los /pisos de operador de división de Python 2 , esto se puede lograr con -n/r, lo que arrojará el valor absoluto correcto, con signo negativo. Por ejemplo, si n = 87654321 , esto devolverá -8 .

Finalmente, multiplicamos el cociente calculado por -r para repetir el cociente una vez por cada dígito en n . Por ejemplo, si n = 87654321 , esto devuelve 88888888 , que es el digito deseado.

Finalmente, para calcular el incremento requerido, restamos n del resultado anterior. Para nuestro ejemplo n = 87654321 , esto devuelve 1234567 , como se desee.

Python 2, 37 bytes

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

Pruébalo en Ideone . Tenga en cuenta que este enfoque es demasiado ineficiente para el caso de prueba 87654321 .

Cómo funciona

Si n ya es un repdigit, 1-len(set(`n`))devolverá 0 ya que la longitud del conjunto de dígitos de n en la base 10 será 1 . En este caso, f devuelve 0 .

Si n no es un repdigit, f(n+1)recurrentemente llama f con el siguiente valor posible de n . -~incrementos el valor de retorno de f ( 0 cuando se encuentra una repdigit) por 1 cada vez que f se llama de forma recursiva, por lo que el valor de retorno final es igual al número de veces f que se ha llamado, es decir, el número de veces n tuvieron que ser incrementado a obtener un repdigit.

Perl 6 , 23 bytes

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

Una lambda que toma el número de entrada como argumento y devuelve el resultado.

Explicación:

1. Utiliza el ...operador de secuencia para incrementar el número de entrada hasta que alcanza un dígito repetido (probado al dividir su representación de cadena en caracteres y ver si son todos iguales) .
2. Resta uno de la longitud de la secuencia.

Java 7, 116 76 bytes

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

Se utilizó el sorprendente enfoque de @Dennis para reducir el conteo de bytes en la friolera de 40 bytes.

Sin golf y casos de prueba:

Pruébalo aquí.

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

Salida:

0
11
109
1234567
2
2222
11090

Pyth, 9 8 7 bytes

1 byte gracias a @FryAmTheEggman.

-f@F`TQ

Pruébalo en línea.

Muy ineficiente, recorre todos los números desde la entrada hasta el siguiente repdigit.

Brain-Flak 690358 bytes

Aquí está mi intento

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

Pruébalo en línea

Explicación

Comience por hacer una segunda copia de la entrada que sea una menos que la original. Usaremos la copia para buscar el próximo repdigit. Restamos uno en caso de que el número en sí fuera un digito

(({})[()])

Presione uno para satisfacer el bucle que viene. (no tiene que ser uno simplemente no cero)

(())

Este bucle se ejecutará hasta que haya un dígito en la parte superior de la pila.

{

Pop the crap. Su es un "booleano" en la parte superior que impulsa el bucle, ya que ya no es necesario lo sacamos.

{}

Agrega uno y duplica la parte superior. La copia se descompondrá en sus dígitos.

(({}()))

Si bien la copia no es cero ...

{

Copiar de nuevo

(({}))

Mod 10 y muévete a la otra pila

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

Dividir por 10 (división entera)

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

}

Pop the zero que era nuestra copia

{}

Ahora hemos descompuesto el número en su base de 10 dígitos, por lo que cambiamos a la pila con todos los dígitos.

<>

Mientras que el dígito inicial no es cero

{

Recogemos una copia de la altura de la pila (es decir, el número de dígitos) ...

(([])<

Silenciosamente reste uno de cada número en la pila

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

Ponga la altura de la pila que recogimos. (y cambiar a la otra pila)

><>)

Usamos la altura de la pila para volver a colocar todos los dígitos que colocamos en la otra pila en la pila adecuada.

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

Pop el cero que era nuestra altura de pila

{}

Vuelva a cambiar a la pila con los dígitos (o cuáles fueron los dígitos)

<>

Bucle final

}

Ahora hemos restado el dígito superior de todos los otros dígitos. Si todos los dígitos son cero, el número original (no la entrada sino el número que estamos verificando) fue un digito. ^{[cita requerida]} . Por lo tanto, debemos verificar que no sean ceros.

Mientras que la altura de la pila no es cero

([])
{
{}

Si el dígito no es cero, muévalo a la otra pila y reemplácelo con un cero.

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

Pop it (ahora es un cero)

{}

Bucle final

([])
}
{}

Cambia a la otra pila (duh ..)

<>

Tome una copia de la altura de la pila menos dos

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

Mientras que la altura de la pila no es dos (el original y el acumulador)

{
{}

Pop the top

{}

Termina el rato

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

Anote nuestra copia de la altura de la pila menos dos. Esto termina siendo el número de dígitos que no son iguales al primer dígito. En otras palabras, si es cero, es un digito.

>)

Si este ciclo termina, hemos encontrado un repdigit

}

Pop el "booleano"

{}

Resta el original del repdigit

({}[{}])

Python 2, 52 bytes

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

Python 2 tiene varios trucos que lo hacen más corto. Por ejemplo, la entrada es numérica, por lo que no necesitamos convertir a int. (-5 bytes) Tampoco necesitamos poner paréntesis alrededor dela-b (-1 byte)

Use este script para verificar todos los casos de prueba:

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

¡También puedes probarlo en línea!

GNU sed, 223 + 1 (r flag) = 224 bytes

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

Correr:

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

Salida:

110

Esta es una solución sed pura , la aritmética se simula utilizando solo expresiones regulares. El algoritmo funciona de la siguiente manera:

1. el formato del espacio del patrón se establece en ^current_reputation:needed_reputation%$
2. en cada iteración del bucle principal de los separadores se conmutan:
   a) %:se aplica el incremento a needed_reputation
   b) :%se aplica el incremento a current_reputation
3. si el current_reputation es un "repdigit", el needed_reputation se imprime y el final del programa

Java, 74 72 bytes

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

(Si la otra entrada de Java tiene 76 bytes, esta es74 72, ya que es dos cuatro bytes más cortos).

De todos modos, solo incremente la entrada hasta que sea un dígito de repetición mientras incrementa un contador. Devuelve el mostrador.

Sí, son tres más en una fila, dos para incrementar la entrada, una para concatenar una cadena vacía para convertirla en una cadena.
No, tampoco pensé que sería legal sin un espacio intermedio, pero ahí lo tienes. Eso es lo que un error tipográfico hará por usted: un byte más corto.

Usar un bucle for en lugar de un tiempo requiere exactamente la misma cantidad de bytes:

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

Editar:

Una versión anterior tenía matches("^(\\d)\\1*$")que verificar un repdigit, pero como acabamos de convertir un int en una cadena, .basta con usar un para que coincida.

Sin golf y casos de prueba:

Pruébalo aquí.

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

}

Salida:

0
11
109
1234567
2
2222
11090

R, 102 98 91 bytes

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

Sin golf:

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

Jugar con el formato ( as.numericyas.character ) agrega algunos bytes, ¡pero R no es realmente flexible!

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

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

Si no se imprime nada en lugar de 0cuando el número ya es un digito de repetición, entonces 37 bytes son suficientes:

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

Ejecutar con -n(1 byte) y -Eo -M5.010(gratis):

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

Explicaciones : hay dos partes principales en el código: /^(.)\1*$/&&say$vy $_++&&++$v&&redo. La primera prueba si $_es un repdigit; en caso afirmativo, imprime el número que agregamos al número original para que sea un repdigit ( $v), y si no, teníamos 1 para ambos $_y $v, y comenzamos de nuevo.

JavaScript (ES6), 42 bytes

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

Explicación: Calcula recursivamente pcomo la próxima potencia de 10after n. El dígito que se repetirá se calcula como 1+floor(9n/p), y la repunidad es simplemente (p-1)/9, de donde se deriva el resultado.

05AB1E , 10 6 bytes

∞.Δ+Ë

Pruébalo en línea!

Explicación

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

Pyke, 13 11 bytes

o+`}ltIr)ot

Pruébalo aquí!

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

En realidad, 15 bytes

;D;WXu;$╔l1<WX-

Pruébalo en línea!

Explicación:

;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

Medusa , 20 bytes

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

Pruébalo en línea! TIO no puede manejar los casos de prueba más largos, pero dado suficiente tiempo y memoria, también deberían funcionar.

Explicación

• ies entrada, y lo <disminuye. Este valor se alimenta a la función de la izquierda.
• \> incrementa el valor (al menos una vez) hasta que la función a la derecha da un valor verdadero.
• La función de prueba es una composición (por &s) de cuatro funciones.
• 0~j se convierte en cadena.
• u elimina dígitos duplicados.
• > elimina la cabeza de la cadena resultante.
• Nes negación lógica: da 1una cadena vacía y 0no vacía. Por lo tanto, la función prueba un dígito rep, y el resultado de \es el siguiente recuento de dígitos rep<i .
• )- resta el resultado de la entrada de la función, es decir, <i .
• Esta diferencia está desactivada por uno, así que la <disminuye. Finalmente, pimprime el resultado.

PowerShell v2 +, 66 bytes

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

El lanzamiento de PowerShell, que generalmente es bueno para el golf, es una gran desventaja aquí.

Toma la entrada $ncomo una cadena y entra en un forbucle. Para el paso de configuración, extraemos el primer carácter $n[0], pero tenemos que convertirlo de nuevo en una cadena "$(...)"antes de convertirlo en int +y guardarlo en $x. De lo contrario, la aritmética posterior utilizará el valor ASCII del código de caracteres.

El condicional verifica si una cadena construida a partir de $n.length "$x" s, almacenada temporalmente en $y, es menor que $n. Mientras no sea así, incrementamos $x++, configurando el condicional para el siguiente ciclo.

Por ejemplo, para la entrada 123, el valor de $ycuando el condicional se verifica por primera vez será 111, que es menor que $n, por lo que el ciclo continúa. No hay nada en el cuerpo del bucle, por lo que ocurre el incremento de paso $x++, luego se vuelve a verificar el condicional. Esta vez$y es igual 222, que es mayor que $n, entonces el ciclo termina. Si la entrada ya es un repdigit, el condicional no se cumple, porque en ese punto $yes igual a $n.

Una vez fuera del ciclo, convertimos $ya un entero +, luego restamos$n . Ese resultado se deja en la tubería y la salida es implícita.

PHP 5.6, 59 53 51 50 bytes

Guardado 6 8 bytes gracias a @manatwork.

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

Prueba con:

php test.php 11132

La count_chars()función con 3 como segundo parámetro devuelve una cadena con los distintos caracteres en una cadena. Cuando esta cadena tiene 1 carácter de longitud ( [1]devolverá falso cuando es longitud 1), luego repita $b, de lo contrario incremente $by repita nuevamente.

MATL , 10 bytes

q`QtVda}G-

Pruébalo en línea!

Esto sigue incrementando la entrada hasta que todos los dígitos sean iguales, por lo que es lento. El caso de prueba para la entrada 87654321agota el tiempo en el compilador en línea.

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

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

Espera entrada de cadena.

Ejecución de muestra:

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

Ruby, 39 caracteres

Llamada recursiva, se encuentra con "SystemStackError: nivel de pila demasiado profundo" en resultados más grandes.

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

Ejecución de muestra:

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 bytes

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

Debido al ciclo while es bastante lento ...

Explicación

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

Ahorrando un byte gracias a @Luis Mendo .

Excel, 85 79 bytes

Ponga la siguiente fórmula en cualquier celda, excepto en la celda, Nya que es un nombre para la celda de referencia de entrada:

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

Explicación:

• Nes la entrada y también el nombre de la celda de referencia .
• LEFT(N) tome el primer dígito del valor de entrada.
• LEN(N) Devuelve la longitud del valor de entrada.
• REPT(LEFT(N),LEN(N))repita el primer dígito de los valores de entrada LEN(N)y multiplíquelo por 1 para convertir el formato de texto a formato de número para que podamos usarlo para la comparación de números.
• La sintaxis para la función IF en Microsoft Excel es: IF (condición, [valor_si_verdadero], [valor_si_falso]) , por lo tanto, la fórmula completa se explica por sí misma.

Brachylog v2, 6 bytes

;.+=∧ℕ

Pruébalo en línea!

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

El byte de 5 bytes +↙.=∧se sale con la omisión ℕporque no prueba salidas no positivas en absoluto, pero también falla cuando se le da un número que ya es un digito porque no prueba salidas no positivas en absoluto.

Java, 59 bytes

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

(Todavía no estoy seguro de cómo contar las entradas de Java, pero de acuerdo con el estándar establecido por la primera entrada de Java , esta entrada es de 59 bytes, ya que es 17 bytes más corta).

De todos modos, si tenemos un repdigit, devuelve 0, de lo contrario agregue 1 a la entrada, llámese a sí mismo y agregue 1 al resultado.

Sin golf y casos de prueba:

Pruébalo aquí.

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

Salida:

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

Como puede ver, la última entrada se queda sin memoria antes de que pueda terminar. Se StackOverflowErrorarroja el (muy apropiado) java.util.regex.Pattern.sequence(Pattern.java:2134), pero estoy bastante seguro de que no hay nada de malo en la expresión regular en sí, ya que es la misma que usé en mi entrada anterior .

C #, 82 bytes

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

C, 84 bytes

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

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

Prólogo, 120 bytes

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.

Pruébalo en línea!