Étant donné un entier n > 0, affiche la longueur de la plus longue séquence contiguë de 0ou 1dans sa représentation binaire.

Exemples

• 6est écrit 110en binaire; la plus longue séquence est 11, alors nous devrions revenir2
• 16→ 10000→4
• 893→ 1101111101→5
• 1337371→ 101000110100000011011→6
• 1→ 1→1
• 9965546→ 100110000000111111101010→7

Python 2 , 46 45 octets

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

Essayez-le en ligne!

Comment ça marche

En XORing n et n / 2 (en divisant par 2, on coupe essentiellement le dernier bit), on obtient un nouvel entier m dont les bits non définis indiquent les bits correspondants correspondants dans n .

Par exemple, si n = 1337371 , nous avons ce qui suit.

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

Cela réduit la tâche de trouver la plus longue série de zéros. Comme la représentation binaire d'un entier positif commence toujours par un 1 , nous allons essayer de trouver la chaîne de chiffres la plus longue ( 10 *) qui apparaît dans la représentation binaire de m . Cela peut être fait de manière récursive.

Initialise k comme 1 . Chaque fois que f est exécuté, nous testons d’abord si la représentation décimale de k apparaît dans la représentation binaire de m . Si c'est le cas, on multiplie k par 10 et on appelle à nouveau f . Si ce n'est pas le cas, le code à droite de andn'est pas exécuté et nous renvoyons False .

Pour ce faire, nous calculons d’abord bin(k)[3:]. Dans notre exemple, bin(k)retourne '0b111100101110000010110'et 0b1le début est supprimé avec [3:].

Maintenant, l' -~appel avant l'appel récursif incrémente Faux / 0 une fois pour chaque fois que f est appelé de manière récursive. Lorsque 10 {j} ( 1 suivi de j répétitions de 0 ) n'apparaît pas dans la représentation binaire de k , la plus longue série de zéros de k a une longueur de j - 1 . Puisque j - 1 zéros consécutifs dans k indiquent j correspondant à des bits adjacents dans n , le résultat souhaité est j , ce que nous obtenons en incrémentant Faux / 0.un total de j fois.

Python 2, 46 octets

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

Essayez-le en ligne

Extrait les chiffres binaires nen sens inverse en prenant plusieurs fois n/2et n%2. Suit la longueur de la série actuelle rde chiffres égaux en la réinitialisant à 0 si les deux derniers chiffres sont inégaux, puis en ajoutant 1.

L’expression ~-n/2%2indique si les deux derniers chiffres sont égaux, c’est-à n- dire 0 ou 3 modulo 4. Vérifier que les deux derniers chiffres ensemble ont été raccourcis au lieu de se souvenir du chiffre précédent.

05AB1E , 6 octets

b.¡€gM

Essayez-le en ligne!

Explication

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

Mathematica, 38 octets

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

ou

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

Python, 53 octets

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

Fonction lambda anonyme.

Gelée , 6 octets

BŒgL€Ṁ

Essayez-le en ligne!

Comment ça marche

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 octets

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

Trouver la plus longue séquence de '1' dans b ou son inverse.

Merci à manatwork d’avoir économisé 1 octet.

JavaScript (ES6), 54 octets

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

Une solution récursive avec beaucoup de manipulation de bits. nstocke l'entrée, rstocke la longueur de l'exécution en cours, lstocke la longueur de l'exécution la plus longue et dstocke le chiffre précédent.

Extrait de test

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 octets

Solution fonctionnelle.

@manatwork est fait de magie

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

Python 2, 57 octets

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

Une solution récursive. Il pourrait y avoir une forme plus courte pour le bit magique.

Perl, 43 octets

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

En comptant le shebang comme un, l'entrée est prise de stdin.

Essayez-le en ligne!

Pip , 16 octets

On dirait qu'il doit y avoir un moyen plus court pour obtenir les exécutions du même chiffre ...

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

Prend l'entrée comme argument de ligne de commande. Essayez-le en ligne!

Explication

     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 octets

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

Explication:

{                                 }   # 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

Essayez-le en ligne .

Haskell, 79 caractères

maximum.map length.group.i

où

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

Ou en version non-golfée:

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)

Explication:

intToBinconvertit un int en une liste de chiffres binaires (lsb en premier). groupgroupe des séquences contiguës, telles qu'elles [1, 1, 0, 0, 0, 1]deviennent [[1, 1],[0, 0, 0],[1]]. maximum . map lengthcalcule pour chaque liste interne sa longueur et renvoie la longueur de la plus longue.

Edit: Merci à @xnor et @Laikoni pour la sauvegarde d’octets

Pyth, 7 octets

heSr8.B

Effectuez la longueur de la séquence binaire sur la chaîne binaire, puis triez-la de manière à ce que les plus longues exécutions arrivent en dernier, puis prenez le premier élément (la longueur) du dernier élément (la plus longue) de la liste.

En pseudocode:

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

J , 21 octets

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

Essayez-le en ligne!

Explication

[:>./#:#;.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 octets

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

Ceci convertit la variable entière 'a' en un tableau binaire int8 puis compte le nombre de fois que le résultat doit être différencié jusqu'à ce qu'il n'y ait plus de zéro dans le résultat.

Je suis nouveau ici. Est-ce que ce type de saisie et de ligne unique est autorisé par les règles du GCPC?

Octave , 31 octets

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

Essayez-le en ligne!

Explication

Ceci est une traduction de ma réponse MATL. Mon plan initial était une approche différente, à savoir @(n)max(diff(find(diff([0 +dec2bin(n) 0])))). Mais il s'avère qu'Octave a une runlengthfonction (que je viens de découvrir). Par défaut, il ne sort que le tableau de longueurs d'exécution, le résultat souhaité est donc celui maxde ce tableau. La sortie de dec2bin, qui est un tableau de caractères (chaîne) contenant '0'et '1', doit être convertie en un tableau numérique en utilisant +, car runlengthattend une entrée numérique.

Utilitaires Bash / Unix, 66 65 42 octets

Merci à @DigitalTrauma pour des améliorations significatives (23 octets!).

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

Essayez-le en ligne!

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

EDITS:

• Moins 1 octet (guillemets supprimés autour de l' expression grep )

Golfé

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

A expliqué

 #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

Essayez-le en ligne!

Brachylog , 9 octets

$b@b:lotl

Essayez-le en ligne!

Explication

$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 octets

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

Version formatée:

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

Et une autre approche accédant à la chaîne par index à 118 octets, en supprimant les espaces:

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 octets

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

Merci à manatwork pour le code.

Explication

x.toString(2)

Convertir le nombre en chaîne binaire.

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

Diviser chaque caractère différent (0 ou 1) (cette expression rationnelle capture les espaces vides mais ils peuvent être ignorés)

map(y=>y.length)

Pour chaque élément du tableau, obtenez sa longueur et mettez-le dans le tableau retourné.

...

Convertir un tableau en liste d'arguments ([1,2,3] -> 1,2,3)

Math.max()

Obtenez le plus grand nombre des arguments.

Merveille , 27 octets

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

Usage:

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

Convertit en binaire, correspond à chaque séquence de 0 et de 1, obtient la longueur de chaque correspondance et obtient le maximum.

Lot, 102 octets

@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%

Port de la réponse de @ edc65. %2.. %4sera vide lors du premier appel, je dois donc écrire les expressions de manière à ce qu'elles fonctionnent encore. Le cas le plus général est celui pour %3lequel je devais écrire (%3+0). %2est plus facile, car il ne peut être que 0ou 1, qui sont les mêmes en octal, 0%2fonctionne donc ici. %4s’est avéré être encore plus facile, car je n’ai besoin que de le soustraire. (%4-r>>5)est utilisé pour comparer lavec rcomme lot de set/ane dispose pas d' un opérateur de comparaison.

Dyalog APL , 22 octets

Train de fonctions anonyme

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

⌈/∘(... Le maximum des résultats du train de fonctions anonyme suivant ...

 ≢¨  le décompte de chaque

 ⊢⊂⍨ partition de l'argument, où le partitionnement est déterminé par ceux de

 1, on a préposé à

 2≠/ l'inégale paire de

 ⊢ l'argument

) appliqué à

2⊥⍣¯1 à partir de la base 2 appliquée une fois (c’est-à-dire à la base 2, une fois) à

⊢ l'argument

TryAPL en ligne!

Japt, 15 octets

2o!q¢ c ml n gJ

Testez-le en ligne! ou Vérifiez tous les cas de test à la fois .

Comment ça marche

                 // 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 octets

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

Correction d'un malentendu idiot grâce à @rturnbull et @plannapus.

PowerShell , 78 74 73 octets

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

Essayez-le en ligne!

Ugh ces méthodes .Net.

Cela utilise juste une expression rationnelle pour trouver (et faire correspondre) des séquences contiguës de uns et de zéros, puis prend la Lengthpropriété (avec un nouveau motif que j'ai trouvé qui utilise un jeu de paramètres peu connu ForEach-Object, pour enregistrer 1 octet) des objets correspondants obtenus, les trie et sort le dernier (le plus grand).

J, 27 octets

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

Une approche légèrement différente (et malheureusement plus longue) de la réponse de miles .

Usage:

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

Explication

>./>#&.>((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