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

来自你的评论。

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

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

编辑为操作错误值 我怀疑你可能没有正确复制数组：

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 3

试试这个：

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 4

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 5

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

左右只在每次迭代中使用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（UNSAFE）

unsafe - fixed - pointers

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

C＃，一维包装数组

8 个答案:

选项1

选项2

选项3

选项4（UNSAFE）