C#，一维包装数组

保持简单，使用变量计算左右单元格索引。在for循环中，您可以这样做。。。

var leftCell = i - 1;
if (leftCell < 0)
{
    leftCell = numberArray.Length - 1; // Wrap around to the end...
}
var rightCell = i + 1;
if (rightCell > numberArray.Length - 1)
{
    rightCell = 0;  // Wrap back around to the beginning...
}

// Now you can update your original code to use these computed indices...
if (numberArray[leftCell] == numberArray[i] + 1 
    && numberArray[rightCell] == numberArray[i] + 1)
{
    numberArray[i] = numberArray[i] - 1;
}

试试这个：

var len = numberArray.Length;
for (int i = 0; i < len; i++)
{
    var leftIndex = (i - 1 + len) % len;
    var rightIndex = (i + 1) % len;
    // do your stuff with numberArray[leftIndex] and numberArray[rightIndex] 
}

%是模运算符。% len允许您保持在0.len-1的范围内，所以您可以遍历数组，就好像它变成了"循环"一样

来自您的评论。

这些值是0到3之间的数字。如果前面的单元格和后面的单元格都是相同的数字，我想将其更改为x+1
例如：假设我有1 0 1 2 2。我想将0更改为1。由于相邻小区均为0。

我会创建一个新数组，用现有数组的值填充它，然后根据现有数组中值的结果更改新数组的值。

编辑为Op得到错误的值 我怀疑您可能没有正确复制阵列：

Existing Array array // The array you are passing in as parameter.

声明一个新的空数组：

int[] newArray;
int size = array.length;
for(int i =1; i<size-1;i++){
    if(array[i-1]==array[i+1])){
        newArray[i]=array[i]+1;
    }
    else{
        newArray[i]=array[i];
    }
}
if(array[size-1]==array[0]){
    newArray[size]= array[size]+1;
}
else{
        newArray[i]=array[i];
    }
if(array [size]==array[1]){
    newArray[0]= array[0]+1;
}
else{
        newArray[i]=array[i];
    }

如果这个数字有限制，并且在2之后它变为零，那么只需对此进行简单的if测试

int[] arr = new int[] { 1, 2, 3, 4, 5 };
var triples = arr.Select((n, i) =>
{
    if (i == 0)
        return Tuple.Create(arr[arr.Length - 1], arr[0], arr[1]);
    else if (i == arr.Length - 1)
        return Tuple.Create(arr[i - 1], arr[i], arr[0]);
    else
        return Tuple.Create(arr[i - 1], arr[i], arr[i + 1]);
});
foreach (var triple in triples)
{
    Console.WriteLine(triple.Item1 + " " + triple.Item2 + " " + triple.Item3);
}

选项1

无论如何分配

    public static int[] firstRule(int[] numberArray)
    {
        int left,right;
        for (int i = 0, max = numberArray.Length - 1; i <= max; i++)
        {                
            left = (i == 0) ? max : i - 1; 
            right = (i == max) ? 0 : i + 1;
            numberArray[i] = (numberArray[left] == numberArray[right]) ? numberArray[i] + 1 : numberArray[i]; //always peforms an assignment;
        }
        return numberArray;
    }

选项2

有条件地分配

    public static int[] secondRule(int[] numberArray)
    {
        int left,right;
        for (int i = 0, max = numberArray.Length - 1; i <= max; i++)
        {   
            left = (i == 0) ? max : i - 1; 
            right = (i == max) ? 0 : i + 1;
            if (numberArray[left] == numberArray[right])
            {
               numberArray[i]++;
            }
        }
        return numberArray;
    }

选项3

左和右在每次迭代中只使用一次。。那么，为什么要麻烦把它们分配给一个变量呢？？？。。。

    public static int[] thirdRule(int[] numberArray)
    {            
        for (int i = 0, max = numberArray.Length - 1; i <= max; i++)
        {                
            if (numberArray[(i == 0) ? max : i - 1] == numberArray[(i == max) ? 0 : i + 1])
            {
                numberArray[i]++; // what happens if numberArray[i] is 3, should it become 4 or 0?
            }
        }
        return numberArray;
    }

选项4(不安全(

不安全的固定指针

    public static int[] fourthRule(int[] numberArray)
    {
        unsafe {
            int* pointer, right, left; 
            for (int i = 0, max = numberArray.Length - 1; i <= max; i++)
            {
                fixed (int* p1 = &numberArray[0], p2 = &numberArray[i], p3 = &numberArray[max])
                {
                    pointer = p2;
                    if (i == 0)
                    {
                        left = p3;
                        right = pointer;
                        right++;
                    }
                    else if (i == max)
                    {
                        left = pointer;
                        left--;
                        right = p1;
                    } 
                    else
                    {
                        left = pointer;
                        left--;
                        right = pointer;
                        right++;
                    }
                    if (*right == *left) {
                        *pointer = *pointer + 1;
                    }
                }
            }
        }
        return numberArray;
    }  

最近我自己遇到了这个问题，发现这是一个可靠的方法。`

int length = numberArray.Length; 
for (int i = 0; i < length; ++i)
{
    int iMinus = (((i - 1) % length) + length) % length;
    int iPlus = (((i + 1) % length) + length) % length;
}`

这样的东西应该可以工作。它为每个循环中的操作确定合适的单元格，并执行该操作。您没有说明该操作是什么，因此需要填写DoYourOperation方法。

public static int[] processArray(int[] numberArray)
{
    for (int i= 0; i < numberArray.Length; i++)
    {
        int firstCell;
        int secondCell;
        //Check if first cell
        if(i == 0)
        { 
            firstCell = numberArray[numberArray.length-1]; //Last cell
            secondCell = numberArray[i++]; //Next cell
        } 
        //Check if last cell
        else if(i == numberArray.Length - 1)
        { 
            firstCell = numberArray[i--]; //Cell before last one
            secondCell = numberArray[0]; //First cell
        }  
        else
        {
            firstCell = numberArray[i--];
            secondCell = numberArray[i++];
        }
        DoYourOperation(firstCell, secondCell);
    }  
}