數組 - 求元素的鄰居？

Question

這個問題要求編寫靜態方法sumNeighbours，它將一個整數數組作為參數，並返回一個與原始數組具有相同元素數的數組，這樣新數組中的每個整數都是它的鄰居和它自身的總和。陣列。

例如

[10, 20, 30, 40]

將會

[30, 60, 90, 70]
30(10+20) 60(20+10+30) 90(30+20+40) 70(40+30)

謝謝。 這是我已經完成的代碼並且它可以工作，但僅適用於某些情況，而不是所有情況。 有人能推薦一種更有效的方法嗎？ 沒有硬編碼所有那些if和其他的特定情況。

public static int[] sumNeighbours(int[] values) {
int[] list = new int[values.length];
for (int i=0; i<values.length; i++) {
    if (values.length > 1) {
        if (values[i] == values[0]) {
            list[i] = values[i] + values[i+1];
        }
        else if (values[i] == values[values.length-1]) {
            list[i] = values[i] + values[i-1];
        }
        else {
            list[i] = values[i] + values[i-1] + values[i+1];
        }
    }
    else {
        list [i] = values[i];
    }
}
return list;
}   

Answer 1

首先：您的輸入可能為null，因此首先進行null檢查，我猜在這種情況下返回null。

第二：創建相同大小的數組后，需要迭代輸入，並為每個索引檢查兩件事：

1. 如果index小於（length-1），則在右側添加元素
2. 如果索引大於0，則在左側添加元素
3. 始終在當前索引中添加元素

完成了嗎？

Answer 2

不要使用值來檢查元素是否是最后一個，使用索引並且還具有nullptr檢查。 您的代碼將因[30,30,30]這樣的情況而失敗

    public static int[] sumNeighbours(int[] values) {
        if (null == values)
            return null;
        int[] list = new int[values.length];
        for (int i=0; i<values.length; i++) {
            if (values.length > 1) {
                if (i == 0) {
                    list[i] = values[i] + values[i+1];
                }
                else if (i == values.length-1) {
                    list[i] = values[i] + values[i-1];
                }
                else {
                    list[i] = values[i] + values[i-1] + values[i+1];
                }
            }
            else {
                list [i] = values[i];
            }
        }
        return list;

    }

Answer 3

這是我已經完成的代碼並且它可以工作，但僅適用於某些情況，而不是所有情況

可能是因為你比較值而不是索引： if (values[i] == values[0])必須是if (i == 0)和if (values[i] == values[values.length-1])必須是if (i == values.length - 1) 。

使用較少代碼和空檢查的代碼段可能如下所示

public static int[] sumNeighbours(int[] input) {
    if (input == null) {
        return null;
    }

    int[] result = new int[input.length];
    for (int i = 0; i < input.length; i++) {
        int sum = input[i];

        if (i > 0) {
            sum += input[i - 1];
        }
        if (i < (input.length - 1)) {
            sum += input[i + 1];
        }

        result[i] = sum;
    }

    return result;
}

Answer 4

如果在循環中刪除if塊，效率更高：

public static int[] sumNeighbours(final int[] values) {

    if (null == values || 2 > values.length) {
        return values;
    }

    final int len = values.length;
    final int[] list = new int[len];

    list[0] = values[0] + values[1];
    list[len - 1] = values[len - 2] + values[len - 1];

    for (int i = 1; i < len - 2; i++) {
        list[i] = values[i - 1] + values[i] + values[i + 1];
    }

    return list;
}

邊緣上不需要匯總3數字。

Answer 5

看一下這個，

public static int[] sumNeighbours(int[] values) {
int[] list = new int[(values.length)];
for (int i=0; i<values.length; i++) {
 if (values.length > 1) { //To Check if there are more than one values
    if(i==0) //It will check if it is first element
    {
        list[i]=values[i]+values[i+1]; //Add First value and second value to place it in first location. As first location has only one Neighbor 

    }
    else if (i==(values.length-1)) //TO check If its last value
    {
        list[i]=values[i]+values[i-1]; //As Last Location has only one Neighbor
    }
    else
    {
         list[i]=values[i]+values[i-1]+values[i+1]; //For All intermediate locations
  }
}
}
return list;
}