阵列旋转 TLE（超出时间限制）

Question

我真的很困惑为什么我的 java 代码无法正常工作，它会在 Hacker Earth 上的 Code Monks 上提供 TLE。 这是1的链接

• 链接到问题第一个问题MONK AND ROTATION

import java.util.Scanner;
class TestClass {
    static int[] ar=new int[100001];
    public static void main(String args[] ){
        Scanner in=new Scanner(System.in);
        byte t=in.nextByte();
        while(t-->0){
            int n=in.nextInt();
            int k=in.nextInt()%n;
                for(int i=0;i<n-k;i++)
                    ar[i]=in.nextInt();
                for(int i=0;i<k;i++)
                    System.out.print(in.nextInt()+" ");
                for(int i=0;i<n-k;i++)
                    System.out.print(ar[i]+" ");
            System.out.println();
        }
    }
}

我不知道为什么它会给 TLE 我认为有一些无限循环。

现场的问题是——

Monk 和 Rotation Monk 喜欢对数组执行不同的操作，因此作为 HackerEarth School 的校长，他给他的新学生 Mishki 分配了一项任务。 Mishki 将获得一个大小为 N 的整数数组 A 和一个整数 K ，她需要将数组沿正确方向旋转 K 步，然后打印结果数组。 由于她是新来的学校，请帮助她完成任务。

输入：第一行由一个整数 T 组成，表示测试用例的数量。 对于每个测试用例：

1. 第一行由两个整数 N 和 K 组成，N 是数组中元素的数量，K 表示旋转的步数。
2. 下一行由 N 个空格分隔的整数组成，表示数组 A 的元素。输出：打印所需的数组。

约束：

1<=T<=20
1<=N<=10^5
0<=K<=10^6
0<=A[i]<=10^6

样本输入

1

5 2

1 2 3 4 5

样本输出

4 5 1 2 3

解释

这里 T 为 1，表示一个测试用例。

表示数组中的元素个数， 表示旋转的步数。

初始数组是：在第一次旋转中，5 将出现在第一个位置，所有其他元素将移动到它们当前位置的前面一个位置。 现在，结果数组将是

在第二次旋转中，4 将进入第一个位置，所有其他元素将移动到其当前位置前面的一个位置。 现在，结果数组将是

时间限制：每个输入文件 1.0 秒内存限制：256 MB 源限制：1024 KB

Answer 1

我不确定您的解决方案的正确性，但请尝试使用 StreamTokenizer 或 BufferedReader 而不是 Scanner。 Scanner 速度太慢，当您需要读取大量数据时可能会导致 TLE。

Answer 2

减少对 System.in 和 System.out 的读写次数。 看下面的解决方案

        Scanner scanner = new Scanner(System.in);
        int noOfTestCases = scanner.nextInt();

        for (int i = 0; i < noOfTestCases; i++) {
            int arraySize = scanner.nextInt();
            int noOfRotations = scanner.nextInt();
            noOfRotations = noOfRotations % arraySize;
            scanner.nextLine();
            String inputString = scanner.nextLine();
            String[] inputStringArray = inputString.split(" ");

            StringBuffer sb = new StringBuffer();

            for (int j = 0; j < arraySize; j++) {
                sb.append(inputStringArray[(arraySize + j - noOfRotations) % arraySize] + " ");
            }

            System.out.print(sb);
            System.out.println("");
        }

Answer 3

import java.util.*;
public class temp {
    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        while(t-->0){
            int n = sc.nextInt();
            int k = sc.nextInt();
            int p = 0;
            int ar[] = new int[n];
            for(int i=0;i<n;i++){
                ar[i] = sc.nextInt();
            }
            k %= n;
            for(int i=0;i<n;i++){
                p = ar[(i+(n-k))%n];
                System.out.print(p+" ");
            }
            System.out.println();
        }       
    }
}

虽然我在开始时没有使用大数组，但这段代码适用于所有测试用例。

试试这个。

Answer 4

从不同的角度思考。 我们可以应用不同的逻辑，而不是拆分字符串并将其转换为数组并应用迭代逻辑。

诀窍是您只需要找到我们必须拆分一次的输入字符串的位置。 我的意思是，
输入=>
6 2 //4是数字的长度，2是旋转的索引
1 2 3 4 5 6 //数组（使用缓冲读取器将输入作为字符串）

在这里，我们只需要在倒数第二个空格即第四个空格处拆分数组字符串。 因此，只需将字符串拆分一次即可实现输出-
5 6 1 2 3 4
第一次拆分- 5 6 + 空格 + 第二次拆分- 1 2 3 4
这个逻辑对我有用，所有的测试用例都通过了。

当数组输入字符串只是一个数字时，不要忘记覆盖极端情况。

代码片段-

int count=0;
for(int k=0; k<arr.length(); k++) {
    if(arr.charAt(k)==' ')
        count++;
    if(count==size-rot) {
         System.out.println(arr.substring(k+1,arr.length())
             + " " + arr.substring(0,k));
         break;
    }
}

Answer 5

问题出在 for 循环内的System.out.print()调用中。 这是一个相当繁重的调用，如果调用太多次并产生开销。 此解决方案有效：

//import for Scanner and other utility classes
import java.util.*;

class TestClass {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String input = s.nextLine();
        int noOfTests = Integer.parseInt(input);
        for (int t = 0; t < noOfTests; t++) {
            input = s.nextLine();
            String[] str = input.split(" ");
            int sizeOfArray = Integer.parseInt(str[0]);
            int noOfRotations = Integer.parseInt(str[1]);
            String strIntegerArray = s.nextLine();
            String[] array = strIntegerArray.split(" ");
            printRightRotatedArray(array, noOfRotations, strIntegerArray.length());
        }
    }

    static void printRightRotatedArray(String[] array, int noOfRotations, int lengthOfStr) {
        int len = array.length;
        int noOfAcutalRotations = noOfRotations % len;
        int startingIndex = len - noOfAcutalRotations;
        StringBuilder sb = new StringBuilder(lengthOfStr+1);
        for (int i = 0; i < len; i++) {
            sb.append(array[(startingIndex + i) % len]);
            sb.append(" ");
        }
        System.out.println(sb);
    }
}

Answer 6

将所有内容放入字符串缓冲区并在最后打印对我有用。

class TestClass {
public static void main(String args[] ) throws Exception {
    //BufferedReader
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int t = Integer.parseInt(br.readLine());
    StringBuilder sb = new StringBuilder();// output
    for(int i=0;i<t;i++){
        String [] nk=br.readLine().split(" ");
        int n= Integer.parseInt(nk[0]);
        int k=Integer.parseInt(nk[1]);
        String [] a=br.readLine().split(" ");
        int split=n-(k%n);
        for (int j = split; j < a.length; j++) {
            sb.append(a[j]);
            sb.append(' ');
        }
        for (int j = 0 ; j < split; j++) {
            sb.append(a[j]);
            sb.append(' ');
        }
        sb.append("\n");
    }
    System.out.println(sb);
}

}