Question

我正在尝试编写一个接受数组长度的函数，并返回＆＃34; ripple out＆＃34;阵列。

例如：
rippleOut(3)会返回[0,1,0]
rippleOut(6)会返回[0,1,2,2,1,0]

这是我到目前为止所得到的。它有效，但我确信有一种更有效的方法：

public int[] rippleOut(int size){
    int[] output = new int[size];
    int middle = 0;
    boolean even = false;

    if(size%2==0){
        middle = (size/2-1);
        even = true;
    } else {
        middle = (int)Math.floor(size/2);
    }

    for(int i = middle; i>0; i--){
        output[i] = middle - (middle-i);
        if (even){
            output[middle+(middle - i+1)] = middle - (middle-i);
        } else {
            output[middle+(middle - i)] = middle - (middle-i);
        }

    }

    return output;
}

Answer 1

至少有一种更简单的方式来编写它，我没有比较性能：

public static int[] rippleOut(int x) {
    int[] r = new int[x];
    // everything except the middle of an odd array
    for (int i = 0; i < (x >> 1); i++) {
        r[i] = i;
        r[x - i - 1] = i;
    }
    // fix middle
    if ((x & 1) == 1)
         r[x >> 1] = x >> 1;
    return r;
}

如果您对此更熟悉，请随意用“正常”数学替换该bitmath，它不是解决方案的组成部分。我只是喜欢这样，就是这样。

Answer 2

这是Java 8版本：

int size = 11;
int odd = (size % 2 == 0) ? 0 : 1;
int mid = (size / 2) - 1;
int[] output = IntStream.range(0, size - 1)
         .map(i -> (i > mid) ? mid + (mid - i) + odd : i).toArray();

IntStream.of(output).forEach(System.out::print);

在Java中抛出整数数组优化

2 个答案: