Question

I have a list List A consisted of strings {"a", "b", "c", "d", "e"}.
My program runs in iterations and for each iteration I want to create a new list List B which is going to contain the same strings, but each of them should move to one position to the left. Here is the example of what the List B should look like in first three iterations:

1. iteration, the List B should be: listB = {"a", "b", "c", "d", "e"}
2. iteration, the List B should be: listB = {"b", "c", "d", "e", "a"}
3. iteration, the List B should be: listB = {"c", "d", "e", "a", "b"}
   and so on…

I have achieved the desired functionality with the following method:

private List<string> CalculateQueueOrder(List<string> listA, int iterationNum)
{
    int listACount = listA.Count;
    List<string> listB = new List<string>();

    for (int i = 0; i < listACount; i++)
    {
        for (int j = 0; j < listACount; j++)
        {
            int order = ((j - iterationNum) % listACount + 1);
            if (order == i)
            {
                string listItem = listA[j];
                listB.Add(listItem);
                break;
            }
        }
    }
    return listB;
}

However, there is an issue with this method. In time as the number of iterations increases, the j - iterationNum starts returning negative values, which makes modulus start returning negative values as well. The whole function fails. I need to make the modulus always return the positive value, like it does in Microsofot Excel (mod function).

Could you help me out fixing the formula for int order? Thanks.

Answer 1

I achieved this here: http://rextester.com/HXACA68585

Method is:

    private static IEnumerable<T> Cycle<T>(List<T> data, int num)
    {
        var start = num%data.Count;
        for(var i=0;i<data.Count;i++)
        {
            yield return data[(i+start)%data.Count];
        }
    }

Which you can stuff back into a new list if you wanted:

List<string> list = new List<string>(){"a", "b", "c", "d", "e"};
List<string> newList = new List<string>(Cycle(list,2)); // contains c, d, e, a, b

But to test your required results used this:

List<string> list = new List<string>(){"a", "b", "c", "d", "e"};
Dump(Cycle(list,0));
Dump(Cycle(list,1));
Dump(Cycle(list,2));
Dump(Cycle(list,3));
Dump(Cycle(list,4));
Dump(Cycle(list,5));
Dump(Cycle(list,6));

Output as follows:

a, b, c, d, e
b, c, d, e, a
c, d, e, a, b
d, e, a, b, c
e, a, b, c, d
a, b, c, d, e
b, c, d, e, a