C#，一维包装数组

Question

我有一个一维数组，我需要根据每个单元格的相邻单元格对其进行操作。

例如：

要在第一个单元格上运行操作，我需要访问最后一个单元格和第二个单元格。

第二个单元格，我需要访问第一个单元格和第三个单元格。

最后一个单元格，我需要访问第一个单元格和最后一个单元格之前的那个。

到目前为止我的代码是：

public static int[] firstRule(int[] numberArray)
{
    for (int i = 0; i < numberArray.Length; i++)
    {
        if (numberArray[numberArray.Length - 1 - i] == numberArray[i] + 1 
            && numberArray[i + 1] == numberArray[i] + 1)
        {
            numberArray[i] = numberArray[i] - 1;
        }
    }
    return numberArray;
}

但我的方法的问题在于它只适用于第一个单元格，因为它会正确地占用最后一个单元格和第二个单元格，但在那之后，一切都会崩溃。我不喜欢没有大量代码的帖子，但我不知道如何跟进。

我正在努力实现以下目标：

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

Answer 1

保持简单并使用变量来计算左右单元格索引。在你的 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;
}

Answer 2

试试这个：

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] 
}

% 是 mod operator。 % len 允许您停留在 0..len-1 范围内，因此您可以像遍历数组一样遍历数组，就好像它已变为“循环”

Answer 3

来自您的 cmets。

这些值是从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 测试。

Answer 4

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);
}

Answer 5

public static void firstRule(int[] numberArray)
{
    for (int i = 0; i < numberArray.Length; i++)
    {
        int? prevElement = i == 0 
            ? numberArray[numberArray.Length-1]
            : numberArray[i - 1];

        int? nextElement = i == numberArray.Length -1
            ? numberArray[0]
            : numberArray[i + 1];

        Console.WriteLine(
            String.Format("Prev: {0}; Current: {1}; Next: {2}",
                prevElement,
                numberArray[i],
                nextElement)
            );
    }
}

然后调用firstRule(new int[]{ 1, 2, 3 }); 打印：

Prev: 3; Current: 1; Next: 2
Prev: 1; Current: 2; Next: 3
Prev: 2; Current: 3; Next: 1

Answer 6

选项 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

left 和 right 在每次迭代中只使用 1 次.. 那么为什么还要将它们分配给一个变量呢？？？...

    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;
    }  

Answer 7

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

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;
}`

Answer 8

这样的事情应该可以工作。它为每个循环中的操作确定适当的单元格并执行操作。您没有说明该操作是什么，因此您需要填写 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);
    }  
}