C#从数组创建非相邻子集

我想从数组中创建一个子集

array=[-2,1,3，-4,5]

我想要下面这样的子集

[2,3,5][2,3][2，-4][2,5][1，-4][1,5][3,5]

    -before the elements should be skipped one element
    -2,3,5
     1 -4
     3.5
    -then for each element, one neighbor should be skipped and the others taken one by  one, forming pairs (without repeating the above)
    -2,3
    -2, -4
    -2.5
     1, -4 (do not take above have)
     3.5 ((we do not have above)
    -1.5

     //This is my code.
    static void Main(string[] args)
    {
        int[] kume = { -3, 4, 5, 6, 7};
        String[] altkume = new string[10];
        String s = "";
        for(int m = 0; m<7; m++)
        {
            int b = m;
            s += "[";
            for (int j = 0; j < kume.Length; j += 2)
            {                    
                if ((b & 1) == 0)
                {
                    s += kume[j].ToString() + ",";
                }
                b = b >> 1;                      
            }
            s += "]" + "\n";
            altkume[m] = s;

        }


        for(int i = 0; i<altkume.Length; i++)
        {


            Console.WriteLine(altkume[i]);
        }

        Console.ReadKey();
    }
Output: 
[-3,5,7,]
[5,7,]
[-3,7,]
[7,]
[-3,5,]
[5,]
[-3,]

-应跳过元素之前的一个元素
-2,3,5
1 -4
3.5
-然后，对于每个元素，应跳过一个相邻元素，并逐个选取其他元素，形成成对（无需重复上述内容）
-2,3
-2, -4
-2.5
1，-4（不带上述内容）
3.5（（我们没有上述信息）
-1.5
//这是我的密码。
静态void Main（字符串[]参数）
{
int[]kume={-3,4,5,6,7}；
字符串[]altkume=新字符串[10]；
字符串s=“”；
对于（int m=0；m>1；
}
s+=“]”+“\n”；
altkume[m]=s；
}
对于（int i=0；i我做了一个方便的扩展，它将返回您所寻求的输出：

public static class Extensions
{
    public static IEnumerable<List<T>> GetNonAdjacentSubsets<T>
    (
        this IEnumerable<T> source, // the collection we are evaluating
        int min_distance,           // minimum gap between numbers
        List<T> subset = null       // stores the progress of the subset we are evaluating
    )
    {
        for (int i = 0; i < source.Count(); i++)
        {
            var new_subset = new List<T>(subset ?? Enumerable.Empty<T>())
            {
                source.ElementAt(i)
            };

            if (new_subset.Count > 1) //return subsets of more than one element
                yield return new_subset;

            if (source.Count() < 2) //end of list reached
                yield break;

            foreach (var ss in source.Skip(i + min_distance).GetNonAdjacentSubsets(min_distance, new_subset))
                yield return ss;
        }
    }
}

公共静态类扩展
{
公共静态IEnumerable GetNonAdjacentSubset
(
此IEnumerable源代码//我们正在评估的集合
int min_距离，//数字之间的最小间距
List subset=null//存储我们正在评估的子集的进度
)
{
对于（int i=0；i1）//返回多个元素的子集
产生新的_子集；
if（source.Count（）<2）//到达列表末尾
屈服断裂；
foreach（source.Skip（i+min_距离）中的var ss.getNonAdjacentSubset（min_距离，new_子集））
收益率；
}
}
}

用法：

var arr = new int[] { -2, 1, 3, -4, 5 };
var subsets = new List<List<int>>(arr.GetNonAdjacentSubsets(2));

var arr=newint[]{-2,1,3，-4,5}；
var子集=新列表（arr.getNonajacentSubsets（2））；

输出：

-2,3

-2,3,5

-2，-4

-2,5

1，-4

1,5

3,5

我已经做了一个方便的扩展，它将返回您寻求的输出：

public static class Extensions
{
    public static IEnumerable<List<T>> GetNonAdjacentSubsets<T>
    (
        this IEnumerable<T> source, // the collection we are evaluating
        int min_distance,           // minimum gap between numbers
        List<T> subset = null       // stores the progress of the subset we are evaluating
    )
    {
        for (int i = 0; i < source.Count(); i++)
        {
            var new_subset = new List<T>(subset ?? Enumerable.Empty<T>())
            {
                source.ElementAt(i)
            };

            if (new_subset.Count > 1) //return subsets of more than one element
                yield return new_subset;

            if (source.Count() < 2) //end of list reached
                yield break;

            foreach (var ss in source.Skip(i + min_distance).GetNonAdjacentSubsets(min_distance, new_subset))
                yield return ss;
        }
    }
}

公共静态类扩展
{
公共静态IEnumerable GetNonAdjacentSubset
(
此IEnumerable源代码//我们正在评估的集合
int min_距离，//数字之间的最小间距
List subset=null//存储我们正在评估的子集的进度
)
{
对于（int i=0；i1）//返回多个元素的子集
产生新的_子集；
if（source.Count（）<2）//到达列表末尾
屈服断裂；
foreach（source.Skip（i+min_距离）中的var ss.getNonAdjacentSubset（min_距离，new_子集））
收益率；
}
}
}

用法：

var arr = new int[] { -2, 1, 3, -4, 5 };
var subsets = new List<List<int>>(arr.GetNonAdjacentSubsets(2));

var arr=newint[]{-2,1,3，-4,5}；
var子集=新列表（arr.getNonajacentSubsets（2））；

输出：

-2,3

-2,3,5

-2，-4

-2,5

1，-4

1,5

3,5

“我想创建一个子集，但该子集不应在近距离内不连续。”嗯，什么？我不理解你的问题。请提供一些示例数据和你期望的输出。我不完全确定你所说的“但该子集不应在近距离内不连续”是什么意思，但在文章的末尾，您的问题似乎只是输出格式问题？在这种情况下，请将子集创建为int数组，并使用
String.Join（“，”，array）
在元素之间放置分隔符。我不知道您打算如何将此数组
array=[-2,1,3，-4,5]
转换为
[-2,3,5][-2,3][-4][2,5][1，-4][1,5][3,5]
这里的逻辑是什么？我希望它[-2,1]应该是或[1,3]或[-4,5]或[3，-4]因为不应该并排。你能用纯文本说出你的规则吗？就像智力测试中的测验一样，从你的样本中找到规则…应该是这样/而不是那样。如果你不能向我们描述任务，你也不能向计算机描述它。“我想创建一个子集，但子集不应在近距离内不连续。”嗯，什么？我不理解你的问题。请提供一些样本数据和你期望的输出。我不完全确定你所说的“但子集不应在近距离内不连续”是什么意思“，但在文章的结尾，您的问题似乎只是输出格式问题？在这种情况下，请将子集创建为int数组，并使用
String.Join（“，”，array）
在元素之间放置分隔符。我不知道您打算如何将此数组
array=[-2,1,3，-4,5]
转换为
[-2,3,5][-2,3][-4][2,5][1，-4][1,5][3,5]
这里的逻辑是什么？我希望它[-2,1]应该是或[1,3]或[-4,5]或[3，-4]因为不应该并排。你能用纯文本说出你的规则吗。这就像智力测验中的测验，从你的样本中找到规则…应该是这样/而不是那样。如果你不能向我们描述任务，你也不能向计算机描述它。非常感谢，我想我知道代码了。但我不明白我怎么能做到使用并显示。@Ozze，如果你还有问题，请告诉我。我真的很感激。非常感谢你，我想我已经获得了代码。但是我不明白如何使用和显示。@Ozze，如果你还有问题，请告诉我。我真的很感激。