Question

问题：将给定的十进制数转换为二进制数并计算连续的1并显示它

示例案例1： 5的二进制表示为101，因此连续1的最大数为1。

示例案例2： 13的二进制表示是1101，因此连续1的最大数量是2。

解决方案：

#!/bin/python3

import sys


n = int(input().strip())
result = []
counter = 1
def get_binary(num):
    if num == 1:
        result.append(num)
        adj(result)
    else:
        result.append(num%2)
        get_binary(int(num/2))

def adj(arr):
    global counter
    for x in range(0,len(arr)-1):
        if arr[x] == 1 and (arr[x] == arr[x+1]):
            counter += 1
    print(counter)

get_binary(n)

它没有通过所有的示例测试用例。我做错了什么？

Answer 1

下面的

是一个有效的简化版本

def func(num):
  return max(map(len, bin(num)[2:].split('0')))

将整数转换为二进制表示bin(num)
从二进制表示bin(num)[:2]
在字符0 bin(num)[2:].split('0')
找到具有最大长度的字符串并返回数字

Answer 2

以下是使用regex的替代解决方案：

>>> import re
>>> def bn(i):
...     n = bin(i)[2:]
...     return n,max(len(j) for j in re.findall(r'1+', n))
...
>>>
>>> bn(13)
('1101', 2)
>>> bn(25)
('11001', 2)

Answer 3

你的计数器逻辑在几个方面是不正确的，M。Fabre确定了主要的一个。结果是，您计算所有序列中的后续1的总数量，并从计数器的初始值加1。流氓一个给了你一个可爱的Pythonic解决方案。要在您的级别修复此问题，请转到 adj 并修复...

您不在功能外使用计数器;保持本地化。
制作第二个变量，它是迄今为止找到的最佳字符串。
使用计数器作为当前字符串;当你点击0时，与最好的目标进行比较，重置计数器，然后继续。\

中心逻辑就像......

best = 0
counter = 0
for bit in arr:
    if bit == 1:
        counter += 1
    else:
        if counter > best:
            best = counter
        counter = 0

# After this loop, make one last check, in case you were on the longest
#   run of 1s when you hit the end of the bits.
# I'll leave that coding to you.

Answer 4

这里有一些聪明的答案，我认为我会使用传统的高效命令方法添加替代方案。

此方法首先将数字转换为字符串二进制表示。从那里它更新一堆最长的值，并检查是否有更长的值要添加。因此，您最终会得到一堆按最长连续1排序的值。要从堆栈中选择最大值，只需pop()。

def longest_consecutive_one(n):
    stack = [0]
    counter = 0
    binary_num = '{0:08b}'.format(n)
    length = len(binary_num) - 1
    for index, character in enumerate(binary_num):
        if character == "1":
            counter += 1
        if character == '0' or index == length:
            if stack[-1] < counter:
                stack.append(counter)
                counter = 0
    return stack.pop()

示例输出：

>>> longest_consecutive_one(190)
5
>>> longest_consecutive_one(10)
1
>>> longest_consecutive_one(10240)
1
>>> longest_consecutive_one(210231)
6

Answer 5

输出以下编写的代码将给出输入十进制数的连续一个的最大数量。

    n = int(raw_input().strip())
    num = list((bin(n).split('b'))[1])
    num.insert(0,'0')
    num.append('0')
    count = 0
    store = 0
    for i in range(0,len(num)):
        if ((num[i]) == '1'):
            count+=1
        elif ('0' == (num[i])) and count !=0:
            if count >= store:
                store = count
            count = 0
    print store

Answer 6

这使用了一点魔术

def maxConsecutiveOnes(x): 

    # Initialize result 
    count = 0

    # Count the number of iterations to 
    # reach x = 0. 
    while (x!=0): 

        # This operation reduces length 
        # of every sequence of 1s by one. 
        x = (x & (x << 1)) 

        count=count+1

    return count 

# Driver code 
print(maxConsecutiveOnes(14)) 
print(maxConsecutiveOnes(222))

输出将是3和4

Answer 7

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;
    int count=0,min=0;
    cin>>n;
    for(int i=0;n>0;i++)
    {
        if(n%2==1)
                {

                count++;
                  if(count>min)
                   {
                     min=count;

                   }
                }
            else
                {
                 count=0;
                 }
        n = n/2;

    }
       cout<<min<<endl;
    return 0;
}

Answer 8

我认为第一个答案是最好的。我以类似的方式完成了它，可能更容易理解。

import sys
if __name__ == '__main__':
    n = int(input())
    bina=str(format(n,'b'))
    holder=bina.split('0')
    max_num = max(holder,key=len)
    print(len(max_num))

将给定的十进制数转换为二进制数并计算连续的1并显示它

8 个答案: