连续负数算法

Question

For the life of me I am stuck on how to keep track of the maximum number of consecutive negative numbers.

I have a list of numbers that gets feed in to a class method during every iteration of a for loop. These numbers can ether be positive or negative and there are no clear way of knowing what will follow what. I need an algorithm so that it can calculate in real time (during loop execution) continuous the consecutive negative number. So at the end of the loop iteration the number stored in consecutiveNegative will be an integer showing the largest consecutive times a negative number was followed by another negative number.

The below is what I've tried but it doesn't work...

class Temp
{
    public int consecutiveNegative = 0;
    private bool previousNegative = false;


    public void iterCall(int x)
    {
        if(x > 0)
        {
            if(previousNegative == true)
            {
                consecutiveNegative = 0;
            }
            previousNegative = false;

        }
        else if (x < 0)
        {
            if (previousNegative == false)
            {
                consecutiveNegative = consecutiveNegative + 1;
            }
            previousNegative = true;
        }
    }


}

Any pointers?

---

Below is some code to get people started messing around.

Temp classTmp = new Temp();
List<int> nums = new List<int>();
nums.Add(1);
nums.Add(-1);
nums.Add(1);
nums.Add(-1);
nums.Add(-1);
nums.Add(-1);
nums.Add(1);
nums.Add(-1);
nums.Add(-1);
nums.Add(1);

for(int i = 0; i < nums.Count;i++)
{
    classTmp.iterCall(nums[i]);
}

classTmp.consecutiveNegative should be 3 after it finishes the loop.

Answer 1

To my understanding, the code should be modified as follows. There was no variable to keep track of the maximum sequence, and the negativity of the last input does not need to be stored. At any time, the desired result can be obtained by evaluating

Math.Max(ConsecutiveNegative,CurrentConsecutiveNegative)

as the sequence might not be terminated.

class Temp
{
    public int CurrentCosecutiveNegative = 0;
    public int ConsecutiveNegative = 0;

    public void iterCall(int x)
    {
        if(x >= 0)
        {
            ConsecutiveNegative
              = Math.Max(ConsecutiveNegative,CurrentConsecutiveNegative);
            CurrentConsecutiveNegative = 0;
        }
        else
        {
            CurrentConsecutiveNegative++;
        }
    }
}

Answer 2

You need a maxNegative , to keep track of your current longest-running consecutive negatives. Also, your logic was faulty in your x < 0 case: the second time it was negative, it wouldn't increase the count.

class Temp
    {
        public int consecutiveNegative = 0;
        public int maxNegative = 0;

        public void iterCall(int x)
        {
            if (x > 0)
            {
                consecutiveNegative = 0;
            }
            else if (x < 0)
            {
                consecutiveNegative += 1;
                if (maxNegative < consecutiveNegative)
                    maxNegative = consecutiveNegative;
            }
        }
    }

As @Codor showed, using this approach you don't need a boolean to keep track of the previous number, because consecutiveNegative will be reset automatically.

Answer 3

You need 2 vars one for the largest negatives sequence and another for the current sequence length:

class Temp
{
    public int consecutiveNegative = 0;
    public int curConsecutiveNegatives = 0;

    public void iterCall(int x)
    {
        if (x < 0)
            consecutiveNegative = Math.Max(consecutiveNegative, ++curConsecutiveNegatives);
        else
            curConsecutiveNegatives = 0;

    }
}