Question

给定一组整数......

var numbers = new int[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,2,1,2,1 };

我需要确定一个最大的数字序列，然后向下或向下交替。

不确定最好的方法来处理这个问题，psuedo明智的过程让我感到很简单，但实现代码却让我感到厌烦。

关键是我们正在寻找最大序列的事实，所以虽然上述数字可以通过多种方式解释，例如七个上下行和七个上下行的序列，重要的事实是从第一个数字是一个14长的下行顺序。

此外，我不应该计算第一个项目，121是长度为3的序列，可以认为序列直到第二个数字才开始，但不允许分裂头发。

Answer 1

这似乎有效，它假设数字的长度大于4（无论如何这种情况应该是微不足道的）：

var numbers = new int[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,2,1,2,1 };
int count = 2, max = 0;
for (int i = 1; i < numbers.Length - 1; i++)
{

    if ((numbers[i - 1] < numbers[i] && numbers[i + 1] < numbers[i]) ||
                    (numbers[i - 1] > numbers[i] && numbers[i + 1] > numbers[i]))
    {
        count++;
        max = Math.Max(count, max);
    }
    else if ((numbers[i - 1] < numbers[i]) || (numbers[i - 1] > numbers[i])
                || ((numbers[i] < numbers[i + 1]) || (numbers[i] > numbers[i + 1])))
    {
        max = Math.Max(max, 2);
        count = 2;
    }
}
Console.WriteLine(max); // 14

Answer 2

我现在不是来自带编译器的电脑，所以我试试看：

int max = 0;
int aux =0;
for(int i = 2 ; i < length; ++i)
{
    if (!((numbers[i - 2] > numbers[i - 1] && numbers[i - 1] < numbers[i]) ||
           numbers[i - 2] < numbers[i - 1] && numbers[i - 1] > numbers[i]))
    {
        aux = i - 2;
    }
    max = Math.Max(i - aux,max);
}
if (max > 0 && aux >0)
    ++max;

注意：应该适用于至少3个元素的序列。

Answer 3

以下是我的想法

首先，您需要知道自己是从高处开始还是从低位开始。例如：1-2-1或2-1-2。你甚至可能没有交替配对。
然后，考虑当前的方向，然后考虑每个数字，看它是否属于序列。
每次序列中断时，您需要通过检查方向重新开始。

我不确定您是否有可能从已经看过的数字中选择不同的起始数字，可能会生成更长的序列。也许有一个定理表明它是不可能的;也许这是显而易见的，我过分思考。但我不认为这是可能的，因为序列被破坏的原因是因为你有两个高或两个低，并且没有办法解决这个问题。

我假设了下列情况

{} - 没有元素，返回0
{1} - 单个元素，返回0
{1, 1, 1} - 没有交替序列，返回0

对C＃期望的输入没有限制。它可能会被浓缩。不确定是否有办法在没有明确跟踪方向的情况下捕获方向改变逻辑。

static int max_alternate(int[] numbers)
{
  int maxCount = 0;
  int count = 0;
  int dir = 0; // whether we're going up or down

  for (int j = 1; j < numbers.Length; j++)
  {
      // don't know direction yet
      if (dir == 0)
      {
          if (numbers[j] > numbers[j-1])
          {
              count += 2; // include first number
              dir = 1; // start low, up to high
          }
          else if (numbers[j] < numbers[j-1])
          {
              count += 2;
              dir = -1; // start high, down to low
          }
      }
      else
      {
          if (dir == -1 && numbers[j] > numbers[j-1])
          {
              count += 1;
              dir = 1; // up to high
          }
          else if (dir == 1 && numbers[j] < numbers[j-1])
          {
              count += 1;
              dir = -1; // down to low
          }
          else 
          {
              // sequence broken
              if (count > maxCount)
              {
                  maxCount = count;
              }
              count = 0;
              dir = 0;
          }
      }
  }
  // final check after loop is done
  if (count > maxCount)
  {
      maxCount = count;
  }
  return maxCount;
}

根据我对问题和一些假设的理解，结果的一些测试用例。

static void Main(string[] args)
{

    int[] nums = { 1};            // base case == 0
    int[] nums2 = { 2, 1 };       // even case == 2
    int[] nums3 = { 1, 2, 1 };    // odd case == 3
    int[] nums4 = { 2, 1, 2 };    // flipped starting == 3
    int[] nums5 = { 2, 1, 2, 2, 1, 2, 1 }; // broken seqeuence == 4
    int[] nums6 = { 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1 }; // long sequence == 14
    Console.WriteLine(max_alternate(nums));
    Console.WriteLine(max_alternate(nums2));
    Console.WriteLine(max_alternate(nums3));
    Console.WriteLine(max_alternate(nums4));
    Console.WriteLine(max_alternate(nums5));
    Console.WriteLine(max_alternate(nums6));
    Console.ReadLine();
}

Answer 4

可能有很多方法可以解决这个问题，但这里有一个选择：

var numbers = new int[] { 7,1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 2, 1, 2, 1 };
int maxCount = 0;
for (int j = 0; j+1 < numbers.Length; j++)
{
    int count = 0;
    if (numbers[j] < numbers[j+1])
    {
        count += 2;
        for (int i = j+2; i+1 < numbers.Length; i += 2)
        {
            if (numbers[i] < numbers[i + 1] )
            {
                count += 2;
            }
            else
            {
                break;
            }
        }
    }
    if (maxCount < count)
    {
        maxCount = count;
    }
}
Console.WriteLine(maxCount);
Console.ReadLine();

此解决方案假设您需要相同的两个交替数字的序列。如果这不是要求，您可以更改第二个if。

现在已经写出来了，它看起来比我想象的要复杂得多......也许其他人可以提出更好的解决方案。

Answer 5

假设至少有2个元素。

int max = 1;
bool expectGreaterThanNext = (numbers[0] > numbers[1]);
int count = 1;

for (var i = 0; i < numbers.Length - 1; i++)
{
    if (numbers[i] == numbers[i + 1] || expectGreaterThanNext && numbers[i] < numbers[i + 1])
    {
        count = 1;
        expectGreaterThanNext = (i != numbers.Length - 1) && !(numbers[i] > numbers[i+1]);
        continue;
    }
    count++;
    expectGreaterThanNext = !expectGreaterThanNext;

    max = Math.Max(count, max);
}

Answer 6

这适用于任何整数，它跟踪你喜欢的低喜和低喜。

int numbers[] = new int[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,2,1,2,1 };

   int count = 0;
   int updownup = 0;
   int downupdown = 0;
   for(int x = 0;x<=numbers.Length;x++)
   {
      if(x<numbers.Length - 2)
      {
         if(numbers[x]<numbers[x+1])
         {
          if(numbers[x+1]>numbers[x+2])
           {
           downupdown++; 
            }
         }

    }
}
count = 0;
for(x=0;x<=numbers.Length;x++)
{
  if(x<numbers.Length - 2)
  {
    if(numbers[x]>numbers[x+1]
    {
     if(numbers[x+1]<numbers[x+2])
     {
        updownup++;
        }
    }
    }

}

计算数组中的交替数字

6 个答案: