Bit run resumen


43

Dado un número entero n > 0, genera la longitud de la secuencia contigua más larga de 0o 1en su representación binaria.

Ejemplos

  • 6está escrito 110en binario; la secuencia más larga es 11, así que deberíamos volver2
  • 16100004
  • 89311011111015
  • 13373711010001101000000110116
  • 111
  • 99655461001100000001111111010107


¿Podemos suponer algún límite del tamaño del entero como 32 bits o 64 bits?
xnor

@xnor sí, puedes suponer que el int es de 32 bits máximo
Arnaud

Respuestas:


30

Python 2 , 46 45 bytes

f=lambda n,k=1:`k`in bin(n^n/2)and-~f(n,k*10)

Pruébalo en línea!

Cómo funciona

Al XORing n y n / 2 (dividiendo por 2 esencialmente corta el último bit), obtenemos un nuevo entero m cuyos bits sin establecer indican bits adyacentes coincidentes en n .

Por ejemplo, si n = 1337371 , tenemos lo siguiente.

n    = 1337371 = 101000110100000011011₂
n/2  =  668685 =  10100011010000001101₂
m    = 1989654 = 111100101110000010110₂

Esto reduce la tarea de encontrar la ejecución más larga de ceros. Dado que la representación binaria de un entero positivo siempre comienza con un 1 , trataremos de encontrar la cadena de dígitos 10 * más larga que aparece en la representación binaria de m . Esto se puede hacer de forma recursiva.

Inicialice k como 1 . Cada vez que se ejecuta f , primero probamos si la representación decimal de k aparece en la representación binaria de m . Si lo hace, multiplicamos k por 10 y llamamos a f nuevamente. Si no lo hace, el código a la derecha de andno se ejecuta y devolvemos False .

Para hacer esto, primero calculamos bin(k)[3:]. En nuestro ejemplo, bin(k)devuelve '0b111100101110000010110', y 0b1al principio se elimina con [3:].

Ahora, -~antes de que la llamada recursiva incremente False / 0 una vez por cada vez que f se llama recursivamente. Una vez que 10 {j} ( 1 seguido de j repeticiones de 0 ) no aparece en la representación binaria de k , la ejecución más larga de ceros en k tiene longitud j - 1 . Como j - 1 ceros consecutivos en k indican j que coinciden con los bits adyacentes en n , el resultado deseado es j , que es lo que obtenemos al incrementar Falso / 0un total de j veces.


2
¡Esto es realmente inteligente!
CraigR8806

1
Wow, eso es inteligente. Nunca podría haberlo pensado.
HyperNeutrino

Buen truco con los poderes de 10, pero ¿no se vuelven largos con una L?
xnor

@xnor Eventualmente, pero eso es solo una limitación del tipo de datos. Las respuestas C, JavaScript y PHP también sufren de esto.
Dennis

Esto sería seriamente imposible de mantener si se usa en la producción. En resumen (ghehe) golf logrado, hoyo en uno :)
JAK

17

Python 2, 46 bytes

f=lambda n,r=1:max(r,n and f(n/2,1+~-n/2%2*r))

Pruébalo en línea

Extrae dígitos binarios de forma ninversa al tomar repetidamenten/2 y n%2. Realiza un seguimiento de la longitud de la ejecución actual rde dígitos iguales restableciéndolo a 0 si los dos últimos dígitos son desiguales, y luego suma 1.

La expresión ~-n/2%2es un indicador de si los dos últimos dígitos son iguales, nes decir, es 0 o 3 módulo 4. Comprobar los dos últimos dígitos juntos resultó más corto que recordar el dígito anterior.


14

05AB1E , 6 bytes

b.¡€gM

Pruébalo en línea!

Explicación

b       # convert to binary
 .¡     # split at difference
   €g   # map length on each
     M  # take max

2
¡DECIR AH! ¡Finalmente! Un uso para , puedo dejar de obligarme a tratar de usarlo.
Magic Octopus Urn

@carusocomputing: estoy bastante seguro de que lo he usado en un par de respuestas.
Emigna

9

Mathematica, 38 bytes

Max[Length/@Split[#~IntegerDigits~2]]&

o

Max[Tr/@(1^Split[#~IntegerDigits~2])]&

9

Python, 53 bytes

import re;lambda g:max(map(len,re.findall('1+|0+',bin(g))))

Función lambda anónima.


9

Jalea , 6 bytes

BŒgL€Ṁ

Pruébalo en línea!

Cómo funciona

BŒgL€Ṁ  Main link. Argument: n

B       Binary; convert n to base 2.
 Œg     Group adjacent, identical elements.
   L€   Map length over the groups.
     Ṁ  Take the maximum.

9

Ruby, 41 40 bytes

->b{("%b%b"%[b,~b]).scan(/1+/).max.size}

Encuentre la secuencia más larga de '1' en bo su inversa.

Gracias a manatwork por guardar 1 byte.


2
No estoy seguro acerca de otras versiones, pero en 2.3.1 no hay necesidad de espacio entre las %b's.
manatwork

Tienes razón, los números binarios negativos comienzan con "..". Gracias.
GB

7

JavaScript (ES6), 54 bytes

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

Una solución recursiva con mucha manipulación de bits. nalmacena la entrada, ralmacena la duración de la ejecución actual, lalmacena la duración de la ejecución más larga y dalmacena el dígito anterior.

Fragmento de prueba

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

for(var i of [0,1,2,3,4,5,6,7,8,9,16,893,1337371]) console.log(`f(${i}): ${f(i)}`)


1
La misma idea, pero utilizando más operaciones de bits y explotando la conversión predeterminada de undefined a 0. Siéntase libre de pedir prestado:f=(x,b,n,m)=>x?f(x>>1,x&1,n=x&1^b||-~n,m>n?m:n):m
edc65

7

Ruby, 51 44 43 bytes

Solución funcional.

@manatwork está hecho de magia

->s{('%b'%s).scan(/0+|1+/).map(&:size).max}

¿Esto verifica dígitos idénticos consecutivos o solo 0s consecutivos ?
ngenisis

2
Resultado incorrecto para 893.
orlp

@orlp ya no! : D
Tinta de valor

1
Me gustaría combinar la 1ª y 2ª soluciones: ->s{s.to_s(2).scan(/0+|1+/).map(&:size).max}.
manatwork

6

Python 2, 57 bytes

a=lambda n:n and max((n&-n|~n&-~n).bit_length()-1,a(n/2))

Una solución recursiva. Puede haber una forma más corta para la magia de bits.


6

Perl, 43 bytes

#!perl -p
\@a[$a+=$_-1+($_>>=1)&1||-$a]while$_;$_=@a

Contando el shebang como uno, la entrada se toma de stdin.

Pruébalo en línea!


Los shebangs cuentan como 0 bytes.
CalculatorFeline

@CalculatorFeline consenso sobre meta es que #!perlcuenta como cero, no #!perl -p.
primo

@CalculatorFeline: el -pcosto 1, suponiendo que su línea de comando Perl tendría un argumento de todos modos (por ejemplo, -eo -M5.010), por lo que puede ingresar un ppoco después de uno de los guiones. El #!perles gratis (aunque innecesario).

Bueno saber. .
CalculatorFeline

5

Pipa , 16 bytes

Parece que debe haber una forma más corta de obtener las corridas del mismo dígito ...

MX#*(TBa`1+|0+`)

Toma entrada como argumento de línea de comando. Pruébalo en línea!

Explicación

     TBa          1st cmdline arg, To Binary
    (   `1+|0+`)  Find all matches of this regex
  #*              Map length operator to that list
MX                Get the maximum and autoprint it

5

Perl 6 , 36 bytes

{(.base(2)~~m:g/1+|0+/)».chars.max}

Explicación:

{                                 }   # a lambda
  .base(2)                            # convert the argument to base 2
          ~~m:g/     /                # regex match, with global matching turned on
                1+|0+                 # match one or more 1, or one or more 0
 (                    )».chars        # replace each match by its length
                              .max    # take the maximum number

Pruébalo en línea .


4

Haskell, 79 caracteres

maximum.map length.group.i

dónde

import Data.List
i 0=[]
i n=mod n 2:i(div n 2)

O en versión sin golf:

import Data.List
pcg :: Int -> Int
pcg = maximum . map length . group . intToBin

intToBin :: Int -> [Int]
intToBin 0 = []
intToBin n = n `mod` 2 : intToBin (n `div` 2)

Explicación:

intToBinconvierte un int en una lista de dígitos binarios (lsb primero). groupagrupa secuencias contiguas, de modo que se [1, 1, 0, 0, 0, 1]convierte en [[1, 1],[0, 0, 0],[1]].maximum . map lengthcalcula para cada lista interna su longitud y devuelve la longitud de la más larga.

Editar: Gracias a @xnor y @Laikoni por guardar bytes


2
groupno está en Prelude de forma predeterminada, debe hacer import Data.Listpara usarlo.
xnor

1
Tenga en cuenta que puede utilizar protectores en su lugar de let: i n|(q,r)<-n`quotRem`2=r:i q. Vea nuestros consejos de golf Haskell . quotRempuede ser divMod. Creo que puedes usarlo i 0=[]como el caso base.
xnor

1
El uso divy moddirecta es aún más corto: i n=mod n 2:i(div n 2).
Laikoni

3

Pyth, 7 bytes

heSr8.B

Ejecute la codificación de longitud en la cadena binaria, luego ordénela de modo que las ejecuciones más largas sean las últimas, luego tome el primer elemento (la longitud) del último elemento (la ejecución más larga) de la lista.

En pseudocódigo:

'  S     ' sorted(
'   r8   '   run_length_encode(
'     .BQ'     bin(input()) ))  \
'he      '   [-1][0]

3

J , 21 bytes

[:>./#:#;.1~1,2~:/\#:

Pruébalo en línea!

Explicación

[:>./#:#;.1~1,2~:/\#:  Input: integer n
                   #:  Binary digits of n
              2   \    For each continuous subarray of 2 digits
               ~:/       Reduce it using not-equals
            1,         Prepend a 1 to those results
     #:                Binary digits of n
        ;.1~           Cut the binary digits at each location with a 1
       #                 Get the length of each cut
[:>./                  Reduce those lengths using maximum and return

3

MATLAB 71 bytes

m=1;a=diff(int8(dec2bin(a)));while(any(a==0)),m=m+1;a=diff(a);end;m

Esto convierte la variable entera 'a' en una matriz binaria int8 y luego cuenta el número de veces que el resultado debe diferenciarse hasta que no haya cero en el resultado.

Soy nuevo aquí. ¿Este tipo de entrada y una línea están permitidas por las reglas PCG?


3
Bienvenido a PPCG! De forma predeterminada, solo se aceptan funciones o programas completos (no fragmentos de código). En el caso de que los medios que necesitan de entrada acon a=input('');. Además, algunos consejos de golf: en ~alugar de a==0. ¿Realmente necesitas int8)?
Luis Mendo

3

Octava , 31 bytes

@(n)max(runlength(+dec2bin(n)))

Pruébalo en línea!

Explicación

Esta es una traducción de mi respuesta MATL. Mi plan inicial fue un enfoque diferente, a saber @(n)max(diff(find(diff([0 +dec2bin(n) 0])))). Pero resulta que Octave tiene una runlengthfunción (que acabo de descubrir). Por defecto, solo genera el conjunto de longitudes de ejecución, por lo que el resultado deseado es el maxde ese conjunto. La salida de dec2bin, que es una matriz de caracteres (cadena) que contiene '0'y '1', debe convertirse a una matriz numérica usando +, porque runlengthespera una entrada numérica.


3

Utilidades Bash / Unix, 66 65 42 bytes

Gracias a @DigitalTrauma por mejoras significativas (¡23 bytes!).

dc<<<`dc -e2o?p|fold -1|uniq -c|sort -n`rp

Pruébalo en línea!


1
@ DigitalTrauma Gracias por las mejoras, especialmente por incluir fold, que no ha estado en mi arsenal habitual.
Mitchell Spector

3

Bash (+ coreutils, + GNU grep), 33, 32 bytes

EDICIONES:

  • Menos 1 byte (comillas eliminadas alrededor de la expresión grep )

Golfed

dc -e2o$1p|grep -Po 1+\|0+|wc -L

Explicado

 #Convert to binary
 >dc -e2o893p
 1101111101

 #Place each continuous run of 1es or 0es on its own line
 >dc -e2o893p|grep -Po '1+|0+'
 11
 0
 11111
 0
 1

 #Output the length of the longest line
 >dc -e2o893p|grep -Po '1+|0+'|wc -L
 5

¡Pruébelo en línea!


AFAIK, grep no forma parte de bash ni coreutils, aunque se mantiene y distribuye por sí mismo . No estoy seguro acerca de DC, pero solía ser una herramienta independiente en el mundo GNU. El único que forma parte de coreutils es wc.
Moreaki

@Moreaki, grep es POSIX, por lo que cualquier respuesta basada en shell implica que ya está disponible. dc no es POSIX, pero es una parte estándar de casi todos los sistemas * Nix, por lo que normalmente tampoco se menciona como una dependencia separada.
zepelín

Creo que estamos en dos líneas diferentes de pensamientos aquí: mi punto no era si grep era POSIX o no, mi punto era que el título de su presentación para mí indicaba que uno necesitaría bash + coreutils para que su solución funcione, mientras que Este no parece ser el caso. Cuando lo leí por primera vez, esta información me resultó confusa. Si prueba su solución en un shell bash enviado por macOS, no funcionará; y no importa si instaló coreutils o no; necesitarías GNU grep para que funcione.
Moreaki

@Moreaki, sí, simplemente me refiero al sistema GNU, cuando digo + coreutils, aunque no siempre es así. He actualizado el título para ser más preciso.
zepelín

2

Brachylog , 9 bytes

$b@b:lotl

Pruébalo en línea!

Explicación

$b          List of binary digits of the input
  @b        Runs of consecutive identical digits in that list
    :lo     Order those runs by length
       tl   Output is the length of the last one

2

C #, 106 bytes

n=>{int l=1,o=0,p=0;foreach(var c in System.Convert.ToString(n,2)){o=c!=p?1:o+1;l=o>l?o:l;p=c;}return l;};

Versión formateada:

System.Func<int, int> f = n =>
{
    int l = 1, o = 0, p = 0;
    foreach (var c in System.Convert.ToString(n, 2))
    {
        o = c != p ? 1 : o + 1;

        l = o > l ? o : l;

        p = c;
    }

    return l;
};

Y un enfoque alternativo para acceder a la cadena por índice a 118 bytes, con espacios en blanco eliminados:

System.Func<int, int> f2 = n =>
{
    var s = System.Convert.ToString(n, 2);

    int l = 1, c = 1, i = 0;

    for (; i < s.Length - 1; )
    {
        c = s[i] == s[++i] ? c + 1 : 1;
        l = l < c ? c : l;
    }

    return l;
};

2

Javascript, 66 bytes

x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.leng‌​th))

Gracias a manatwork por el código.

Explicación

x.toString(2)

Convertir número a cadena binaria.

split(/(0+|1+)/g)

Dividir cada carácter diferente (0 o 1) (esta expresión regular captura espacios vacíos pero pueden ignorarse)

map(y=>y.length)

Para cada elemento de la matriz, obtenga su longitud y colóquela en la matriz devuelta.

...

Convertir matriz en lista de argumentos ([1,2,3] -> 1,2,3)

Math.max()

Obtenga el mayor número de argumentos.


1
Al dar crédito a la solución Ruby de Value Ink como inspiración, esto se puede transformar en . O la misma longitud: . x=>x.toString(2).split(/(0+|1+)/g).map(y=>y.length).sort().pop()x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.length))
manatwork

3
Creo que puede que tenga que agregar un predicado a la función de clasificación sort((a,b)=>b-a). Por defecto, la función de clasificación se ubica 10entre 1y 2.
Mama Fun Roll

O puede usar Math.max, como sugiere manatwork.
Mama Fun Roll

Wtf, pero son números. JS por favor.

2

Maravilla , 27 bytes

max.map#len.mstr`0+|1+`g.bn

Uso:

(max.map#len.mstr`0+|1+`g.bn)123

Convierte a binario, coincide con cada secuencia de 0 y 1, obtiene la duración de cada coincidencia y obtiene el máximo.


¿Esto convierte la entrada a binario?
Laikoni

oooooh me perdí esa parte. Solución rápida: P
Mama Fun Roll

2

Lote, 102 bytes

@set/a"n=%1/2,d=%1%%2,r=1+(%3+0)*!(0%2^d),l=%4-(%4-r>>5)
@if not %n%==0 %0 %n% %d% %r% %l%
@echo %l%

Respuesta del puerto de @ edc65. %2.. %4estará vacío en la primera llamada, así que tengo que escribir las expresiones de tal manera que aún funcionen. El caso más general es el %3que tuve que escribir (%3+0). %2es más fácil, ya que solo puede ser 0o 1, que son iguales en octal, por lo que 0%2funciona aquí. %4resultó ser aún más fácil, ya que solo necesito restarlo. (%4-r>>5)se utiliza para comparar lcon rtan lotes de set/ano tiene un operador de comparación.


2

Dyalog APL , 22 bytes

Tren de funciones anónimo

⌈/∘(≢¨⊢⊂⍨1,2≠/⊢)2⊥⍣¯1

⌈/∘(... El máximo de los resultados del siguiente tren de funciones anónimo ...

≢¨  el recuento de cada

⊢⊂⍨ partición del argumento, donde la partición está determinada por los que están en

1, uno antepuesto a

2≠/ la desigual desigual de

 el argumento

) aplicado a

2⊥⍣¯1 from-base-2 aplicado negativo una vez (es decir, to-base-2, una vez) a

 el argumento

TryAPL en línea!


2

Japt, 15 bytes

2o!q¢ c ml n gJ

¡Pruébalo en línea! o Verificar todos los casos de prueba a la vez .

Cómo funciona

                 // Implicit: U = input integer, J = -1
2o               // Create the range [0...2), or [0,1].
  ! ¢            // Map each item Z in this range to U.s(2)
   q             //                                        .q(Z).
                 // This returns the runs of 1's and 0's in the binary
                 // representation of U, respectively.
      c          // Flatten into a single list.
        ml       // Map each item Z to Z.length.
           n gJ  // Sort the result and grab the item at index -1, or the last item.
                 // This returns the largest element in the list.
                 // Implicit: output result of last expression

2

R, 45 34 bytes

max(rle(miscFuncs::bin(scan()))$l)

Se corrigió un malentendido tonto gracias a @rturnbull y @plannapus.


Quizás me falta algo, pero ¿no se supone que la entrada es un número entero, no un número binario? Y estamos buscando la carrera máxima de 0o de 1, no solo 0, ¿verdad?
rturnbull

@plannapus No lo sé honestamente. Debe haber perdido la especificación por completo. Corregido ahora.
Billywob

2

PowerShell , 78 74 73 bytes

([regex]::Matches([convert]::ToString("$args",2),'0+|1+')|% Le*|sort)[-1]

Pruébalo en línea!

Ugh esos métodos .Net.

Esto solo usa una expresión regular para encontrar (y hacer coincidir) secuencias contiguas de unos y ceros, luego toma la Lengthpropiedad (con un nuevo patrón que encontré que usa un conjunto de parámetros poco conocido deForEach-Object , para guardar 1 byte) de los objetos de coincidencia resultantes, los ordena y genera el último (el más grande).


1

J, 27 bytes

>./>#&.>((1,2~:/\[)<;.1])#:

Un enfoque ligeramente diferente (y desafortunadamente más largo) para la respuesta de millas .

Uso:

    >./>#&.>((1,2~:/\[)<;.1])#:893
5

Explicación

>./>#&.>((1,2~:/\[)<;.1])#:
                         #: Convert to base 2
        (               )   A fork
                       ]    Previous result
         (1,2~:/\[)         Find where each new sequence begins
                   <;.1     Cut the string of integers based on where each sequence begins and box them
    #&.>                    Count under open - open each box and count the items in it
>./>                        Open all the boxes and find the maximum value

No creo que esto sea válido, no es una función y también lo es un fragmento.
Conor O'Brien

@ ConorO'Brien Bien, lo miraré de nuevo más tarde.
Gareth el
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.