配列要素をn回シフトする方法は？

Question

私は配列を持っているので、配列要素をn-indexでシフトしたいと思います。問題の簡略化のため、1-indexに移動したいとします。またはrecursionと書いてn-timesにすることができます。

言って、配列がA = [3, 8, 9, 7, 6]であると私はそれA = [6, 3, 8, 9, 7]

私はインデックスを取るとn-インデックスによりシフトするのHashMapを考えさせるために1-indexによってright shiftしたいと思います。言って、

Map<Integer, Integer> map = new HashMap<>(); 
int n = 2; 

for(int j =0; j < arr.length; j++){ 
    if(j+2 > arr.length -1){ 
     map.put(j+2 - arr.length, arr[j]); 
    } 
    map.put(j+2, arr[j]); 
} 

for(Map.Entry<Integer, Integer> map : amp.entrySet()){ 
    arr[map.getKey()] = map.getValue(); 
} 

解決策は私にはあまり気に入らない。どのようにアルゴリズムを書くか？

Answer 1

以下のような単純な方法を使用して、配列とシフト数を入力として使用できます。各ステップを説明するインラインコメントを追加しました。

static String[] shiftArray(String[] inputArray, int shifts) { 

    // Loop the number of shifts 
    for (int x = 0; x < shifts; x++) { 

     //Last element will be store in temporary variable 
     String lastElm = inputArray[inputArray.length - 1]; 

     //This loop will shift array content by one 
     for (int i = inputArray.length; i > 0; i--) { 
      if (i == 1) { 
       inputArray[0] = lastElm; 
      } else { 
       inputArray[i - 1] = inputArray[i - 2]; 

      } 
     } 
    } 

    return inputArray; 
    } 

Answer 2

import com.sun.tools.javac.util.ArrayUtils;  
import java.util.Arrays; 

public class shift { 
    public static void main(String args[]){ 
     int [] arr = {3, 8, 9, 7, 6}; 
     int index = 1; // you can change it to whatever you want based on ur ques 
     int temp; 
     int len = arr.length; 
     int[] left = Arrays.copyOfRange(arr, 0, len-index); 
     int[] right = Arrays.copyOfRange(arr,len-index,len); 
     int[] result = new int[5]; 
     System.arraycopy(right, 0, result, 0, right.length); 
     System.arraycopy(left, 0, result, right.length, left.length); 
     System.out.println(Arrays.toString(result)); 
    } 
} 

Answer 3

私は第一1がフォーラムからcolected sはここ2つのソリューションを提供しています。

/*solution-a*/ 
    public static int swap(int itself , int dummy){ 
     return itself; 
    } 

    public static void reverse(int[] A, int start, int end){ 

     int i = start, j = end; 

     while(i < j){ 

      A[i] = swap(A[j], A[j] = A[i]); 

      i++; 
      j--; 
     } 
    } 

    public int[] solution(int[] A, int K) { 

     if(K > A.length){ 
      return null; 
     } 

     reverse(A, 0, A.length -1); 
     reverse(A, 0, K-1); 
     reverse(A, K, A.length -1); 

     return A; 
    } 
    /*ENd of solution-a*/ 






    /*ENd of solution-b*/ 
    public static int[] solution1(int[] arr, int n){ 

     Map<Integer, Integer> map = new HashMap<>(); 

     for(int j =0; j < arr.length; j++){ 

      if(j+n > arr.length -1){ 

       map.put(j+n - arr.length, arr[j]); 
       continue; 
      } 

      map.put(j+n, arr[j]); 
     } 

     for(Map.Entry<Integer, Integer> entry : map.entrySet()){ 
      arr[entry.getKey()] = entry.getValue(); 
     } 

     return arr; 
    } 
    /*ENd of solution-b*/