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
• 16→ 10000→4
• 893→ 1101111101→5
• 1337371→ 101000110100000011011→6
• 1→ 1→1
• 9965546→ 100110000000111111101010→7

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.

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.

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

Mathematica, 38 bytes

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

o

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

Python, 53 bytes

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

Función lambda anónima.

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.

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.

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

Ruby, 51 44 43 bytes

Solución funcional.

@manatwork está hecho de magia

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

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.

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!

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

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 .

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

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]

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

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?

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.

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!

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!

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

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

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.

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.

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.

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!

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

R, 45 34 bytes

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

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

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

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