C# 在数组中计算交替数
给定一个整数数组C# 在数组中计算交替数,c#,algorithm,C#,Algorithm,给定一个整数数组 var numbers = new int[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,2,1,2,1 }; 我需要确定一个最大的数字序列，它是先上后下还是先下后上 我不确定实现这一点的最佳方式，psuedo wise过程对我来说很简单，但具体化的代码却在逃避我 关键是我们正在寻找最大序列，因此，尽管上述数字可以用多种方式解释，比如7个向上向下和7个向下向下向下的序列，但重要的事实是，从第一个数字开始，有一个向下向上向下的序列，长度为14 我也不认为我
var numbers = new int[] { 1,2,1,2,1,2,1,2,1,2,1,2,1,2,2,2,1,2,1 };
我也不认为我们计算第一个项目，121是长度为3的序列，可以说序列直到第二个数字才开始，但不允许分割头发。可能有很多方法来实现这一点，但这里有一个选项：
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();
var number=newint[]{7,1,2,1,2,1,2,2,1,2,2,1,2,2,1,2,2,2,2,2,1}；
int maxCount=0；
对于（int j=0；j+1
现在，它被写出来了，它看起来比我在脑海中想象的更复杂。。。也许其他人可以想出一个更好的解决方案。我现在不是一台有编译器的电脑，所以我只是试试：
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;
int max=0；
int aux=0；
对于（int i=2；i数字[i-1]&数字[i-1]<数字[i]）||
数字[i-2]<数字[i-1]&数字[i-1]>数字[i]））
{
aux=i-2；
}
最大值=数学最大值（i-辅助，最大值）；
}
如果（最大值>0&&aux>0）
++最大值；
注：应适用于至少3个元素的顺序 这似乎是可行的，它假设数字的长度大于4（这种情况无论如何都不重要）：
var number=newint[]{1,2,1,2,1,2,1,2,1,2,1,2,2,1,2,2,2,2,1,2,1}；
整数计数=2，最大值=0；
for（int i=1；i数字[i]&数字[i+1]>数字[i]））
{
计数++；
最大值=数学最大值（计数，最大值）；
}
else if（（数[i-1]<数[i]）| |（数[i-1]>数[i]））
||（（数字[i]<数字[i+1]）| |（数字[i]>数字[i+1]））
{
max=Math.max（max，2）；
计数=2；
}
}
控制台写入线（最大值）；//14
这适用于任何整数，它会按照您的要求跟踪low hi low和hi low hi
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++;
}
}
}
}
int numbers[]=新的int[]{1,2,1,2,1,2,1,1,2,1,2,2,1,2,2,2,1,2,1}；
整数计数=0；
int-updownup=0；
int down=0；
对于（intx=0；x我是这样想的
- 首先，你需要知道你是从高起点开始还是从低起点开始。例如：
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;
}
假设至少有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);
}
int max=1；
bool expectGreaterThanNext=（数字[0]>数字[1]）；
整数计数=1；
对于（变量i=0；inumbers[i+1]）；
继续；
}
计数++；
expectGreaterThanNext=！expectGreaterThanNext；
最大值=数学最大值（计数，最大值）；
}
你的问题太模糊了。请更详细地说明你想做什么。听起来像是最大递增子序列，只检查交替，而不是递增。总是1s和2s吗？你需要知道条纹的起始位置，还是仅仅是最大大小？它们总是相差1吗？不，它可能与1和2相差很大，我只是t想要一个简单的例子来避免噪音。好的一点，这只是从一开始就计算序列的长度。我将更新答案来解决这个问题。如果输入在序列中包含奇数个值怎么办？（注意，这是在澄清之后）它应该仍然有效。如果你想用不同的序列进行测试，你应该能够将代码复制并粘贴到控制台应用程序中。这不是C#，这没什么大不了的，但它也不会产生正确的结果。@NominSim:你能澄清你的反对意见吗？我的意思是，我没有明确检查1或2。我遗漏了什么？对不起
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();
}
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);
}