Java 旋转数组并查找最大元素的索引

我正在做一个程序，在这个程序中，我需要找出一个数组的索引位置，在数组左旋转后，这个数组中的最大值就是这个数组的索引位置

例如：

如果数组是{5,7,1,8,2}。此数组的最大值为8。如果我旋转数组2次，那么结果是1,8,2,5,7。那么max元素8的索引位置是1

如果我将数组{5,7,1,8,2}旋转6次，那么数组将变成7,1,8,2,5。现在8的指数是2

我的程序将数组和旋转次数作为输入，并在旋转数组时返回一个包含max元素索引位置的数组

int[] rotate(int[] array, int[] rotate) {
    int[] result = new int[rotate.length];
    int index = 0;
    int large = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > large) {
            large = array[i];
            index = i;
        }
    }
    for (int i = 0; i < rotate.length; i++) {
        int r = rotate[i];
        if (index - r < 0) {
            if (r > array.length) {
                r = r % array.length;
                result[i] = index - r;
            } else {
                result[i] = index - (index - r);
            }
        } else {
            result[i] = index - r;
        }
    }
    return result;
}

int[]旋转（int[]数组，int[]旋转）{
int[]结果=新int[rotate.length]；
int指数=0；
int大=数组[0]；
for（int i=1；i大）{
大=数组[i]；
指数=i；
}
}
对于（int i=0；iarray.length）{
r=r%array.length；
结果[i]=指数-r；
}否则{
结果[i]=指数-（指数-r）；
}
}否则{
结果[i]=指数-r；
}
}
返回结果；
}

该程序在某些情况下工作，但在其他我无法找到的测试用例中失败

你能帮我解释一下我在代码中犯了什么错误吗

获取最大数的索引，代码就可以工作

int index = 0;
int large = array[0];
for (int i = 1; i < array.length; i++) {
    if (array[i] > large) {
        large = array[i];
        index = i;
    }
}

---

您可以使用streams查找索引，然后通过每次旋转对其进行偏移：

int[] rotate(int[] array, int[] rotate) {
    int len = array.length;

    // find the index of the greatest element
    int index = IntStream.range(0, len)
            .reduce(Integer.MIN_VALUE, (a, b) -> array[a] > array[b] ? a : b);

    // offset the index by each rotation
    return Arrays.stream(rotate)
            .map(r -> (index + len + (r % len)) % len)
            .toArray();
}

---

您可以使用以下函数。看到它工作了吗

---

什么是投入和预期产出？因为我认为它可以更优化一点（因此，如果测试用例由于超时而失败，那么可以利用它），您实际上必须旋转数组还是只找到正确的索引（前者可以不用（物理地）完成）旋转？@zlakad，我只需要找到指示符号than，我没有遵循逻辑…如果我旋转数组2次…违反方法

int[]rotate（int[]数组，int[]rotate）

声明。应该是

int[]rotate（int[]数组，int[]rotate）

？我将集中精力编写带有此签名的方法

int findIndexOfMaxAfterRotate（int[]arr，int noOfRotation）

你能帮我理解这行吗

int r=（index-（rotate[I]%len）%len）；result[I]=（r>=0）？r:（len+r）；

line

int r=（index-（rotate[I]%len len）；

应该是

int r=（index-（rotate[i]%len））；

（虽然两者产生相同的结果）。我已经更新了答案。行

int r=（index-（rotate[i]%len））；

，在

部分（rotate[i]%len）

我试图计算实际的旋转次数，例如，如果数组中有5个元素，那么我将其旋转3、8或13、18等等……次，它将产生相同的结果。在部分

（index-（rotate[I]%len））

我试图获得最大元素的索引（

index

保留原始数组中最大元素的索引）但是这个结果可能是-ve，例如数组{5,8,1,7,2}旋转1圈的情况。所以这在

结果[i]=（r>=0）？r：（len+r）；

行中被纠正。希望现在清楚：）

Arrays.sort(array);
System.out.println(array);
//or
Collections.shuffle(Arrays.asList(array));
System.out.println(array);

int[] rotate(int[] array, int[] rotate) {
    int len = array.length;

    // find the index of the greatest element
    int index = IntStream.range(0, len)
            .reduce(Integer.MIN_VALUE, (a, b) -> array[a] > array[b] ? a : b);

    // offset the index by each rotation
    return Arrays.stream(rotate)
            .map(r -> (index + len + (r % len)) % len)
            .toArray();
}

int[] rotate(int[] array, int[] rotate) 
{
    int[] result = new int[rotate.length];
    int index = 0;
    int large = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > large) {
            large = array[i];
            index = i;
        }
    }
    int len = array.length;
    for (int i = 0; i < rotate.length; i++) {
         int r = (index - (rotate[i]%len));
         result[i] = (r>=0) ? r : (len+r); 
    }
    return result;
}

class Test
{
    static int[] rotate(int[] array, int[] rotate) 
    {
        int[] result = new int[rotate.length];
        int index = 0;
        int large = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > large) {
                large = array[i];
                index = i;
            }
        }
        int len = array.length;
        for (int i = 0; i < rotate.length; i++) {
             int r = (index - (rotate[i]%len));
             result[i] = (r>=0) ? r : (len+r); 
        }
        return result;
    }

    public static void main (String[] args) throws java.lang.Exception
    {
        int nums[] = {5,7,1,8,2};
        int r[] = {2, 6, 5, 1, 2, 3, 4, 5, 0};

        int res[] = rotate(nums, r);

        for(int i=0; i<res.length; i++)
        {
            System.out.println(r[i] + " = "+ res[i]);
        }
    }
}

2 = 1
6 = 2
5 = 3
1 = 2
2 = 1
3 = 0
4 = 4
5 = 3
0 = 3