由于大量输入的黑客等级超时而终止

Question

这段代码在Hackerrank上的一些大输入上显示“Terminated due to timeout”（因超时而终止）错误，但在其余情况下仍能正常工作。请帮助我改进此代码。

约翰·沃森在整数数组上执行一个称为右圆旋转的操作。执行一次右圆旋转操作后，数组将从 转换为 。

Watson多次执行此操作。为了测试Sherlock识别旋转数组中特定位置的当前元素的能力，Watson请求查询，其中每个查询由一个整数组成，您必须为此打印旋转数组中索引处的元素（即的值）。

输入格式

第一行分别包含空格分隔的整数、、和。第二行包含空格分隔的整数，其中每个整数描述数组元素（where）。随后的每一行都包含一个表示的整数。

约束条件

输出格式

对于每个查询，在新行上打印旋转数组索引处的元素值。

示例输入

3 2 3 1 2 3 0 1 2 采样输出

2 3 1

我的代码

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        int n,k,q,temp=0,c=0;
        Scanner sc=new Scanner(System.in);
        try{
        n=sc.nextInt();
        k=sc.nextInt();
        q=sc.nextInt();
        int[] arr=new int[n];
        int qrr[]=new int[q];
        for(int i=0;i<n;i++)
            arr[i]=sc.nextInt();
        while(sc.hasNext()){
            qrr[c++]=sc.nextInt();
        }
        for(int j=1;j<=k;j++){
        temp=arr[n-1];
        for(int i=n-2;i>=0;i--){
            arr[i+1]=arr[i];
        }
        arr[0]=temp;
        }
        for(int i=0;i<q;i++){
            System.out.println(arr[qrr[i]]);
        }
    }
    catch(Exception ae){
        System.out.println(ae.getMessage());
    }
}
}

Answer 1

import java.io.*;
import java.util.*;

public class Solution {

    public static int m,n,k,q,i=0,c=0;
    public static int errorflag = 0;
    public static int array[];
    public static int rotated[];
    public static Scanner in = new Scanner(System.in);

    public static int[] getArray(int n){
        array = new int[n];
        for(i=0;i<n;i++){
            array[i] = in.nextInt();
        }       
        return(array);
    }

    public static int[] rotate(int[] original){
        int[] rotated = new int[original.length];
        for(i=0;i<original.length;i++){
            rotated[(i+k)%original.length] = original[i];
        }
        return(rotated);
    }

上面的函数工作在最坏的情况下O（n）复杂度。基本上，您正在做的是为元素分配一个新索引，这样它们就可以右旋转或递增k，溢出由模运算处理。

    public static void main(String[] args) {
        n = in.nextInt();
        k = in.nextInt();
        q = in.nextInt();
        array = getArray(n);

        int m[] = new int[q];
        for(i=0;i<m.length;i++){
            m[i] = in.nextInt();
        }
        rotated = rotate(array);
        for(i=0;i<m.length;i++){
            System.out.println(rotated[m[i]]);
        }


    }
}