目标

给定一个非负整数，创建一个函数，该函数返回该整数的二进制值中最大的连续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.

JavaScript（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递归“与” ，从而逐渐减少连续设置位的模式，直到仅保留序列的最右边的位。我们保留最后一个非零值的副本，并通过舍入以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：

如果number为NaN，+0，-0，+∞或-∞，则返回 +0

x86机器码，14个字节

使用@阿尔诺算法的x &= x>>1，并采取在之前的步骤中最高设置位的位置x变成0。

可通过C / C ++调用，并带有unsigned longest_set(unsigned edi);x86-64 System V ABI中的签名。在32位模式下，相同的机器代码字节将以相同的方式进行解码，但是标准的32位调用约定不会将第一个arg放入edi。（将输入寄存器更改为Windows 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指令（反向位扫描）非常适合此操作，它直接为我们提供了位索引，而不是对前导零进行计数。（bsr不会像输入那样直接为input = 0产生0 32-lzcnt(x)，但是对于非零输入，我们需要bsr = 31-lzcnt，因此lzcnt甚至不保存指令，更不用说字节计数了。在循环工作之前对eax进行清零是因为bsr'输入为零时不更改目的地的半官方行为。）

如果我们可以返回最长运行时间的MSB位置，则该时间会更短。在这种情况下，lea ecx, [rdi+rdi]（3个字节）将复制+ 左移而不是mov+ shr（4个字节）。

请参阅此TIO链接，了解执行以下操作的asm调用程序exit(longest_set(argc-1));

使用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

果冻，19 17 11字节

HÐĿ&\ḟ0ṪBL’

在线尝试！

-6（！）个字节，感谢@Dennis的敏锐观察

怎么运行的

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个字节

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

在线尝试！

感谢Dennis，节省了很多字节！（请注意，len(bin(...))-3而不是math.frexp）

感谢@xnor找到了一个bug，幸运的是它很容易修复！

Perl 6，45 35字节

此高度改进的版本由@nwellnhof提供。

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

在线尝试！

Python 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

在线尝试！

编辑：由于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 Core），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 Core），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;

致谢

感谢GrzegorzPuł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 Core），164161字节

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_‘

在线尝试！

感谢Jonathan Allan节省了 4  6个字节！

尽管已经很长时间了，但我已经做了很多工作，只是放弃了这一点。我真的很想添加一个解决方案，从字面上搜索1二进制表示形式中s 的最长子串。

说明

BŒgḄṀB-Monadic助手链接。在下一个链接中将与Ç一起使用。

B-二进制表示。
 Œg-连续相等元素的分组运行。
   Ḅ-从二进制转换为整数。
    Ṁ-最大值。
     B-从整数转换为二进制。


BwÇɓÇL+ɓBL_'-主链接。

B-（输入的）二进制表示形式。
  Ç-作为单声道的最后一个链接。接受输入整数。
 w-第一个子列表索引。
   ɓ-建立单独的二元链。反转参数。
    Ç-作为单声道的最后一个链接。
     L-长度。
      +-加法
       ɓ-建立单独的二元链。反转参数。
        B-二进制。
         L-长度。
          _'-减去并增加结果（因为Jelly使用1索引）。
              -隐式输出。

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

Haskell，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）并加一个。否则，列表理解为空，并sum[]产生0。对于示例输入，c 142产生列表[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返回元组的第二个分量。

Python 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个字节

AC版本的@Arnauld的答案

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

在线尝试！

MS SQL Server中，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）

 ↑ 混合（将列表的列表放入矩阵中，并用零填充）

 ∨⌿ 垂直或减少（产生最长条纹）

⍸ of起始位置要点

⌽ 相反

⊃ 选择第一个（如果没有可用，则收益为零）

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

Excel VBA，₅₄ 44字节

-10字节感谢@EngineerToast

匿名VBE立即窗口功能，可接收范围内的输入[A1]并输出到VBE立即窗口

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

APL（Dyalog Classic），24 21字节

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

在线尝试！

腐霉菌，17个字节

这是一个递归函数。该链接包括y为了在给定输入上调用函数。

L|&K.&b/b2yKsl|b1

验证所有测试用例。

Pyth，20个字节

-lK.B|Q1+xKJeScK\0lJ

验证所有测试用例。

R，66字节

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

说明：

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个字节

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

在线尝试！

基于Xcoder先生的解决方案。

Javascript，54个字符

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

• i.toString(2) 获取整数的二进制字符串。
• 在.split(0)得到在阵列元素中的每个按顺序的一部分。
• .sort().reverse() 首先获得我们最高的价值。
• 这[0].length给了我们第一个值的长度。

Perl 5、45 +1（-p）

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

如果您在大多数Shell的命令行上将此代码写出来，则可能必须输入以下内容：

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

最后的引号是为了让perl看到a '，否则将被shell消耗。

视网膜，52 43字节

转换为二进制，然后替换为最大字符串后面的长度。

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

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

.

在线尝试 -所有测试案例

感谢Martin，节省了9个字节。