C#找到满足条件的序列的相邻元素

因此，我必须编写一个程序，用数字填充数组，然后找到相邻的偶数，如（2，4，6等），然后在序列中对它们进行分类，然后显示序列的数量和每个序列的元素 编辑：我所指的数字是那些在除以2时以0作为剩余值的数字。对不起，误解了

范例

[1,2,2,3,4,6,9,3,2] it would display 2 sequences found and the contents are 2,2 and 4,6 (the last 2 was ignored because it isn't in a sequence)

这就是我所做的，但我一直在想该怎么做

            Console.WriteLine("Enter the number of rows you'd like yo have ");
        int rows = Convert.ToInt32(Console.ReadLine());
        if (rows > 20 || rows < 3)
            throw new ArgumentException("this isn't right");
        List<int> numbers = new List<int>(rows);
        List<int> D = new List<int>();
        for (int i = 0; i < rows; i++)
        {
            Console.WriteLine("Enter the " + i + "Element:");
            numbers[i] = Convert.ToInt32(Console.ReadLine());
        }

        for (int i = 0; i < numbers.Count; i++)
        {
            if (numbers[i] % 2 == 0)
            {
                D.Add(numbers[i]);

            }

Console.WriteLine（“输入您想要的行数”）；
int rows=Convert.ToInt32（Console.ReadLine（））；
如果（行数>20 | |行数<3）
抛出新的ArgumentException（“这不对”）；
列表编号=新列表（行）；
列表D=新列表（）；
对于（int i=0；i

我曾考虑过两个单独的列表，一个用于对号，另一个用于索引，但没有成功

如果您愿意使用，那么这是一种方法：

var inputData = new int[] { 1, 2, 2, 2, 3, 4, 6, 4, 8, 9, 3, 2 };

var wasEven = false;
var results = inputData.Segment(z =>
        {
            var isEven = z % 2 == 0;
            var result = isEven != wasEven;
            wasEven = isEven;
            return result;
        })
    .Where(z => z.Count() > 1 && z.First() % 2 == 0)
    .SelectMany(z => z).ToList();

Console.WriteLine(string.Join(",", results));

Segment

的使用是根据值是否与输入中的前一个值具有相同的

偶数

将输入分解为多个部分。然后使用

Count（）

仅查看其中包含多个条目的段，然后使用

First

确保该段包含偶数（而不是赔率）。

选择多个

和

列表

，然后将片段重新连接到一个列表中。

如果您愿意使用，则这是一种方法：

var inputData = new int[] { 1, 2, 2, 2, 3, 4, 6, 4, 8, 9, 3, 2 };

var wasEven = false;
var results = inputData.Segment(z =>
        {
            var isEven = z % 2 == 0;
            var result = isEven != wasEven;
            wasEven = isEven;
            return result;
        })
    .Where(z => z.Count() > 1 && z.First() % 2 == 0)
    .SelectMany(z => z).ToList();

Console.WriteLine(string.Join(",", results));

---

Segment

的使用是根据值是否与输入中的前一个值具有相同的

偶数

将输入分解为多个部分。然后使用

Count（）

仅查看其中包含多个条目的段，然后使用

First

确保该段包含偶数（而不是赔率）.

SelectMany

和

ToList

然后将这些段重新连接到一个列表中。

一种方法是循环数字，如果数字可以被2整除，则将其添加到临时列表中。如果不能被2整除，则检查临时列表中是否有多个项目，并将该列表添加到结果集中。如果临时列表中有任何内容，请清除该列表

循环完成后，对临时列表再进行一次检查，必要时将其添加到结果集中

首先是一个helper函数，通过允许用户传入逗号分隔值的单个条目，从用户处获取数字列表：

private static List<int> GetListOfNumbers()
{
    Console.Write("Enter a comma-separated list of numbers: ");

    return Console.ReadLine()
        .Split(',')
        .Where(item => item.Trim().All(char.IsNumber))
        .Select(int.Parse)
        .ToList();
}

private静态列表getListofNumber（）
{
Console.Write（“输入逗号分隔的数字列表：”）；
返回控制台。ReadLine（）
.Split（“，”）
.Where（item=>item.Trim（）.All（char.IsNumber））
.Select（int.Parse）
.ToList（）；
}

然后使用代码查找偶数集：

static void Main(string[] args)
{
    var numbers = GetListOfNumbers();
    var results = new List<List<int>>();
    var currentSet = new List<int>();

    foreach (var number in numbers)
    {
        if (number % 2 == 0)
        {
            currentSet.Add(number);
        }
        else
        {
            if (currentSet.Count > 1)
            {
                results.Add(currentSet);
            }

            currentSet = new List<int>();
        }
    }

    if (currentSet.Count > 1)
    {
        results.Add(currentSet.ToList());
    }

    Console.WriteLine("Results:");
    foreach (var setOfNumbers in results)
    {
        Console.WriteLine(string.Join(",", setOfNumbers));
    }

    Console.ReadLine();
}

static void Main（字符串[]args）
{
var numbers=GetListOfNumbers（）；
var results=新列表（）；
var currentSet=新列表（）；
foreach（数值中的变量编号）
{
如果（数字%2==0）
{
currentSet.Add（数字）；
}
其他的
{
如果（currentSet.Count>1）
{
结果。添加（currentSet）；
}
currentSet=新列表（）；
}
}
如果（currentSet.Count>1）
{
results.Add（currentSet.ToList（））；
}
Console.WriteLine（“结果：”）；
foreach（结果中的var SetOfNumber）
{
WriteLine（string.Join（“，”，setOfNumber））；
}
Console.ReadLine（）；
}

输出

---

一种方法是循环数字，如果数字可以被2整除，则将其添加到临时列表中。如果不能被2整除，则检查临时列表中是否有多个项目，以及是否将该列表添加到结果集中。如果临时列表中有任何内容，则清除临时列表

循环完成后，对临时列表再进行一次检查，必要时将其添加到结果集中

首先是一个helper函数，通过允许用户传入逗号分隔值的单个条目，从用户处获取数字列表：

private static List<int> GetListOfNumbers()
{
    Console.Write("Enter a comma-separated list of numbers: ");

    return Console.ReadLine()
        .Split(',')
        .Where(item => item.Trim().All(char.IsNumber))
        .Select(int.Parse)
        .ToList();
}

private静态列表getListofNumber（）
{
Console.Write（“输入逗号分隔的数字列表：”）；
返回控制台。ReadLine（）
.Split（“，”）
.Where（item=>item.Trim（）.All（char.IsNumber））
.Select（int.Parse）
.ToList（）；
}

然后使用代码查找偶数集：

static void Main(string[] args)
{
    var numbers = GetListOfNumbers();
    var results = new List<List<int>>();
    var currentSet = new List<int>();

    foreach (var number in numbers)
    {
        if (number % 2 == 0)
        {
            currentSet.Add(number);
        }
        else
        {
            if (currentSet.Count > 1)
            {
                results.Add(currentSet);
            }

            currentSet = new List<int>();
        }
    }

    if (currentSet.Count > 1)
    {
        results.Add(currentSet.ToList());
    }

    Console.WriteLine("Results:");
    foreach (var setOfNumbers in results)
    {
        Console.WriteLine(string.Join(",", setOfNumbers));
    }

    Console.ReadLine();
}

static void Main（字符串[]args）
{
var numbers=GetListOfNumbers（）；
var results=新列表（）；
var currentSet=新列表（）；
foreach（数值中的变量编号）
{
如果（数字%2==0）
{
currentSet.Add（数字）；
}
其他的
{
如果（currentSet.Count>1）
{
结果。添加（currentSet）；
}
currentSet=新列表（）；
}
}
如果（currentSet.Count>1）
{
results.Add（currentSet.ToList（））；
}
Console.WriteLine（“结果：”）；
foreach（结果中的var SetOfNumber）
{
WriteLine（string.Join（“，”，setOfNumber））；
}
Console.ReadLine（）；
}

输出

---

这适用于内置LINQ操作符：

var numbers = new[] { 1, 2, 2, 2, 3, 4, 6, 4, 8, 9, 3, 2 };

var results = 
    numbers
        .Skip(1)
        .Aggregate(
            new[] { numbers.Take(1).ToList() }.ToList(),
            (a, n) =>
            {
                if (a.Last().Last() % 2 != n % 2)
                {
                    a.Add(new[] { n }.ToList());
                }
                else
                {
                    a.Last().Add(n);
                }
                return a;
            })
        .Where(x => x.Count > 1 && x.First() % 2 == 0)
        .ToList();

---

它提供了

2,2,2

和

4,6,4,8

这适用于内置LINQ操作符：

var numbers = new[] { 1, 2, 2, 2, 3, 4, 6, 4, 8, 9, 3, 2 };

var results = 
    numbers
        .Skip(1)
        .Aggregate(
            new[] { numbers.Take(1).ToList() }.ToList(),
            (a, n) =>
            {
                if (a.Last().Last() % 2 != n % 2)
                {
                    a.Add(new[] { n }.ToList());
                }
                else
                {
                    a.Last().Add(n);
                }
                return a;
            })
        .Where(x => x.Count > 1 && x.First() % 2 == 0)
        .ToList();

---

它给出了

2,2,2

和

4,6,4,8

输入

[1,2,2,3,4,6,4]时应返回的内容