哪个角箱单元测试会失败?

时间:2016-10-21 08:33:28

标签: c# algorithm data-structures computer-science

我尝试了Fish problem on Codility并获得了75%的正确性标记,因为结果报告说我的代码失败了一个简单的测试用例。结果不会报告为测试用例提供的输入。

请问您能帮我找出我的代码有什么问题以及它会失败的最坏情况吗?

using System;

public class Solution
{
    // Time complexity: O(N)
    // Space complexity: O(N)
    public int solution(int[] sizes, int[] direction)
    {
        if (sizes == null || direction == null)
            throw new ArgumentNullException();

        var sizesLen = sizes.Length;
        var directionLen = direction.Length;

        if (sizesLen != direction.Length)
            throw new ArgumentException();

        var len = sizesLen;

        if (len <= 1) return len;

        var survivors = new Fish[len];
        survivors[0] = new Fish(sizes[0], direction[0]);
        var curr = 0;

        for (int i = 1; i < len; i++)
        {
            var fish = new Fish(sizes[i], direction[i]);

            if (survivors[curr].Direction == 1 && fish.Direction == 0)
            {
                if (fish.Size < survivors[curr].Size) continue;

                while(curr >= 0 && 
                    fish.Size > survivors[curr].Size && 
                    survivors[curr].Direction == 1)
                {
                    curr--;
                }
            }

            survivors[++curr] = fish;
        }

        return ++curr;
    }
}

public class Fish
{
    public Fish(int size, int direction)
    {
        Size = size;
        Direction = direction;
    }

    public int Size { get; set; }
    public int Direction { get; set; }
}

2 个答案:

答案 0 :(得分:2)

正如您的代码中所述,您的解决方案是O(M*N)。如问题链接中所述,代码应以线性时间运行。因此,我不会更正您的解决方案,因为它最终会在更大的测试用例中失败。我将为您提供一个可以轻松实现的线性算法。

保持堆栈S,最初为空。

Ai

迭代数组0n-1

遇到元素时,请说A[i],请执行以下操作

  • 如果堆栈S为空,则将两者(A[i], B[i])同时推送
  • 否则,从堆栈S中提取顶部对,并比较B[top]B[i]的值。

    虽然 B[top]1B[i]0,但其中一条鱼会吃掉另一条鱼。所以从顶部元素堆栈S弹出。现在,比较哪些鱼的值更大,值A[top]A[i]。无论哪个更大,鱼都活着。将该对推入堆栈S,该堆对应于保持活着的鱼。继续 while 循环,直到条件失败 如果B[top]不是1B[i]不是0,那么只需推送新对(A[i],B[i]

最后的堆栈S的大小是你的答案。

注意:您可能没有通过该解决方案超时的测试用例。例如,对于N = 100000,您的解决方案将超时。

在我的解决方案中,最差情况时间复杂度为O(N+N) = O(2N) = O(N)N次由于迭代超过数组A而另一N次最坏情况,因为堆栈如果它一直在缩小,对于条件保持{ {1}}。

希望它有所帮助!!!

编辑:假设A = [99,98,92,91,93],B = [1,1,1,1,0]。您的代码给出答案为3.预期答案= 2

编辑-2:这是您修改后的代码,将通过每个测试用例

true

答案 1 :(得分:0)

我认为这里的意图是使用Stack或Queue。这是一个有两个Stack的解决方案。

fragment_layout.xml