Peu couru épuisé


43

É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
  • 16100004
  • 89311011111015
  • 13373711010001101000000110116
  • 111
  • 99655461001100000001111111010107


Pouvons-nous supposer n'importe quelle limite de la taille de l'entier comme 32 bits ou 64 bits?
xnor

@xnor oui, vous pouvez supposer que l'int est de 32 bits maximum
Arnaud le

Réponses:


30

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.


2
C'est vraiment malin!
CraigR8806

1
Wow, c'est intelligent. Jamais pu y avoir pensé.
HyperNeutrino

Beau tour avec les puissances de 10, mais ne deviennent-ils pas longs avec un L?
xnor

@xnor Finalement, mais ce n'est qu'une limitation du type de données. Les réponses C, JavaScript et PHP en souffrent également.
Dennis

Cela serait sérieusement impossible à maintenir si utilisé en production. En bref (ghehe) golf atteint, trou d'un coup :)
JAK

17

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.


14

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

2
HA! Finalement! Une utilisation pour , je peux arrêter de me forcer à essayer de l'utiliser.
Urne Magic Octopus

@carusocomputing: Je suis presque sûr de l'avoir utilisé dans quelques réponses.
Emigna

9

Mathematica, 38 octets

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

ou

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

9

Python, 53 octets

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

Fonction lambda anonyme.


9

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.

9

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.


2
Pas sûr des autres versions, mais dans la version 2.3.1, l’espace entre les %b.
Manatwork

Vous avez raison, les nombres binaires négatifs commencent par "..". Merci.
GB

7

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


1
Même idée, mais en utilisant davantage d'opérations sur les bits et en exploitant la conversion par défaut de undefined à 0. N'hésitez pas à emprunter: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 octets

Solution fonctionnelle.

@manatwork est fait de magie

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

Est-ce que cela recherche des chiffres identiques consécutifs ou juste des 0s consécutifs ?
ngenisis

2
Résultat incorrect pour 893.
orlp

@ orlp plus! : D
Value Ink le

1
Je combiner les 1er et 2e solutions: ->s{s.to_s(2).scan(/0+|1+/).map(&:size).max}.
Manatwork

6

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.


6

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!


Les shebang comptent pour 0 octet.
CalculatorFeline

Le consensus de @CalculatorFeline sur les méta est que #!perlcompte pour zéro, pas #!perl -p.
Primo

@CalculatorFeline: Les -pcoûts 1, dans l'hypothèse où votre ligne de commande Perl aurait de toute façon un argument (par exemple -eou -M5.010), vous pouvez donc insérer un point pjuste après l'un des tirets. Le #!perlest gratuit (bien que inutile).

Bon à savoir. .
CalculatriceFeline

5

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

5

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 .


4

Haskell, 79 caractères

maximum.map length.group.i

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


2
groupn'est pas dans Prelude par défaut, vous devez le faire import Data.Listpour l'utiliser.
xnor

1
Notez que vous pouvez utiliser les protections en place de let: i n|(q,r)<-n`quotRem`2=r:i q. Voir nos conseils de golf Haskell . quotRempeut être divMod. Je pense que vous pouvez utiliser i 0=[]comme cas de base.
xnor

1
L' utilisation divet moddirectement est encore plus court: i n=mod n 2:i(div n 2).
Laikoni

3

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]

3

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

3

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?


3
Bienvenue chez PPCG! Par défaut, seules les fonctions ou les programmes complets (pas les extraits de code) sont acceptés. Dans votre cas, cela signifie que vous devez entrer aavec a=input('');. En outre, quelques conseils de golf: ~aau lieu de a==0. Avez-vous vraiment besoin int8)?
Luis Mendo

3

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.


3

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!


1
@DigitalTrauma Merci pour les améliorations, en particulier pour inclure le pli, qui ne fait pas partie de mon arsenal habituel.
Mitchell Spector le

3

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!


Autant que je sache, grep ne fait partie ni de bash ni de coreutils, bien qu’il soit maintenu et distribué par ses propres moyens . Pas sûr de dc, mais c'était un outil autonome dans le monde GNU. Le seul faisant partie de coreutils est wc.
Moreaki

@ Moreaki, grep est POSIX, donc toute réponse basée sur un shell implique qu'elle soit déjà disponible. dc n'est pas POSIX mais constitue une partie standard de presque tous les systèmes * Nix. Par conséquent, il n'est normalement pas mentionné en tant que dépendance distincte.
Zeppelin

Je pense que nous sommes sur deux pistes de réflexion: mon point n'était pas si grep était POSIX ou non, mais le titre de votre soumission m'indiquait qu'il faudrait bash + coreutils pour que votre solution fonctionne, cela ne semble pas le cas. Lorsque je l'ai lu pour la première fois, cette information m'a confondu. Si vous essayez votre solution sur un shell bash livré avec macOS, cela ne fonctionnera pas. et peu importe si vous avez installé coreutils ou non; vous auriez besoin de GNU grep pour que cela fonctionne.
Moreaki

@ Moreaki, oui, je viens d'impliquer le système GNU, quand je dis + coreutils, bien que ce ne soit pas toujours le cas. J'ai mis à jour le titre pour être plus précis.
Zeppelin

2

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

2

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

2

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.


1
Par créditant Valeur d' encre de solution Ruby pour l'inspiration, cela peut se transformer en x=>x.toString(2).split(/(0+|1+)/g).map(y=>y.length).sort().pop(). Ou la même longueur: x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.length)).
Manatwork

3
Je pense que vous devrez peut-être ajouter un prédicat à la fonction de tri sort((a,b)=>b-a). Par défaut, la fonction de tri se situe 10entre 1et 2.
Mama Fun Roll

Ou vous pouvez utiliser Math.max, comme le suggère manatwork.
Mama Fun Roll

Wtf, mais ce sont des nombres. JS s'il vous plaît.

2

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.


Est-ce que cela convertit l'entrée en binaire?
Laikoni

oooooh j'ai raté cette partie. Solution rapide: P
Mama Fun Roll

2

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.


2

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!


2

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

2

R, 45 34 octets

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

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


Peut-être qu'il me manque quelque chose, mais l'entrée n'est-elle pas supposée être un entier, pas un nombre binaire? Et nous recherchons le nombre maximal de fois 0ou 1non, pas seulement 0, non?
rturnbull

@ Plannapus Je ne sais pas honnêtement. Doit avoir manqué la spécification complètement. Correction maintenant.
Billywob

2

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


1

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

Je ne pense pas que cela soit valide - ce n'est pas une fonction, c'est donc un extrait de code.
Conor O'Brien

@ ConorO'Brien D'accord, je le regarderai plus tard.
Gareth
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.