Obbiettivo

Dato un numero intero non negativo, creare una funzione che restituisca la posizione iniziale del numero di 1 consecutivi più grandi nel valore binario di quel numero intero.

Quando viene fornito un input 0, restituire 0.

Se il numero ha più strisce di uguale lunghezza, è necessario restituire la posizione dell'ultima striscia.

Ingresso

Un numero intero maggiore o uguale a 0.

Produzione

Un numero intero calcolato come spiegato di seguito.

Regole

• Questo è code-golf, quindi vince il codice più breve in byte in ogni lingua.
• Sono vietate le scappatoie standard.

Esempi e casi di test

Esempio 1

• Alla tua funzione viene passato l'intero 142
• 142 è uguale a 10001110 in binario
• La sequenza più lunga è "111" (una sequenza di tre)
• La sequenza inizia nella posizione 2 ^ 1
• La tua funzione restituisce 1 come risultato

Esempio 2

• Alla tua funzione viene passato l'intero 48
• 48 è uguale a 110000 in binario
• La striscia più lunga è "11" (una striscia di due)
• La sequenza inizia nella posizione 2 ^ 4
• La tua funzione restituisce 4 come risultato

Esempio 3

• La tua funzione è passata all'intero 750
• 750 è uguale a 1011101110 in binario
• La sequenza più lunga è "111" (una sequenza di tre)
• Poiché ci sono due strisce di uguale lunghezza, restituiamo la striscia successiva.
• La sequenza successiva inizia nella posizione 2 ^ 5
• La tua funzione restituisce 5 come risultato

Gelatina , 10 8 byte

Ba\ÐƤṀċ¬

Provalo online!

Come funziona

Ba\ÐƤṀċ¬  Main link. Argument: n


B         Binary; convert n to base 2.

   ÐƤ     Apply the link to the left to all postfixes of the binary array.
 a\         Cumulatively reduce by logical AND.

          For example, the array

          [1, 0, 1, 1, 1, 0, 1, 1, 1, 0]

          becomes the following array of arrays.

          [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0, 0, 0, 0]
                [1, 1, 1, 0, 0, 0, 0, 0]
                   [1, 1, 0, 0, 0, 0, 0]
                      [1, 0, 0, 0, 0, 0]
                         [0, 0, 0, 0, 0]
                            [1, 1, 1, 0]
                               [1, 1, 0]
                                  [1, 0]
                                     [0]

     Ṁ    Take the lexicographical maximum, i.e., the array with the most 1's at
          the beginning, breaking ties by length.

       ¬  Yield the logical NOT of n, i.e., 0 if n > 0 and 1 if n = 0.

      ċ   Count the occurrences of the result to the right in the one to the left.

JavaScript (ES6), 41 40 36 34 byte

Salvato 4 byte grazie a @ThePirateBay

f=x=>(k=x&x/2)?f(k):Math.log2(x)|0

Casi test

f=x=>(k=x&x/2)?f(k):Math.log2(x)|0

console.log(f(0))
console.log(f(142))
console.log(f(48))
console.log(f(750))

Come?

Caso generale x> 0

Abbiamo ricorsivamente E l'ingresso x con x / 2 che riduce progressivamente i modelli di bit impostati consecutivi fino a quando rimane solo il bit più a destra della sequenza. Conserviamo una copia dell'ultimo valore diverso da zero e determiniamo la posizione del suo bit più significativo arrotondando il logaritmo di base 2.

Di seguito sono riportati i passaggi che eseguiamo per x = 750 ( 1011101110 in binario).

    1011101110 --.
,----------------'
'-> 1011101110
AND 0101110111
    ----------
=   0001100110 --.
,----------------'
'-> 0001100110
AND 0000110011
    ----------
=   0000100010 --.  --> output = position of MSB = 5  (0000100010)
,----------------'                                         ^
'-> 0000100010
AND 0000010001
    ----------
=   0000000000

Custodia perimetrale x = 0

Il caso speciale x = 0porta immediatamente a Math.log2(0) | 0. Il logaritmo di 0valuta -Infinitye OR binario bit a bit forza una coercizione a un numero intero a 32 bit. In conformità con le specifiche dell'operazione astratta ToInt32 , ciò fornisce l'atteso 0:

Se il numero è NaN , +0 , −0 , + ∞ o −∞ , restituisce +0

codice macchina x86, 14 byte

L'utilizzo dell'algoritmo di @ Arnauldx &= x>>1 e l'assunzione della posizione di bit impostata più alta nella fase precedente xdiventa 0.

Callable da C / C ++ con firma unsigned longest_set(unsigned edi);nell'ABI System V x86-64. Gli stessi byte di codice macchina decodificheranno allo stesso modo in modalità 32 bit, ma le convenzioni di chiamata standard a 32 bit non inseriscono il primo argomento edi. (La modifica del registro di input in ecxo edxper Windows _fastcall/ _vectorcallo gcc -mregparmpotrebbe essere eseguita senza interrompere nulla.)

   address   machine-code
             bytes
                         global longest_set
 1                       longest_set:
 2 00000000 31C0             xor  eax, eax    ; 0 for input = 0
 3                       
 4                       .loop:               ; do{
 5 00000002 0FBDC7           bsr  eax, edi    ;  eax = position of highest set bit
 6                           ;; bsr leaves output unmodified when input = 0 (and sets ZF)
 7                           ;; AMD documents this; Intel manuals say unspecified but Intel CPUs implement it
 8 00000005 89F9             mov  ecx, edi
 9 00000007 D1E9             shr  ecx, 1
10 00000009 21CF             and  edi, ecx
11 0000000B 75F5             jnz .loop        ; } while (x &= x>>1);
12                       
13 0000000D C3               ret

L' BSRistruzione di x86 (Bit Scan Reverse) è perfetta per questo, dandoci direttamente l'indice di bit, piuttosto che contare gli zeri iniziali. ( bsrnon produce direttamente 0 per input = 0 come 32-lzcnt(x)farebbe, ma abbiamo bisogno di bsr = 31-lzcnt per input diversi da zero, quindi lzcntnon salveremo nemmeno le istruzioni, per non parlare del conteggio dei byte. Azzerando eax prima che il ciclo funzioni a causa di bsr' s comportamento semi-ufficiale di lasciare la destinazione non modificata quando l'ingresso è zero.)

Ciò sarebbe ancora più breve se potessimo restituire la posizione MSB nel lungo periodo. In tal caso, lea ecx, [rdi+rdi](3 byte) copierebbe + left -shift invece di mov+ shr(4 byte).

Vedere questo collegamento TIO per un chiamante asm che lo faexit(longest_set(argc-1));

Test con un loop shell:

l=(); for ((i=0;i<1025;i++));do 
    ./longest-set-bitrun "${l[@]}";   # number of args = $i
    printf "$i %#x: $?\n" $i; 
    l+=($i); 
done | m

0 0: 0
1 0x1: 0
2 0x2: 1
3 0x3: 0
4 0x4: 2
5 0x5: 2
6 0x6: 1
7 0x7: 0
8 0x8: 3
9 0x9: 3
10 0xa: 3
11 0xb: 0
12 0xc: 2
13 0xd: 2
14 0xe: 1
15 0xf: 0
16 0x10: 4
17 0x11: 4
18 0x12: 4
19 0x13: 0
20 0x14: 4
21 0x15: 4

...

747 0x2eb: 5
748 0x2ec: 5
749 0x2ed: 5
750 0x2ee: 5
751 0x2ef: 0
752 0x2f0: 4
753 0x2f1: 4
754 0x2f2: 4

Gelatina , 19 17 11 byte

HÐĿ&\ḟ0ṪBL’

Provalo online!

-6 (!) Byte grazie alle acute osservazioni di @Dennis

Come funziona

HÐĿ&\ḟ0ṪBL’
HÐĿ         - halve repeatedly until reaching 0 due to rounding
   &\       - cumulative AND
     ḟ0Ṫ    - final non-zero, or 0 if all elements are 0
        BL  - length of binary representation (log base 2). 0->[0]->1
          ’ - decrement

Python 2 , 45 byte

f=lambda x:f(x&x/2)if x&x/2else len(bin(x))-3

Provalo online!

Risparmio di byte grazie a Dennis! (Il testa a testa len(bin(...))-3invece di math.frexp)

Grazie a @xnor per aver trovato un bug, che fortunatamente era facilmente risolvibile!

Perl 6 ,45 35 byte

Questa versione altamente migliorata è per gentile concessione di @nwellnhof.

{.msb+1-(.base(2)~~m:g/1+/).max.to}

Provalo online!

Python 2 , 89 78 byte

m=t=i=j=0
for c in bin(input()):
 t=-~t*(c>'0');i+=1
 if t>m:j=i;m=t
print i-j

Provalo online!

EDIT: salvato 11 byte grazie a Mr. Xcoder.

05AB1E , 14 12 11 byte

bDγàŠrkrJgα

Provalo online!o eseguire casi di test .

Spiegazione

bDγàŠrkrJgα  Implicit input (ex: 750)
bD           Convert input to binary string and duplicate
                 '1011101110', '1011101110'
  γ          Split into groups of 1s or 0s
                 '1011101110', ['1', '0', '111', '0', '111', '0']
   à         Pull out max, parsing each as an integer
                 '1011101110', ['1', '0', '0', '111', '0'], '111'
    Šrk      Rearrange stack and get first index of max run of ones
                 ['1', '0', '0', '111', '0'], 2
       rJg   Reverse stack, join the array to a string, and get its length
                 2, 7
          α  Get absolute difference
                 5

J , 18 17 byte

(#-0{#\\:#.~\)@#:

Provalo online!

Spiegazione

(#-0{#\\:#.~\)@#:  Input: integer n
               #:  Binary
     #\            Length of each prefix
       \:          Sorted down using
         #.~\      Mixed base conversion on each prefix
   0{              Get the value at index 0
  -                Subtract from
 #                 Length

C # (.NET Core) , 64 60 byte

T=a=>(a&a/2)>0?T(a&a/2):Math.Log(a,2)<0?0:(int)Math.Log(a,2)

Provalo online!

Versione AC # della risposta di @ Arnauld

Ringraziamenti

4 byte salvati grazie a Kevin Cruijssen.

C # (.NET Core) , 131 123 + 18 = 141 byte

a=>{string s=Convert.ToString(a,2),t=s.Split('0').OrderBy(x=>x.Length).Last();return a<1?0:s.Length-s.IndexOf(t)-t.Length;}

Provalo online!

+18 byte per using System.Linq;

Ringraziamenti

8 byte salvati grazie a Grzegorz Puławski.

Degolfed

a=>{
    string s=Convert.ToString(a,2),      // Convert to binary
    t=s.Split('0')                       // get largest group of 1's
       .OrderBy(x=>x.Length)
       .Last();
    return 
        a<1?0:                          // handle 0 case
        s.Length-s.IndexOf(t)-t.Length; // get position in reversed string
}

C # (.NET Core) , 164 161 byte

a=>{var s=Convert.ToString(a,2);int c=0,l=0,p=0,k=0,j=s.Length-1,i=j;for(;i>=0;i--){if(s[i]>'0'){if(i==j||s[i+1]<'1'){p=i;c=0;}if(++c>=l){l=c;k=p;}}}return j-k;}

Provalo online!

Una non Linqsoluzione, che sono sicuro potrebbe essere migliorata, anche se nulla è immediatamente evidente.

Degolfed

a=>{
    var s=Convert.ToString(a,2); // Convert to binary
    int c=0,l=0,p=0,k=0,j=s.Length-1,i=j;
    for(;i>=0;i--)               // Loop from end of string
    {
        if(s[i]>'0')             // if '1'
        {
            if(i==j||s[i+1]<'1') // if first digit or previous digit was '0'
            {
                p=i;             // set the position of the current group
                c=0;             // reset the count
            }
            if(++c>=l)           // if count is equal or greater than current largest count
            {
                l=c;             // update largest count
                k=p;             // store position for this group
            }
        }
    }
    return j-k;                  // as the string is reversed, return string length minus position of largest group
}

Buccia , 12 byte

→S§-€¤≠Lo▲gḋ

Provalo online!

Spiegazione

                 Implicit input, e.g                           750
           ḋ     Convert to binary                             [1,0,1,1,1,0,1,1,1,0]
          g      Group equal elements                          [[1],[0],[1,1,1],[0],[1,1,1],[0]]
        o▲       Maximum                                       [1,1,1]
    €            Index of that substring in the binary number  3
     ¤≠L         Absolute difference of lengths                abs (3 - 10) = 7
 S§-             Subtract the two                              7 - 3 = 4
→                Increment                                     5

Gelatina ,  14 13 12  11 byte

Bµṣ0Ṫ$ƤMḢạL

Un collegamento monadico che prende e restituisce numeri interi non negativi.

Provalo online! o vedi la suite di test .

Come?

Bµṣ0Ṫ$ƤMḢạL - Main link: number, n                   e.g. 750
B           - convert to a binary list                    [1,0,1,1,1,0,1,1,1,0]
 µ          - monadic chain separation, call that b
      Ƥ     - map over prefixes:  (i.e. for [1], [1,0], [1,0,1], [1,0,1,1],...)
     $      -   last two links as a monad:                e.g.: [1,0,1,1,1,0,1,1]
   0        -     literal zero                                   0
  ṣ         -     split (prefix) at occurrences of (0)           [[1],[1,1,1],[1,1]]
    Ṫ       -     tail                                                        [1,1]
       M    - maximal indices                             [5,9]
        Ḣ   - head                                        5
          L - length (of b)                               10
         ạ  - absolute difference                         5

Gelatina , 19 byte

BŒgḄṀB
BwÇɓÇL+ɓBL_‘

Provalo online!

Grazie a Jonathan Allan per aver salvato  4  6 byte!

Ho lavorato troppo per abbandonarlo, anche se è un po 'lungo. Volevo davvero aggiungere una soluzione che cercasse letteralmente la sottostringa più lunga di 1s nella rappresentazione binaria ...

Spiegazione

BŒgḄṀB - Collegamento di supporto monadico. Verrà utilizzato con Ç nel collegamento successivo.

B - Rappresentazione binaria.
 --G - Esecuzioni di gruppo di elementi uguali consecutivi.
   Ḅ - Converti da binario a intero.
    Ṁ - Valore massimo.
     B - Converti da intero a binario.


BwÇɓÇL + ɓBL_ '- Collegamento principale.

B - Rappresentazione binaria (dell'ingresso).
  Ç - Ultimo collegamento come monade. Accetta il numero intero di input.
 w - Primo indice della lista secondaria.
   ɓ - Avvia una catena diadica separata. Annulla gli argomenti.
    Ç - Ultimo collegamento come monade.
     L - Lunghezza.
      + - Aggiunta
       ɓ - Avvia una catena diadica separata. Annulla gli argomenti.
        B - Binario.
         L - Lunghezza.
          _ '- Sottrai e incrementa il risultato (perché Jelly usa 1-indicizzazione).
              - Uscita implicita.

Kotlin , 77 byte

{val b=it.toString(2)
b.reversed().lastIndexOf(b.split(Regex("0+")).max()!!)}

Abbellire

{
    val b = it.toString(2)
    // Find the left position of the first instance of
    b.reversed().lastIndexOf(
            // The largest group of 1s
            b.split(Regex("0+")).max()!!)
}

Test

var s:(Int)->Int =
{val b=it.toString(2)
b.reversed().lastIndexOf(b.split(Regex("0+")).max()!!)}
fun main(args: Array<String>) {
    r(0, 0)
    r(142, 1)
    r(48, 4)
    r(750, 5)
}

fun r(i: Int, i1: Int) {
    var v = s(i)
    println("$i -> $v [$i1] ${i1 == v}")
}

Haskell , 101 98 96 75 byte

snd.maximum.(`zip`[0..]).c
c 0=[0]
c n|r<-c$div n 2=sum[r!!0+1|mod n 2>0]:r

Provalo online! Utilizzo: snd.maximum.(`zip`[0..]).c $ 142rese 1.

Spiegazione:

• cconverte l'input in binario contando allo stesso tempo la lunghezza delle strisce di uno, raccogliendo i risultati in un elenco. r<-c$div n 2calcola ricorsivamente il resto rdi questo elenco, mentre sum[r!!0+1|mod n 2>0]:raggiunge la lunghezza corrente della sequenza a r. La comprensione dell'elenco controlla se mod n 2>0, ovvero se la cifra binaria corrente è una, e in tal caso, prende la lunghezza della sequenza precedente (il primo elemento di r) e ne aggiunge una. Altrimenti la comprensione dell'elenco è vuota esum[] produce 0. Per l'input di esempio, c 142restituisce l'elenco[0,3,2,1,0,0,0,1,0] .

• (`zip`[0..])aggiunge la posizione a ciascun elemento dell'elenco precedente come secondo componente di una tupla. Per l'esempio questo dà [(0,0),(3,1),(2,2),(1,3),(0,4),(0,5),(0,6),(1,7),(0,8)].

• maximumtrova la tupla lessicograficamente massima in questo elenco, ovvero le lunghezze delle strisce vengono considerate per prime in quanto sono il primo componente, e in caso di legame il secondo componente, ovvero l'indice più grande, decide. Questo produce (3,1)nell'esempio e sndrestituisce il secondo componente della tupla.

Python 2 o 3 , 58 byte

import math
f=lambda x:x&x>>1and f(x&x>>1)or len(bin(x))-3

Provalo online!

C (gcc) , 81 80 byte

i,l,c,r;f(n){for(i=l=c=r=0;n;n/=2,i++)c=n&1?c+1:c>=l?r=i-(l=c),0:0;n=c<l?r:i-c;}

Provalo online!

C (gcc) , 43 byte

Versione AC della risposta di @ Arnauld

k;f(n){n=(k=n&n/2)?f(k):(k=log2(n))<0?0:k;}

Provalo online!

MS SQL Server, 437 426 407 398 byte

SQL Fiddle

Sono sicuro di poter rimuovere le interruzioni di riga, ecc., Ma è compatto come ero disposto a farlo:

create function j(@ int)
returns int
as BEGIN
declare @a varchar(max)='',@b int,@c int=0,@d int=0,@e int=0,@f int=0,@g int=0,@h int=0
while @>0 BEGIN SELECT @a=cast(@%2 as char(1))+@a,@=@/2
END
SET @b=len(@a)
while @<@b
BEGIN
select @c=@d,@d=cast(substring(@a,@b-@,1)as int)
IF @d=1
BEGIN IF @c=0
SELECT @e=@,@g=1
else SET @g+=1 END
IF @g>=@h BEGIN select @h=@g,@f=@e END
SET @+=1
END
return @f
END

Ecco una versione più leggibile:

create function BinaryString(@id int)
returns int
as BEGIN
  declare @bin varchar(max)
  declare @binLen int
  declare @pVal int = 0
  declare @Val int = 0
  declare @stC int = 0 --start of current string of 1s
  declare @stB int = 0 --start of biggest string of 1s
  declare @lenC int = 0 --length of current string of 1s
  declare @lenB int = 0 --length of biggest string of 1s

  set @bin = ''

    while @id>0
      BEGIN
        SET @bin = cast(@id%2 as varchar(1)) + @bin
        SET @id = @id/2
      END

    SET @binLen = len(@bin)

    while @id<@binLen
      BEGIN
        set @pVal = @Val
        set @Val = cast(substring(@bin,@binLen-@id,1) as int)
        IF @Val = 1 and @pVal = 0
          BEGIN 
            SET @stC = @id
            SET @lenC = 1
          END
        IF @Val = 1 and @pVal = 1
          BEGIN 
            SET @lenC = @lenC + 1
          END
        IF @lenC >= @lenB
          BEGIN
            set @lenB = @lenC
            set @StB = @StC
          END

        SET @id = @id + 1 
      END

  return @StB
END

Il vero trucco è che, per quanto ho potuto trovare, non esiste alcuna funzionalità SQL nativa per convertire un numero da decimale a binario. Di conseguenza, ho dovuto codificare manualmente la conversione in binario, quindi ho potuto confrontarlo come una stringa, un carattere alla volta fino a quando non ho trovato il numero giusto.

Sono sicuro che c'è un modo migliore per farlo, ma non ho visto una (n) risposta SQL, quindi ho pensato di buttarla lì.

APL (Dyalog Unicode) , 22 caratteri = 53 byte

Richiede il ⎕IO←0valore predefinito su molti sistemi.

⊃⌽⍸(∨⌿↑⊆⍨b)⍷⌽b←2⊥⍣¯1⊢⎕

Provalo online!

⎕ richiesta di input

⊢ cedere che (separa ¯1da ⎕)

2⊥⍣¯1 converti in base-2, usando tutte le posizioni necessarie

b← memorizza come b(per b inary)

⌽ inverso

(... ) contrassegnare le posizioni iniziali di quanto segue in quanto:

 ⊆⍨b auto-partizione b(cioè le 1 strisce di b)

 ↑ mix (crea una lista di liste in matrice, imbottitura con zeri)

 ∨⌿ riduzione OR verticale (produce una striscia più lunga)

⍸ ɩ ndices delle posizioni di partenza

⌽ inverso

⊃ scegli il primo (restituisce zero se non disponibile)

MATL , 15 byte

`tt2/kZ&t]xBnq&

Provalo online!

Usa la metà e l'idea AND. Ilk è necessaria solo per rendere terminare per1 - per qualche motivo, 1 e 0,5 restituisce 1, causando un ciclo infinito.

(soluzione alternativa: BtnwY'tYswb*&X>)-convertendo in codifica binaria e run-length)

Fogli Google, 94 byte

=Len(Dec2Bin(A1))-Find(MAX(Split(Dec2Bin(A1),0)),Dec2Bin(A1))-Len(MAX(Split(Dec2Bin(A1),0)))+1

No, non è molto carino. Sarebbe davvero bello poter memorizzare Dec2Bin(A1)come variabile come riferimento.

Punto chiave: come Excel, la Dec2Binfunzione ha un valore di input massimo di 511. Qualsiasi cosa di dimensioni maggiori restituisce un errore, come mostrato di seguito.

R, 117 byte

z=rev(Reduce(function(x,y)ifelse(y==1,x+y,y),strtoi(intToBits(scan())),,,T));ifelse(!sum(z),0,33-which.max(z)-max(z))

Excel VBA, ₅₄ 44 byte

-10 byte grazie a @EngineerToast

Funzione di finestra immediata VBE anonima che accetta input dalla gamma [A1]e output alla finestra immediata VBE

?Instr(1,StrReverse([Dec2Bin(A1)]),1)+[A1>0]

APL (Dyalog Classic) , 24 21 byte

63|-⊃⍒+/×\↑,⍨\⎕⊤⍨64⍴2

Provalo online!

Pyth , 17 byte

Questa è una funzione ricorsiva. Il collegamento include yper chiamare la funzione sull'input dato.

L|&K.&b/b2yKsl|b1

Verifica tutti i casi di test.

Pyth , 20 byte

-lK.B|Q1+xKJeScK\0lJ

Verifica tutti i casi di test.

R, 66 byte

function(i){a=rle(intToBits(i));max(0,a[[1]][which(a[[2]]==1)])}

Spiegazione:

function(i){
  a = rle(                  # Run-length encode
    intToBits(i)            # The bits in i
  );                        # And assign it to a.
  max(0,                    # Return the maximum of zero and
      a[[1]][               # The lengths of a,
        which(a[[2]]==1)    # But only those where the repeated bit is 1
        ])
}

Python 2, 41 bytes

f=lambda n:n/2and(n&n/2<1)+f(n&n/2or n/2)

Try it online!

Based on this solution by Mr. Xcoder.

Javascript, 54 chars

f=i=>i.toString(2).split(0).sort().reverse()[0].length

• i.toString(2) gets the binary string for the integer.
• The .split(0) gets each sequential ones part in an array element.
• .sort().reverse() gets us the highest value as first.
• The [0].length gives us the length of that first value.

Perl 5, 45 + 1 (-p)

(sprintf"%b",$_)=~/(1+)(?!.*1\1)/;$_=length$'

If you write this out on the command line of most shells, you may have to type this as:

perl -pE'(sprintf"%b",$_)=~/(1+)(?!.*1\1)/;$_=length$'"'"

The dance of the quotes at the end is just to get perl see a ', which would otherwise be consumed by the shell.

Retina, 52 43 bytes

Convert to binary, then replace with the length of what follows the largest string of ones.

.*
$*
+`(1+)\1
$+0
01
1

$'¶
O`
A-3`
^1+

.

Try it online - all test cases

Saved 9 bytes thanks to Martin.