En 4chan, un juego popular es get. Cada publicación en el sitio obtiene una identificación de publicación secuencial. Dado que no puede influir en ellos o determinarlos, las personas intentan adivinar (al menos una parte de) su propio número de publicación, generalmente los primeros dígitos. Otra versión del juego se llama dubs, y su objetivo es obtener dígitos repetidos al final del número (es decir, 1234555).

Su tarea, si desea aceptarla, es escribir un programa que tome una identificación de entrada como entrada (entero estándar, puede suponer debajo de 2 ^ 32), y devuelve cuántos dígitos repetidos hay al final.

Reglas

• Las lagunas estándar no están permitidas .
• El programa puede ser una función, un programa completo, un comando REPL, lo que funcione, realmente, siempre que no se necesiten códigos / argumentos externos sin contar para ejecutarlo.
• La entrada puede provenir de STDIN, argumentos de función, argumento de línea de comando, archivo, lo que más le convenga.

Casos de prueba

Input: 14892093
Output: 1

Input: 12344444
Output: 5

Input: 112311
Output: 2

Input: 888888
Output: 6

Input: 135866667 //Post number I got on /pol/ few days ago, rip
Output: 1

Mathematica, 29 bytes

¿Qué tal una solución aritmética?

IntegerExponent[9#+#~Mod~10]&

Estoy muy contento de ver que esto supera el enfoque directo de Mathematica.

Explicación

El código mismo calcula 9 * n + n% 10 y luego encuentra la mayor potencia de 10 que divide la entrada, o en otras palabras, cuenta los ceros finales. Necesitamos mostrar si n termina en k dígitos repetidos, que 9 * n + n% 10 tiene k ceros al final.

Los dígitos de repetición se expresan matemáticamente más fácilmente dividiendo un número como 99999 (que es 10 ⁵ -1 ) por 9 y luego multiplicándolo por el dígito repetido. Entonces podemos escribir n = m * 10 ^k + d * (10 ^k -1) / 9 , donde m ≢ d (mod 10) , para asegurarnos de que n no termine en más de k dígitos repetidos. Tenga en cuenta que d = n% 10 .

Vamos a conectar eso a nuestra fórmula 9 * n + n% 10 . Obtenemos 9 * m * 10 ^k + d * (10 ^k -1) + d . La d al final se cancela, por lo que nos queda: 9 * m * 10 ^k + d * 10 ^k = (9 * m + d) * 10 ^k . Pero 9 ≡ -1 (mod 10) , entonces 9 * m + d ≡ d - m (mod 10) . Pero hemos afirmado que m ≢ d (mod 10) y, por lo tanto, d - m ≢ 0 (mod 10) .

En otras palabras, hemos demostrado que 9 * m + d no es divisible por 10 y, por lo tanto, la mayor potencia de 10 que divide 9 * n + n% 10 = (9 * m + d) * 10 ^k es k , El número de dígitos repetidos finales.

Como ∞beneficio adicional, esta solución imprime el resultado correcto , como entrada 0.

Retina , 9 bytes

&`(.)\1*$

Pruébalo en línea!

Cuenta el número de coincidencias superpuestas, de las (.)\1*$cuales es una expresión regular que coincide con un sufijo de caracteres idénticos.

Brachylog , 4 bytes

ẹḅtl

Pruébalo en línea!

Explicación

ẹ       Elements: split to a list of digits
 ḅ      Blocks: group consecutive equal digits into lists
  t     Tail: take the last list
   l    Length: Output is the length of that last list

Si ḅfuncionó directamente en enteros (y no estoy seguro de por qué no lo implementé para que lo haga), esto solo sería de 3 bytes, ya ẹque no sería necesario.

Python 2 , 47 41 bytes

lambda s:len(`s`)-len(`s`.rstrip(`s%10`))

Pruébalo en línea!

36 bytes: para una entrada más flexible

lambda s:len(s)-len(s.rstrip(s[-1]))

Pruébalo en línea!

Javascript (ES6), 55 52 32 30 bytes

a=>a.match`(.)\\1*$`[0].length

• Guardado 19 bytes gracias a @MartinEnder mediante la sustitución de la expresión regular
• Guardado 2 bytes gracias a @ user81655 usando plantillas etiquetadas literales

Usar una expresión regular para que coincida con el último grupo del último dígito

Nota: Publicación por primera vez. No dudes en hacer comentarios.

f=a=>a.match`(.)\\1*$`[0].length


console.log(f("14892093"));//1
console.log(f("12344444"));//5
console.log(f("112311"));//2
console.log(f("888888"));//6
console.log(f("135866667 "));//1

C, 62 56 48 47 bytes

¡Ahorré un byte gracias a @Steadybox!

j,k;f(n){for(k=j=n%10;j==n%10;n/=10,k++);k-=j;}

Pruébalo en línea!

PHP, 47 45 40 bytes

while($argn[-++$i]==$argn[-1]);echo$i-1;

Corre con echo <n> | php -nR '<code>

Parece que un bucle es aún más pequeño que mi primera respuesta. simplemente cuente los caracteres que son iguales al último. Esto utiliza compensaciones de cadena negativas de PHP 7.1 .

-5 bytes por Titus. Gracias !

Vieja respuesta:

<?=strlen($a=$argv[1])-strlen(chop($a,$a[-1]));

elimina de la derecha todos los caracteres que coinciden con el carácter de la derecha y calcula la diferencia en la longitud.

05AB1E , 4 bytes

.¡¤g

Pruébalo en línea! o como un conjunto de pruebas

Explicación

.¡    # group consecutive equal elements in input
  ¤   # get the last group
   g  # push its length

CJam , 7 bytes

re`W=0=

Pruébalo en línea!

Explicación

r   e# Read input.
e`  e# Run-length encode.
W=  e# Get last run.
0=  e# Get length.

Jalea , 5 bytes

DŒgṪL

Pruébalo en línea!

Explicación

D      # convert from integer to decimal   
 Œg    # group runs of equal elements
   Ṫ   # tail
    L  # length

Perl 5 , 22 bytes

21 bytes de código + -pbandera.

/(.)\1*$/;$_=length$&

Pruébalo en línea!

/(.)\1*$/obtiene los últimos números idénticos y luego $_=length$&asigna su longitud a $_, que se imprime implícitamente gracias a la -pbandera.

C (gcc) , 32 29 bytes

f(x){x=x%100%11?1:-~f(x/10);}

Este es un puerto de mi respuesta de Python .

Esto funciona con gcc, pero la falta de una returndeclaración es un comportamiento indefinido.

Pruébalo en línea!

Python 2, 51 bytes

Toma un entero como entrada. Pruébalo en línea

lambda S:[x==`S`[-1]for x in`S`[::-1]+'~'].index(0)

48 bytes para la cadena como entrada. Pruébalo en línea

lambda S:[x==S[-1]for x in S[::-1]+'~'].index(0)

C # , 63 62 bytes

Golfed

i=>{int a=i.Length-1,b=a;while(a-->0&&i[a]==i[b]);return b-a;}

Sin golf

i => {
    int a = i.Length - 1,
        b = a;

    while( a-- > 0 && i[ a ] == i[ b ] );

    return b - a;
}

Legible sin golf

i => {
    int a = i.Length - 1, // Store the length of the input
        b = a ;           // Get the position of the last char

    // Cycle through the string from the right to the left
    //   while the current char is equal to the last char
    while( a-- > 0 && i[ a ] == i[ b ] );

    // Return the difference between the last position
    //   and the last occurrence of the same char
    return b - a;
}

Código completo

using System;

namespace Namespace {
   class Program {
      static void Main( String[] args ) {
         Func<String, Int32> f = i => {
            int a = i.Length - 1, b = a;
            while( a-- > 0 && i[ a ] == i[ b ] );
            return b - a;
         };

         List<String>
            testCases = new List<String>() {
               "14892093",
               "12344444",
               "112311",
               "888888",
               "135866667"
            };

         foreach( String testCase in testCases ) {
            Console.WriteLine( $" Input: {testCase}\nOutput: {f( testCase )}\n" );
         }

         Console.ReadLine();
      }
   }
}

Lanzamientos

• v1.1 - - 1 byte - Gracias al comentario de Kevin .
• v1.0 -  63 bytes- Solución inicial.

Notas

Nada que añadir

Python 2 , 38 32 bytes

f=lambda n:0<n%100%11or-~f(n/10)

¡Gracias a @xnor por guardar 6 bytes!

Pruébalo en línea!

MATL , 6 5 bytes

1 byte guardado gracias a @Luis

&Y'O)

Pruébalo en MATL Online

Explicación

        % Implicitly grab input as a string
&Y'     % Perform run-length encoding on the string but keep only the second output
        % Which is the number of successive times an element appeared
O)      % Grab the last element from this array
        % Implicitly display

Cubix, 24 19 bytes

)uO)ABq-!wpUp)W.@;;

Nota

• En realidad, cuenta cuántos de los mismos caracteres hay al final de la entrada, por lo que esto también funciona para enteros realmente grandes y cadenas muy largas (siempre que la cantidad de los mismos caracteres al final sea menor que la precisión máxima de JavaScript ( alrededor de 15 dígitos en base-10).
• La entrada va en el campo de entrada, la salida se imprime en el campo de salida

Pruébalo aquí

Explicación

Primero, expandamos el cubo

    ) u
    O )
A B q - ! w p U
p ) W . @ ; ; .
    . .
    . .

Los pasos en la ejecución se pueden dividir en tres fases:

1. Analizar entrada
2. Comparar personajes
3. Imprimir resultado

Fase 1: entrada

Los dos primeros caracteres que se ejecutan son Ay B. Alee todas las entradas y las envía como códigos de caracteres a la pila. Tenga en cuenta que esto se hace a la inversa, el primer personaje termina en la parte superior de la pila, el último personaje casi en la parte inferior. En el fondo-1EOF se coloca ( ), que se utilizará como un contador para la cantidad de caracteres consecutivos al final de la cadena. Como necesitamos que la parte superior de la pila contenga los dos últimos caracteres, invertimos la pila antes de ingresar al bucle. Tenga en cuenta que la parte superior de la pila ahora se ve así: ..., C[n-1], C[n], -1.

El lugar de la IP en el cubo es donde Eestá, y apunta a la derecha. Todas las instrucciones que aún no se han ejecutado, fueron reemplazadas por no-ops (paradas completas).

    . .
    . .
A B E . . . . .
. . . . . . . .
    . .
    . .

Fase 2: Comparación de personajes

La pila es ..., C[a-1], C[a], counter, donde counterestá el contador para aumentar cuando los dos caracteres para verificar ( C[a]y C[a-1]) son iguales. La IP primero ingresa a este bucle en el Spersonaje, moviéndose hacia la derecha. El Ecarácter es la posición en la que la IP terminará (apuntando a la derecha) cuando C[a]y C[a-1]no tenga el mismo valor, lo que significa que restar C[a]de C[a-1]no produce 0, en cuyo caso !se omitirá la instrucción que sigue a la (que es a w).

    . .
    . .
. S q - ! w E .
p ) W . . ; ; .
    . .
    . .

Aquí están las instrucciones que se ejecutan durante un ciclo completo:

q-!;;p) # Explanation
q       # Push counter to the bottom of the stack
        #     Stack (counter, ..., C[a-1], C[a])
 -      # Subtract C[a] from C[a-1], which is 0 if both are equal
        #     Stack (counter, ..., C[a-1], C[a], C[a-1]-C[a])
  !     # Leave the loop if C[a-1]-C[a] does not equal 0
   ;;   # Remove result of subtraction and C[a] from stack
        #     Stack (counter, ..., C[a-1])
     p  # Move the bottom of the stack to the top
        #     Stack (..., C[a-1], counter)
      ) # Increment the counter
        #     Stack (..., C[a-1], counter + 1)

Y luego da vueltas.

Fase 3: resultado de la impresión

Desde que salimos del bucle temprano, las miradas se encaja como esto: counter, ..., C[a-1]-C[a]. Es fácil imprimir el contador, pero tenemos que incrementar el contador una vez porque no lo hicimos en la última iteración del ciclo, y una vez más porque comenzamos a contar en -1lugar de 0. El camino en el cubo se ve así, comenzando en S, apuntando a la derecha. Los dos no-ops que son ejecutados por la IP son reemplazados por flechas que apuntan en la dirección de la IP.

    ) u
    O )
. B . . . S p U
. ) . . @ . . .
    > >
    . .

Las instrucciones se ejecutan en el siguiente orden. Tenga en cuenta que las B)instrucciones al final cambian la pila, pero no afectan el programa, ya que estamos a punto de terminarlo, y ya no usamos la pila.

p))OB)@ # Explanation
p       # Pull the counter to the top
        #     Stack: (..., counter)
 ))     # Add two
        #     Stack: (..., counter + 2)
   O    # Output as number
    B)  # Reverse the stack and increment the top
      @ # End the program

Alea iacta est.

Lote, 91 bytes

@set s=-%1
@set n=1
:l
@if %s:~-2,1%==%s:~-1% set s=%s:~,-1%&set/an+=1&goto l
@echo %n%

Esto -evita que la prueba se ejecute desde el inicio de la cadena.

JavaScript (ES6), 34 bytes

f=(n,p)=>n%10-p?0:1+f(n/10|0,n%10)

No más corto que la solución regex.

Función recursiva que evalúa los dígitos de derecha a izquierda, deteniéndose cuando se encuentra un dígito diferente. El resultado es el número de iteraciones. pestá undefineden la primera iteración, lo que significa n%10-pdevoluciones NaN(falsedad). Después de eso, pes igual al dígito anterior con n%10. Cuando el dígito actual ( n%10) y el anterior ( p) son diferentes, el ciclo finaliza.

Röda , 12 bytes

{count|tail}

Pruébalo en línea!

Esta es una función anónima que espera que cada carácter de la cadena de entrada se envíe a la secuencia (creo que esto es válido en espíritu de una meta pregunta reciente ).

Utiliza dos incorporados: county tail:

1. count lee valores de la secuencia y empuja el número de elementos consecutivos a la secuencia.
2. tail devuelve el último valor en la secuencia.

T-SQL, 238 214 bytes

declare @ varchar(max) = '' declare @i int=0, @e int=0, @n int=right(@,1), @m int while (@i<=len(@)) begin set @m=(substring(@,len(@)-@i,1)) if (@n=@m) set @e=@e+1 else if (@i=0) set @e=1 set @i=@i+1 end select @e

O:

declare @ varchar(max) = '12345678999999'
declare 
    @i int = 0,
    @e int = 0,
    @n int = right(@,1),
    @m int

while (@i <= len(@))
begin
    set @m = (substring(@,len(@)-@i,1))
    if (@n = @m) set @e = @e + 1
    else
    if (@i) = 0 set @e = 1
    set @i = @i + 1
end
select @e

Java 7, 78 bytes

int c(int n){return(""+n).length()-(""+n).replaceAll("(.)\\1*$","").length();}

Pruébalo aquí

Intenté algunas cosas usando recursividad o un bucle, pero ambas terminaron por encima de los 100 bytes.

Powershell, 41 bytes

for($n="$args";$n[-1]-eq$n[-++$a]){};$a-1

bucle directo hacia atrás hasta que un carácter no coincida con el último carácter de la cadena, devuelva el índice de ese carácter -1.

-3 gracias a @AdmBorkBork - usando un bucle for en lugar de un tiempo.

Mathematica, 33 30 bytes

Gracias a Greg Martin por guardar 3 bytes.

Tr[1^Last@Split@Characters@#]&

Toma la entrada como una cadena.

Obtiene los dígitos decimales (en forma de caracteres), los divide en series de elementos idénticos, obtiene la última serie y calcula la longitud con el truco estándar de tomar la suma del vector 1^list.

Bash + Unix utilidades, 34 bytes

sed s/.*[^${1: -1}].//<<<x$1|wc -c

Pruébalo en línea!

JavaScript (ES6), 39 38 37 27 bytes

f=n=>n%100%11?1:1+f(n/10|0)

Tal vez no sea más corto que la solución basada en expresiones regulares, pero no pude resistirme a escribir una solución completamente basada en aritmética. La técnica consiste en tomar n % 100 % 11y dividir repetidamente entre 10 hasta que el resultado no sea cero, luego contar las iteraciones. Esto funciona porque si los dos últimos dígitos son iguales, n % 100 % 11lo será 0.

Haskell , 33 bytes

f(h:t)=sum[1|all(==h)t]+f t
f _=0

Pruébalo en línea!

Toma entrada de cadena. Corta repetidamente el primer carácter y agrega 1 si todos los caracteres del sufijo son iguales al primero.

R, 35 bytes

rle(rev(charToRaw(scan(,''))))$l[1]

Breve explicacion

                  scan(,'')         # get input as a string
        charToRaw(         )        # convert to a vector of raws (splits the string)
    rev(                    )       # reverse the vector
rle(                         )$l[1] # the first length from run length encoding

Befunge-98 , 19 bytes

01g3j@.$~:01p-!j$1+

Pruébalo en línea!

Esto podría acortarse si solo lograra usar la pila.

Cómo funciona:

01g3j@.$~:01p-!j$1+
01g                 ; Get the stored value (default: 32)                 ;
   3j               ; Skip to the ~                                      ;
        ~           ; Get the next character of input                    ;
         :01p       ; Overwrite the stored value with the new char       ;
             -!     ; Compare the old value and the new                  ;
               j$   ; Skip the $ when equal, else pop the counter        ;
                 1+ ; Increment the counter                              ;

; When the input runs out, ~ reflects the IP and we run: ;
   @.$
     $              ; Pop the extraneous value (the stored value) ;
   @.               ; Print the number and exit                   ;

Python 3 - 50 44 bytes

Programa completo (en Python 3, input()devuelve una cadena, sin importar la entrada):

g=input();print(len(g)-len(g.rstrip(g[-1])))