compare every number in arrary in groups of 6

Question

hello guys I'm doing a little self learning and i have come across of problem that seems to have stumped me for the time being i figuere someone here im sure has already encountered something similar to this in the past. i have an array list of 1-10

public List<int> ValueArrays = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

im trying to get the sum of every number groups of 6 but i'm just stuck. for example i want

[1,2,3,4,5,6]
[1,3,4,5,6,7]
[1,4,5,6,7,8] etc...

i have written some code but im just stumbling on my feet here.

private void runbtn_Click(object sender, EventArgs e)
        {
            int thisTotal;
            //Object ListOfNumbersToCompareTo = new Object[];
            List<int> fiveEl = new List<int> { }; //= ValueArrays.GetRange(1, 5);//target a group of 5
            List<int> test2 = new List<int> { };
            //test2.AddRange(fiveEl);

            //thisTotal = SumRange(fiveEl);
             int groupSize = 5;





            for (int i = 0; i < ValueArrays.Count; i++)
            {

                fiveEl=ValueArrays.GetRange(i+1, 5);
                currentNum = ValueArrays[i];
                fiveEl.Add(currentNum);


                for (int x = 0; x < 1; x++)
                {
                    thisTotal = SumRange(fiveEl);

                    //fiveEl = ValueArrays.GetRange(x, groupSize);
                    //fiveEl.Add(currentNum);
                    //fiveEl.RemoveRange(x, groupSize); ;
                }




            }
}

can someone give me a code snippet or point me in the right direction? Thanks in advance.

Answer 1

Here is a quick n dirty solution with "hard-coded" fact, that you choose groups of six. For a generic solution, you need recursion and generating all combinations (you can start with Algorithm to return all combinations of k elements from n )

var numbersList = new[] { 1, 2, 3, 4, 5, 6 ,7,8,9,10};

        var groupsBySix = from i1 in numbersList
                        from i2 in numbersList.Where( i => i>i1)
                        from i3 in numbersList.Where(i => i > i2)
                        from i4 in numbersList.Where(i => i > i3)
                        from i5 in numbersList.Where(i => i > i4)
                        from i6 in numbersList.Where(i => i > i5)
                        select new []{ i1, i2, i3, i4, i5, i6 };


        var cachedGroups = groupsBySix.ToList();  // 210 groups of int arrays. Starts with [1..6] and ends with [5..10]
        var sums = groupsBySix.Select(list => list.Sum());

Answer 2

Personally I’d write it like this:

var values = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var groupsOfSix = values.Subsequences().Where(s => s.Count() == 6);

And then of course you can use .Sum() on each of the subsequences thus generated.

This uses an extension method I wrote some time ago, which generates all subsequences of an IEnumerable<T>. This solution is not the most speedy possible, but by golly does it make the code easy to read and obviously correct, and on an input list of just 10 elements it’s way fast enough.

Here’s the Subsequences function:

/// <summary>
/// Returns all subsequences of the input <see cref="IEnumerable&lt;T&gt;"/>.
/// </summary>
/// <param name="source">The sequence of items to generate subsequences of.</param>
/// <returns>A collection containing all subsequences of the input <see cref="IEnumerable&lt;T&gt;"/>.</returns>
public static IEnumerable<IEnumerable<T>> Subsequences<T>(this IEnumerable<T> source)
{
    if (source == null)
        throw new ArgumentNullException("source");
    // Ensure that the source IEnumerable is evaluated only once
    return subsequences(source.ToArray());
}

private static IEnumerable<IEnumerable<T>> subsequences<T>(IEnumerable<T> source)
{
    if (source.Any())
    {
        foreach (var comb in subsequences(source.Skip(1)))
        {
            yield return comb;
            yield return source.Take(1).Concat(comb);
        }
    }
    else
    {
        yield return Enumerable.Empty<T>();
    }
}