골

음수가 아닌 정수가 주어지면 해당 정수의 이진 값에서 최대 연속 1의 수의 시작 위치를 반환하는 함수를 만듭니다.

입력이 주어지면을 0반환 0합니다.

숫자에 같은 길이의 여러 줄이있는 경우 마지막 줄의 위치를 ​​반환해야합니다.

입력

정수보다 크 거나 같음 0.

산출

아래에 설명 된대로 계산 된 정수입니다.

규칙

• 이것은 코드 골프이므로 각 언어에서 가장 짧은 바이트 코드가 이깁니다.
• 표준 허점은 금지되어 있습니다.

예 및 테스트 사례

실시 예 1

• 함수에 정수 142가 전달되었습니다.
• 142는 이진에서 10001110과 같습니다.
• 가장 긴 줄무늬는 "111"(세 개의 줄무늬)
• 행진은 2 ^ 1 위치에서 시작합니다
• 함수는 결과로 1을 반환합니다

실시 예 2

• 함수에 정수 48이 전달되었습니다.
• 이진수로 48은 110000과 같습니다.
• 가장 긴 줄은 "11"(두 줄의 줄)입니다.
• 행진은 2 ^ 4 위치에서 시작합니다
• 함수는 결과로 4를 반환합니다

실시 예 3

• 함수에 정수 750이 전달되었습니다.
• 750은 이진수 1011101110과 같습니다.
• 가장 긴 줄무늬는 "111"(세 개의 줄무늬)
• 길이가 같은 두 줄이 있으므로 나중에 줄을 반환합니다.
• 후행은 2 ^ 5 위치에서 시작됩니다.
• 함수는 결과로 5를 반환합니다

젤리 , 10 8 바이트

Ba\ÐƤṀċ¬

온라인으로 사용해보십시오!

작동 원리

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.

자바 스크립트 (ES6), 41 40 36 34 바이트

@ThePirateBay 덕분에 4 바이트 절약

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

테스트 사례

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

방법?

일반적인 경우 x> 0

우리는 재귀 적으로 입력 x 와 x / 2 를 사용하여 시퀀스의 가장 오른쪽 비트 만 남을 때까지 연속 세트 비트의 패턴을 점진적으로 줄입니다. 우리는 0이 아닌 마지막 값의 사본을 유지하고 밑이 2 인 로그를 반올림하여 최상위 비트의 위치를 ​​결정합니다.

다음은 x = 750 ( 이진수 1011101110) 에 대해 수행하는 단계 입니다.

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

가장자리 케이스 x = 0

특별한 경우는 x = 0즉시로 이어집니다 Math.log2(0) | 0. 의 대수 0로 평가 -Infinity하고 32 비트 정수로 바이너리 비트 또는 강제 설정 강제. 추상 작업 ToInt32 의 사양에 따라 다음과 같이 예상됩니다 0.

경우 수 있습니다 NaN를 , +0 , -0 , + ∞ , 또는 -∞ , 돌려 공을

x86 기계 코드, 14 바이트

사용 Arnauld의 알고리즘 @ 의 x &= x>>1와 전에이 단계에서 가장 높은 세트 비트 위치 복용 x하게를 0.

unsigned longest_set(unsigned edi);x86-64 System V ABI의 서명 을 사용하여 C / C ++에서 호출 할 수 있습니다 . 동일한 기계 코드 바이트는 32 비트 모드에서 동일한 방식으로 디코딩되지만 표준 32 비트 호출 규칙은 첫 번째 인수를에 넣지 않습니다 edi. (입력이 등록 변경 ecx또는 edxWindows 용 _fastcall/ _vectorcall또는 gcc -mregparm아무것도 파괴없이 할 수 있습니다.)

   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

x86의 BSR명령어 (Bit Scan Reverse)는이 경우에 적합하므로 선행 0을 계산하는 대신 비트 인덱스를 직접 제공합니다. ( bsr직접 = 0과 같은 입력에 0을 생성하지 않습니다 32-lzcnt(x),하지만 우리는 너무 비 제로 입력에 대한 = 31 lzcnt BSR 필요가 lzcnt혼자 바이트 수를 것조차 지침에 저장 할 수 있습니다. 영점의 EAX를 때문에 루프가 작동하기 전에 bsr' 입력이 0 일 때 대상을 수정하지 않은 반 공식 동작.)

가장 긴 실행의 MSB 위치를 반환 할 수 있다면이 길이는 더 짧을 것입니다. 이 경우 lea ecx, [rdi+rdi](3 바이트)는 + (4 바이트) 대신 + 왼쪽 -shift를 복사 합니다.movshr

전화를 거는 asm 발신자에 대해서는 이 TIO 링크 를 참조하십시오.exit(longest_set(argc-1));

쉘 루프를 사용한 테스트 :

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

젤리 , 19 17 11 바이트

HÐĿ&\ḟ0ṪBL’

온라인으로 사용해보십시오!

@Dennis의 예리한 관찰 덕분에 -6 (!) 바이트

작동 원리

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

파이썬 2 , 45 바이트

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

온라인으로 사용해보십시오!

Dennis 덕분에 많은 바이트를 절약했습니다! ( len(bin(...))-3대신에 머리 위로 올라감 math.frexp)

다행히도 쉽게 고칠 수있는 버그를 찾은 @xnor에게 감사합니다!

펄 6 ,45 35 바이트

이 개선 된 버전은 @nwellnhof가 제공합니다.

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

온라인으로 사용해보십시오!

파이썬 2 , 89 78 바이트

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

온라인으로 사용해보십시오!

편집 : Mr. Xcoder 덕분에 11 바이트를 절약했습니다.

05AB1E , 14 12 11 바이트

bDγàŠrkrJgα

온라인으로 사용해보십시오! 또는 테스트 케이스를 실행하십시오 .

설명

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 바이트

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

온라인으로 사용해보십시오!

설명

(#-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 코어) , 64 60 바이트

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

온라인으로 사용해보십시오!

@Arnauld의 답변의 AC # 버전

감사의 말

Kevin Cruijssen 덕분에 4 바이트가 절약되었습니다.

C # (. NET 코어) , 131123 + 18 = 141 바이트

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

온라인으로 사용해보십시오!

+18 바이트 using System.Linq;

감사의 말

Grzegorz Puławski 덕분에 8 바이트가 절약되었습니다.

탈고

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 코어) , 164 바이트

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

온라인으로 사용해보십시오!

비Linq 아무것도 즉시 알 수 없지만 내가 확신 솔루션은 향상 될 수있다.

탈고

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
}

껍질 , 12 바이트

→S§-€¤≠Lo▲gḋ

온라인으로 사용해보십시오!

설명

                 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

젤리 ,  14 13 12  11 바이트

Bµṣ0Ṫ$ƤMḢạL

음이 아닌 정수를 가져오고 리턴하는 모나드 링크.

온라인으로 사용해보십시오!또는 테스트 스위트를 참조하십시오 .

방법?

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

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

 4  을 저장 해준 Jonathan Allan에게 감사합니다 6 바이트 합니다!

오래 걸리지 만 이것을 포기하기에는 너무 많은 노력을 기울였습니다. 나는 1이진 표현에서 s 의 가장 긴 부분 문자열을 문자 그대로 검색하는 솔루션을 추가하고 싶었습니다 ...

설명

BŒgḄṀB-수도원 도우미 링크. 다음 링크에서 Ç과 함께 사용됩니다.

B-이진 표현.
 Œg-연속적인 동일한 요소로 구성된 그룹 런.
   Ḅ-이진수를 정수로 변환합니다.
    Ṁ-최대 값.
     B-정수에서 이진으로 변환합니다.


BwÇɓÇL + ɓBL_ '-메인 링크.

B-이진 표현 (입력).
  Ç-모나드로서의 마지막 링크. 입력 정수를받습니다.
 w-첫 번째 서브리스트 색인.
   ɓ-별도의 2 차원 체인을 시작하십시오. 인수를 반대로합니다.
    Ç-모나드로서의 마지막 링크.
     L-길이.
      +-추가
       ɓ-별도의 2 차원 체인을 시작하십시오. 인수를 반대로합니다.
        B-이진.
         L-길이.
          _ '-젤리가 1- 인덱싱을 사용하기 때문에 결과를 빼고 증가시킵니다.
              -암시 적으로 출력됩니다.

코 틀린 , 77 바이트

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

미화

{
    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()!!)
}

테스트

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

하스켈 , 101 98 96 75 바이트

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

온라인으로 사용해보십시오! 사용법 : snd.maximum.(`zip`[0..]).c $ 142수확량 1.

설명:

• c한 줄의 길이를 계산하면서 입력을 이진으로 변환하고 결과를 목록으로 수집합니다. 이 목록 r<-c$div n 2의 나머지 부분 r을 재귀 적으로 계산 하면서 sum[r!!0+1|mod n 2>0]:r현재 줄의 길이 를에 추가합니다 r. 목록 이해는 다음을 확인합니다.mod n 2>0 , 즉 현재 이진수가 1인지 여부를 , 이진 행의 길이 (의 첫 번째 요소 r)를 취하여 1 을 더합니다. 그렇지 않으면 목록 이해가 비어 sum[]있고을 산출 0합니다. 예제 입력의 c 142경우 list를 생성합니다 [0,3,2,1,0,0,0,1,0].

• (`zip`[0..])튜플의 두 번째 구성 요소로 이전 목록의 각 요소에 위치를 추가합니다. 예를 들어 이것은 [(0,0),(3,1),(2,2),(1,3),(0,4),(0,5),(0,6),(1,7),(0,8)].

• maximum이 목록에서 사전 식적으로 최대 튜플을 찾습니다. 즉, 첫 번째 구성 요소 인 것처럼 연속 길이가 먼저 고려되고, 동점 인 경우 두 번째 구성 요소 인 즉, 더 큰 색인이 결정됩니다. 이 (3,1)예에서는 snd결과가 나오고 튜플의 두 번째 구성 요소를 반환합니다.

파이썬 2 또는 3 , 58 바이트

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

온라인으로 사용해보십시오!

C (gcc) , 81 80 바이트

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

온라인으로 사용해보십시오!

C (gcc) , 43 바이트

@Arnauld의 답변의 AC 버전

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

온라인으로 사용해보십시오!

MS SQL 서버, 437 426 407 398 바이트

SQL 바이올린

줄 바꿈 등을 제거 할 수 있다고 확신하지만, 기꺼이 만들만큼 컴팩트합니다.

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

더 읽기 쉬운 버전은 다음과 같습니다.

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

진짜 요령은 내가 찾을 수있는 한 숫자를 십진수에서 이진수로 변환하는 기본 SQL 기능이 없다는 것입니다. 결과적으로 변환을 수동으로 이진으로 코딩해야했고 올바른 숫자를 찾을 때까지 한 번에 한 문자 씩 문자열로 비교할 수있었습니다.

이 작업을 수행하는 더 좋은 방법이 있다고 확신하지만 SQL 응답이 표시되지 않으므로 거기에 버릴 것이라고 생각했습니다.

APL (Dyalog Unicode) , 22 자 = 53 바이트

⎕IO←0많은 시스템에서 기본값이 필요합니다 .

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

온라인으로 사용해보십시오!

⎕ 입력 프롬프트

⊢ 그 수율 (분리형 ¯1에서 ⎕)

2⊥⍣¯1 필요한만큼 많은 위치를 사용하여 밑이 2로 변환

b← 로 저장 b( b inary)

⌽ 역

(… ) 다음의 시작 위치를 표시하십시오.

 ⊆⍨b 자체 파티션 b(즉, 1 줄 b)

 ↑ 믹스 (리스트 목록을 행렬로 만들고 0으로 채 웁니다)

 ∨⌿ 수직 OR 감소 (가장 긴 줄무늬)

⍸ ɩ 시작 위치 ndices

⌽ 역

⊃ 첫 번째 것을 고르세요 (아무것도 없으면 0을 얻습니다)

MATL , 15 바이트

`tt2/kZ&t]xBnq&

온라인으로 사용해보십시오!

반과 AND 아이디어를 사용합니다. 는 k이 종료되는 있도록에만 필요1 어떤 이유로, 1 및 0.5 반환 1, 무한 루프의 원인 -.

(대체 솔루션 : BtnwY'tYswb*&X>)-이진 및 실행 길이 인코딩으로 변환)

Google 스프레드 시트, 94 바이트

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

아뇨, 예쁘지 않아요 보관할 수있어서 정말 좋을 것 같습니다Dec2Bin(A1)참조를 위해 변수 입니다.

요점 : Excel과 마찬가지로이 Dec2Bin함수의 최대 입력 값은 511입니다. 그보다 큰 것은 아래에 표시된 것처럼 오류를 반환합니다.

R, 117 바이트

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

엑셀 VBA, ₅₄ 44 Bytes

@EngineerToast 덕분에 -10 바이트

범위에서 입력 [A1]을 받고 VBE 즉시 창으로 출력하는 익명 VBE 즉시 창 기능

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

APL (Dyalog Classic), 24 21 bytes

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

Try it online!

Pyth, 17 bytes

This is a recursive function. The link includes y in order to call the function on the given input.

L|&K.&b/b2yKsl|b1

Verify all test cases.

Pyth, 20 bytes

-lK.B|Q1+xKJeScK\0lJ

Verify all test cases.

R, 66 Bytes

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

Explanation:

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.