查找堆栈中最长的字符序列答案

【问题标题】：Find longest sequence of characters in stack查找堆栈中最长的字符序列
【发布时间】：2016-09-13 19:58:27
【问题描述】：

您好，我正在解决一个问题：

给定一个以 10 为底的整数 n，将其转换为二进制（以 2 为底）。然后找到并打印以 10 为底的整数，表示连续 1 的最大数量在 n 的二进制表示中。例如对于 n=5，base-2 = 101 所以输出应该是 1，对于 n = 439，base-2 = 110110111 所以输出应该是 3。

下面是我的代码解决方案：

class Solution {

    static int CalcBinary (int n) {
        Stack<int> binRep = new Stack<int>();
        while (n > 0) {
            int i = n%2;
            binRep.Push (i);
            n = n/2;
        }
        int oldCount = 0, newCount = 0;
        while (binRep.Count > 0){
            int val = binRep.Pop();
            if (val == 1) {
                newCount++;
            } else {
                if (newCount > oldCount) {
                    oldCount = newCount;
                }
                newCount = 0;
            }
        }
        return (newCount > oldCount) ? newCount : oldCount;
    }

    static void Main(String[] args) {
        int n = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine (CalcBinary(n));
    }
}

代码运行良好，并通过了所有测试用例，例如 n = 5、6、439 等。我唯一的问题是，是否有任何优化的解决方案可以做到这一点。其他人发布了相同的问题here，但对该问题的所有回复似乎都与 O(n) 时间复杂度相同。另一件事是我可以使用数组而不是堆栈，但这有什么不同吗？？

【问题讨论】：

437 (110110101) 的答案是什么？ 2?
我认为计算一个数字中的 1 位（即 O（1 的数量））可能适用于这种情况，以获得比固定长度数字的 O（位数）更好... （只是猜测，不完全确定会不会成功）
我很确定您的意思是 O(log n)，除非 n 是二进制位数而不是数字本身。
有什么理由需要使用堆栈或数组 - 您可以直接处理整数值吗？ while (n > 0) { if ((n%2) == 1) .......
@UweKeim，在此之前我遇到过问题，虽然我的问题在 stackoverflow 上有效，但在代码审查中却是负面的。所以我更愿意在这里问他们。

标签： c# arrays algorithm loops stack

【解决方案1】：

public int CalcBinary(int n)
{
    int result = 0;
    int current = 0;
    for (int i = 0; i + result < 32 && (n >> i) != 0; i++)
    {
        if (((n >> i) & 1) == 1)
            current += 1;
        else
        {
            if (current > result) 
                result = current;
            current = 0;
        }
    }

    return result == 0 ? current : result;
}

我不太擅长大 O 算术，但我认为这个解决方案应该更快，因为我不使用任何其他类，只使用简单的位移。

如果不再有解决方案，我提早停止 (i + result < 32)。

注意，这仅适用于 32 位 整数。对于 64 位，请调整上述条件。它仅适用于正值（设置符号位会产生错误的结果，例如 111....111101）。

更新：按照@Scott-Chamberlain 的建议添加了(n >> i) != 0 条件（它检查是否还有1s 会出现）。

【讨论】：

你也可以通过i + result < 32 && n >> i != 0提前退出
@ScottChamberlain 我不明白，不应该是i + result < 32 || (n >> i) == 0 吗？所以 int 的“上其余部分”是零？
@ScottChamberlain 啊抱歉，我的错，for 循环的条件继续...我在脑海中将其转为退出条件

【解决方案2】：

为什么在转换二进制时不计算maximum_consecutive而不是等待转换完成，然后从堆栈中再次计算maximum_consecutive？

我认为你应该改变这个。

class Solution {

static int CalcBinary (int n) {
    int oldCount = 0, newCount = 0;
    while (n > 0) {
        int i = n%2;
        n = n/2;

        if (i == 1) {
            newCount++;
        }
        else {
            if (newCount > oldCount) {
                oldCount = newCount;
            }
            newCount = 0;
        }

    }
    return (newCount > oldCount) ? newCount : oldCount;
}

static void Main(String[] args) {
    int n = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine (CalcBinary(n));
}
}

【讨论】：

是的，实际上这使我免于创建堆栈。谢谢。

【解决方案3】：

为了有趣和最小的分支：

int[] lookup = new[]
{
  0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 
  31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
};
int LongestRunOfBits(uint value)
{
    int max = 0;
    while(1 << max < value + 1)
    {
        uint testValue = ~value;
        uint lookupIndex = ((uint)((testValue & -testValue) * 0x077CB531U)) >> 27;
        int trailingZeros = lookup[lookupIndex];
        max = trailingZeros - ((trailingZeros - max) & ((trailingZeros - max) >> 31));
        value >>= 1;
    }
    return max;
}

这结合了以下操作：

Compute the maximum of two integers without branching（QuAD 版本）

Count the consecutive zero bits (trailing) on the right with multiply and lookup（如果它计算value 上的尾随零位，那么它计算~value 上的尾随一位）

让我们来看看value 6 或110：

现在我们有了：

值：000000000000000000000000000000110 〜价值：1111111111111111111111111111001 尾随零位：0 rsh 后的值：000000000000000000000000000000011 〜价值：1111111111111111111111111111100 尾随零位：2 rsh 之后的值：00000000000000000000000000000001 //跳过最后一次迭代 ~value : 11111111111111111111111111111110 //因为现在不可能尾随零位：1 //找到一个> 2的值

通过找到~value 的最大尾随零位数，我们有效地找到了value 的最大尾随一位数。如果我们继续右移直到没有剩余的位，最长的设置位运行是我们在~value 上执行的尾随零位操作的最大值。万岁。一旦我们找到值 2 并且该值中剩余的位数为 2 或更少，我们可以提前放弃，因为我们可以确定找不到大于 2 的值，因此可以跳过最后一次迭代。

【讨论】：