首页 文章

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

提问于
浏览 次
-1

此代码在Hackerrank上的某些大型输入上显示“由于超时而终止”错误，但在其他情况下工作正常 . 请帮我改进这段代码 .

John Watson在一个整数数组上执行一个称为右旋转的操作 . 执行一次右旋转操作后，数组从变换为 .

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

输入格式

第一行包含空格分隔的整数,,和 . 第二行包含空格分隔的整数，其中每个整数描述数组元素（where） . 每个后续行包含一个表示的整数 .

约束

输出格式

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

样本输入

3 2 3 1 2 3 0 1 2样品输出

2 3 1

MY CODE

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());
    }
}
}
java arrays

1 回答

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


    }
}
    回复于

相关问题