C# 使数组像圆形一样工作

我不太清楚怎么做

伪代码：

array1 = {"a","b", "c", "d", "e","f", "g","h", "i","j"} //there might be more values.
take c
loop =>c+3 =f
       f+3 =i
       i+3 =b
       b+3 =e
......
end loop

我需要将这个

array1

作为一个圆圈来处理，并找到添加了3个字母的字母（f、I、b、e等）。

您需要自己编写“查找添加了3个字母的字母”功能，如：

new_index = (current_index+3)%length_of_array

您需要自己编写“查找字母添加3”功能，如：

new_index = (current_index+3)%length_of_array

使用mod（

%

），则

索引可以是任何正值，它将环绕：

int index;
array1[index % array1.Length]

使用mod（
%
），则
索引可以是任何正值，它将环绕：

int index;
array1[index % array1.Length]

正如另一个答案所说，
%
操作符是实现它的关键。下面是实现

private string[] strings = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" };

private IEnumerable<string> GetStringWrapped(int position)
{
    int current = position - 1;
    while (true)
    {
        yield return strings[current];
        current += position;
        current %= strings.Length;
    }
}

注意
Take
很重要，否则您的方法将永远不会结束，它将永远循环。
正如其他答案所说，
%
运算符是实现它的关键。下面是实现

private string[] strings = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" };

private IEnumerable<string> GetStringWrapped(int position)
{
    int current = position - 1;
    while (true)
    {
        yield return strings[current];
        current += position;
        current %= strings.Length;
    }
}

注意
Take
非常重要，否则您的方法将永远不会结束，它将永远循环。
我们可以使用
%
操作符计算数组中的循环索引，然后我们可以在类中抽象它

class CircularList<T> : List<T>
        {
            public new T this[int index]
            {
                get { return base[index%Count]; }
                set { base[index%Count] = value; }
            }

            public T this[T item, int distance]
            {
                get
                {
                    var index = IndexOf(item);
                    return this[index + distance];
                }
                set
                {
                    var index = IndexOf(item);
                    this[index + distance] = value;
                }
            }
        }

类循环列表：列表
{
公共新T此[int索引]
{
获取{返回基[索引%Count]；}
集合{base[索引%Count]=value；}
}
公共T此[T项，整数距离]
{
收到
{
var指数=指数（项目）；
返回此[索引+距离]；
}
设置
{
var指数=指数（项目）；
此[索引+距离]=值；
}
}
}

用法：

    var arr = new CircularList<string> { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" };
    var b = arr[8 + 2];
    var b2 = arr["i", 2];

var arr=新的循环列表{“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”、“i”、“j”}；
var b=arr[8+2]；
var b2=arr[“i”，2]；
我们可以使用
%
操作符来计算数组中的循环索引，然后我们可以在类中抽象它

class CircularList<T> : List<T>
        {
            public new T this[int index]
            {
                get { return base[index%Count]; }
                set { base[index%Count] = value; }
            }

            public T this[T item, int distance]
            {
                get
                {
                    var index = IndexOf(item);
                    return this[index + distance];
                }
                set
                {
                    var index = IndexOf(item);
                    this[index + distance] = value;
                }
            }
        }

类循环列表：列表
{
公共新T此[int索引]
{
获取{返回基[索引%Count]；}
集合{base[索引%Count]=value；}
}
公共T此[T项，整数距离]
{
收到
{
var指数=指数（项目）；
返回此[索引+距离]；
}
设置
{
var指数=指数（项目）；
此[索引+距离]=值；
}
}
}

用法：

    var arr = new CircularList<string> { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j" };
    var b = arr[8 + 2];
    var b2 = arr["i", 2];

var arr=新的循环列表{“a”、“b”、“c”、“d”、“e”、“f”、“g”、“h”、“i”、“j”}；
var b=arr[8+2]；
var b2=arr[“i”，2]；
我还是不清楚。。。。。。。。乘以数组长度有什么帮助？你能把它弄清楚一点吗。实际上，“i”是8个元素。“b”是1个元素。(8+3)%10=1. 这样就给了您正确的位置。（您知道%操作和数组索引从0开始，对）是的，现在。。。我理解。。。一开始我误解了。我还是不清楚。。。。。。。。乘以数组长度有什么帮助？你能把它弄清楚一点吗。实际上，“i”是8个元素。“b”是1个元素。(8+3)%10=1. 这样就给了您正确的位置。（您知道%操作和数组索引从0开始，对）是的，现在。。。我理解。。。一开始我就误解了。我从来没有见过任何代码，如<代码>返回<代码>中间，就像你做的代码>收益率< /代码> @ gILID，它们被称为非常强大的语言特征。我从来没有见过任何代码有<代码>返回<代码>中间，就像你做的代码>收益率< /代码> @ gILID，它们被称为非常强大的语言。特色