Consigue tus doblajes juntos

24

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
sagiksp
fuente
1
¿Se nos permite tomar la entrada como cadena?
Dead Possum
66
@DeadPossum Supongo que está permitido, ya que obtienes una cadena de todos modos si lees la entrada de STDIN, el argumento de la línea de comandos o el archivo (que son todos los métodos de entrada admisibles).
Martin Ender
1
¿Podemos suponer que la entrada será mayor que 0?
Martin Ender
1
@MartinEnder Sí
sagiksp
2
¡Vota por el juego de doblaje! ¡Compruébalo!
ZombieChowder

Respuestas:

19

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

Martin Ender
fuente
1
Es en momentos como este que deseo que este sitio sea compatible con MathJax; las fórmulas en negrita no son tan buenas como las compuestas tipográficas. Sin embargo, es bueno que te hayas tomado el tiempo de escribir el superíndice de exponentes.
wizzwizz4
1
@ wizzwizz4 Solía ​​usar el formato de código, pero descubrí que negrita (que usualmente usa Dennis) es un poco más legible que eso. Pero de acuerdo, no es tan bueno como MathJax.
Martin Ender
13

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.

Martin Ender
fuente
2
Esto debe ser un meme: tú y tu expresión regular
Christopher
Necesito aprender todos estos modificadores, simplemente lo hubiera elegido (.)(?=\1*$).
Neil
1
@DownChristopher literalmente hizo un lenguaje basado en expresiones regulares, esto va más allá del material meme c:
Rod
1
@Neil Si te sirve de consuelo, mi primer intento fue (?=(.)\1*$)(básicamente el mismo que el tuyo).
Martin Ender
1
¡Si eso es gracias!
Neil
9

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.

Fatalizar
fuente
9

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!

Barra
fuente
Guau. Tengo que aprender los builtins con más atención. +1
Dead Possum
2
@DeadPossum dir(object)es nuestro amigo c:
Rod
Por cierto, no se nos permite tomar cadenas como entrada. "Si su método de entrada devuelve cadenas automáticamente, entonces seguro, pero no puede suponer que la entrada se proporcionará como cadenas". : C
Dead Possum
1
@DeadPossum Creo que el autor cambió de opinión al respecto. El comentario parece haber sido eliminado.
Brian McCutchon
8

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
Weedoze
fuente
Bienvenido a PPCG! Puede guardar muchos bytes utilizando una referencia inversa en lugar de completar el carácter repetido manualmente:/(.)\1*$/
Martin Ender
Además, las funciones sin nombre están completamente bien (a menos que necesite el nombre para llamadas recursivas, por ejemplo), por lo que puede guardar dos bytes en el f=.
Martin Ender
¡Buen trabajo! Esto seguramente pasa revisión, pero esto podría ser golfista
Christopher
@MartinEnder Gracias! Todavía tengo que aprender a jugar golf
Weedoze
@DownChristopher Gracias! Intentaré hacerlo mejor la próxima vez
Weedoze
7

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!

Betseg
fuente
7

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.

Christoph
fuente
-Ry $argnpodría ahorrar 5 bytes.
Titus
6

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.
Martin Ender
fuente
6

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
Emigna
fuente
6

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.

Dada
fuente
6

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!

Dennis
fuente
Estoy confundido, ¿cómo es que no pasa un puntero y cambia el valor en la ubicación, o simplemente devuelve el valor? Parece que solo cambia la copia local, lo que haría que la función no se pueda usar, pero esto funciona en TIO. También agrega 1 a n en el pie de página, en lugar de sizeof (int), ¿eso no lo movería 1 byte hacia adelante, en lugar del ancho completo de un int? Claramente, hay algunos trucos que podría aprender aquí, y probablemente podría usar el primero en mi propia respuesta.
Bijan
2
Todo lo returnque hace la declaración es almacenar el valor de retorno en EAX. Con gcc, asignarlo a una variable pasa a hacer lo mismo. En cuanto a la aritmética del puntero, cuando agrega 1 a un puntero int, se mueve al siguiente int, no al siguiente byte.
Dennis
¿Hay casos (cuando se usan ints) en los que sería mejor regresar, parece que en el peor de los casos haría un nuevo int y lo asignaría?
Bijan
Compiladores de C @Bijan siempre adecuan acceso de memoria directa con el tamaño de un átomo de lo primitivo en cuestión - No recuerdo si es en el estándar, aunque
gato
5

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)
Zarigüeya muerta
fuente
5

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

auhmaan
fuente
+1 Sin embargo, puedes jugar golf por 1 byte. Así:i=>{int a=i.Length-1,b=a;while(a-->0&&i[a]==i[b]);return b-a;}
Kevin Cruijssen
4

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
Suever
fuente
Había olvidado que eso &hacía eso Y':-D ¿Por qué no tomar la entrada como una cadena entre comillas y deshacerse de ella j?
Luis Mendo
@LuisMendo No estaba seguro de poder hacerlo, ya que el desafío decía explícitamente que la entrada era un "entero"
Suever
Lo supuse por el comentario de Martin y por las reglas predeterminadas, que lo permiten. Pero no estoy realmente seguro
Luis Mendo
@LuisMendo Ah, ok, no vi su comentario. ¡Actualizará!
Suever
4

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.

Luke
fuente
3

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.

Neil
fuente
3

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.

usuario81655
fuente
3

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.
fergusq
fuente
3

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
Nelz
fuente
2

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.

Kevin Cruijssen
fuente
2

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.

colsw
fuente
2

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.

Martin Ender
fuente
Charactersen lugar de IntegerDigits?
Greg Martin
@ GregMartin Ah sí, supongo. Gracias.
Martin Ender
Todavía no superas a ese otro astuto golfista de Mathematica por esta pregunta;)
Greg Martin
@ GregMartin Qué pena. :)
Martin Ender
2

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.

ETHproducciones
fuente
Ah, terminaste justo antes que yo jaja! No estoy seguro de publicar otra respuesta, ya que probablemente convergerán después del golf, pero esta es mi solución con 34 bytes:f=(n,p)=>n%10-p?0:1+f(n/10|0,n%10)
user81655
@ user81655 Eso es genial, no dudes en publicarlo. No creo que el mío converja a eso sin un cambio de imagen completo, y por supuesto, ahora que he visto el tuyo, eso no sucederá ;-)
ETHproductions
2

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.

xnor
fuente
2

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
MickyT
fuente
2

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                   ;
Justin
fuente
2

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]))) 
Sr. Xcoder
fuente