将数组旋转 k

Question

给定一个数组和一个数字 k，我们必须将数组旋转 k 次。

Sample Input
1            //number of of testcases 
5 2          //5(array size) 2(K value)
1 2 3 4 5    /array elements

Sample output
4 5 1 2 3

这是我的代码

import java.util.*;
class TestClass {
    public static void main(String args[] ) throws Exception {
        // Write your code here
        Scanner input=new Scanner(System.in);
        int testcases=input.nextInt();

        for(int i=0;i<testcases;i++)
        {
            int size=input.nextInt();
            int rotationNo=input.nextInt();
            rotateArray(size, rotationNo, input);
        }
    }
    public static void rotateArray(int size, int rotationNo, Scanner input)
    {
        int[] arr=new int[size];
        int[] result=new int[size];

        rotationNo=rotationNo%size;

        for(int i=0;i<size;i++)
        {
            arr[i]=input.nextInt();
        }

        int resultIndex=0;

        int index=size-rotationNo;

        int k=index,t=0,track=0;

        while(true)
        {
            if(k<size)
            {
                System.out.print(arr[k++]+" ");
                ++track;

                if(track==size)
                {
                    break;
                }
                else
                {
                    continue;
                }
            }
            if(t<index)
            {
                if(t==(index-1))
                {
                    System.out.print(arr[t++]);
                }
                else
                {    
                    System.out.print(arr[t++]+" ");
                }
                ++track;
                
                if(track==size)
                {
                    break;
                }
                else
                {
                    continue;
                }
            }
        }

        System.out.println();
    }
}

这个问题是在一次编程比赛中提出的。我的所有测试用例都通过了，除了一个显示超出时间限制的测试用例。但我不明白超出时限的原因是什么。循环将始终停止任何测试用例。 我的代码的时间复杂度是 O(n)。 还有其他更好更有效的解决方案吗？

Answer 1

在读取和存储 k 个值后立即开始直接输出输入（即不存储）。
然后输出k个最初读取和存储的值。

数组内部的移位，就是这里的相关操作。
完成的班次越少（如果实施得当，班次的距离在这里并不真正相关）越好。它包括对数组的存储和检索。我认为读取和输出，如果在中间没有任何处理的情况下完成，可以忽略不计。 IE。我专注于转变。

严格来说，读取和输出是处理过程，这意味着无法计算 O() 的改进。

但请允许我忽略对改进的 O() 估计的读取和输出：

建议的建议将提高从 O(n) 到 O(k) 期间的数组访问次数。诚然，这里忽略了读取和输出。这里避免了从数组中存储和检索，尤其是数组内部的移位，这就是与这里相关的 O(k) 部分。
所以相关操作是O(k)，忽略O(1)中的n-k个值。

类似的测试用例

1
10000 1
1 2 3 4 5 6 7 8 ...

将很容易消除读取后输出前执行O(4*10000)的程序，即全部存储，全部读写移位，然后全部读取输出。与 O(2*1) 相比，它只存储一个值并再次读取以在最后输出。
（是的，我知道干净的 O() 分析不使用因子或任何数字。你仍然明白这一点，我希望。;-)

这是一个代码提案（简化为单个测试用例）：

import java.util.*;
public class Test {

    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);
        int testcases= input.nextInt(); //ignored, assuming 1
        int size     = input.nextInt();
        int rotation = input.nextInt();
        int i=0;

        int[] newArr = new int[rotation%size]; //small array
        // based on the nice idea by User-Upvotedon'tsayThanks
        
        for(; i<rotation%size; i++)
        {
            newArr[i] = input.nextInt(); // few write accesses
        }
        for(; i<size; i++)
        {
            System.out.println( input.nextInt()); //many direct outpots
        }
        for(i=0; i<rotation%size; i++)
        {
            System.out.println(newArr[i]); // few outputs from array
        }
        return;
    }
}

对于输入：

1
5 2
1 2 3 4 5

它会为您提供以下输出：

3
4
5
1
2

模数要求输入的相同输出：

1
5 7
1 2 3 4 5

Answer 2

我在下面提供了一个解决方案，它将直接输出扫描仪输入，直到满足输入的大小。它有一个恒定的输入时间 o(n)，但是它只接触每个项目一次。并避免使用可能会增加迭代乘数的 while 循环。

public class Test {


    public static void main(String[] args) {

        int rotation = new Scanner(System.in).nextInt();
        int size = new Scanner(System.in).nextInt();


        int[] values = rotate(rotation, size, new Scanner(System.in));

        for(int i : values){
            System.out.println(i);
        }
    }

    public static int[] rotate(int rotation, int size, Scanner input){

        int[] newArr = new int[size];

        for(int i = 0; i<size; i++){

            int newPosition = i + rotation;

            newPosition = newPosition >= size ? newPosition - size : newPosition;

            newArr[newPosition] = input.nextInt();

        }

        return newArr;
    }
}