Imprime todas las rotaciones posibles de un Array dado

Dada una array de enteros arr[] de tamaño N , la tarea es imprimir todas las rotaciones posibles de la array.
Ejemplos: 

Entrada: arr[] = {1, 2, 3, 4} 
Salida: {1, 2, 3, 4}, {4, 1, 2, 3}, {3, 4, 1, 2}, {2, 3, 4, 1} 
Explicación: 
Inicial arr[] = {1, 2, 3, 4} 
Después de la primera rotación arr[] = {4, 1, 2, 3} 
Después de la segunda rotación arr[] = {3, 4, 1, 2} 
Después de la tercera rotación arr[] = {2, 3, 4, 1} 
Después de la cuarta rotación, arr[] vuelve a su forma original.
Entrada: arr[] = [1] 
Salida: [1] 

Enfoque: 
siga los pasos a continuación para resolver el problema:  

1. Genere todas las rotaciones posibles de la array, realizando una rotación a la izquierda de la array una por una.
2. Imprima todas las rotaciones posibles de la array hasta que se encuentre la misma rotación de la array.

A continuación se muestra la implementación del enfoque anterior: 

// C++ program to print
// all possible rotations
// of the given array
#include <iostream>
using namespace std;  
 
// Global declaration of array
int arr[10000];
 
// Function to reverse array
// between indices s and e
void reverse(int arr[],
             int s, int e)
{
  while(s < e)
  {
    int tem = arr[s];
    arr[s] = arr[e];
    arr[e] = tem;
    s = s + 1;
    e = e - 1;
  }
}
 
// Function to generate all
// possible rotations of array
void fun(int arr[], int k)
{
  int n = 4 - 1;
  int v = n - k;
 
  if (v >= 0)
  {
    reverse(arr, 0, v);
    reverse(arr, v + 1, n);
    reverse(arr, 0, n);
  }
}
 
// Driver code
int main()
{
  arr[0] = 1;
  arr[1] = 2;
  arr[2] = 3;
  arr[3] = 4;
 
  for(int i = 0; i < 4; i++)
  {
    fun(arr, i);
    cout << ("[");
     
    for(int j = 0; j < 4; j++)
    {
      cout << (arr[j]) << ", ";
    }
    cout << ("]");
  }
}
 
// This code is contributed by Princi Singh

// Java program to print
// all possible rotations
// of the given array
class GFG{
     
// Global declaration of array
static int arr[] = new int[10000];
 
// Function to reverse array
// between indices s and e
public static void reverse(int arr[],
                           int s, int e)
{
    while(s < e)
    {
        int tem = arr[s];
        arr[s] = arr[e];
        arr[e] = tem;
        s = s + 1;
        e = e - 1;
    }
}
 
// Function to generate all
// possible rotations of array
public static void fun(int arr[], int k)
{
    int n = 4 - 1;
    int v = n - k;
     
    if (v >= 0)
    {
        reverse(arr, 0, v);
        reverse(arr, v + 1, n);
        reverse(arr, 0, n);
    }
}
 
// Driver code
public static void main(String args[])
{
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    arr[3] = 4;
     
    for(int i = 0; i < 4; i++)
    {
        fun(arr, i);
         
        System.out.print("[");
        for(int j = 0; j < 4; j++)
        {
            System.out.print(arr[j] + ", ");
        }
        System.out.print("]");
    }
}
}
 
// This code is contributed by gk74533

# Python program to print
# all possible rotations
# of the given array
 
# Function to reverse array
# between indices s and e
def reverse(arr, s, e):
    while s < e:
        tem = arr[s]
        arr[s] = arr[e]
        arr[e] = tem
        s = s + 1
        e = e - 1
# Function to generate all
# possible rotations of array
def fun(arr, k):
    n = len(arr)-1
    # k = k % n
    v = n - k
    if v>= 0:
        reverse(arr, 0, v)
        reverse(arr, v + 1, n)
        reverse(arr, 0, n)
        return arr
# Driver Code
arr = [1, 2, 3, 4]
for i in range(0, len(arr)):
    count = 0
    p = fun(arr, i)
    print(p, end =" ")

// C# program to print
// all possible rotations
// of the given array
using System;
class GFG{
     
// Global declaration of array
static int []arr = new int[10000];
 
// Function to reverse array
// between indices s and e
public static void reverse(int []arr,
                           int s, int e)
{
  while(s < e)
  {
    int tem = arr[s];
    arr[s] = arr[e];
    arr[e] = tem;
    s = s + 1;
    e = e - 1;
  }
}
 
// Function to generate all
// possible rotations of array
public static void fun(int []arr, int k)
{
  int n = 4 - 1;
  int v = n - k;
 
  if (v >= 0)
  {
    reverse(arr, 0, v);
    reverse(arr, v + 1, n);
    reverse(arr, 0, n);
  }
}
 
// Driver code
public static void Main(String []args)
{
  arr[0] = 1;
  arr[1] = 2;
  arr[2] = 3;
  arr[3] = 4;
 
  for(int i = 0; i < 4; i++)
  {
    fun(arr, i);
    Console.Write("[");
     
    for(int j = 0; j < 4; j++)
    {
      Console.Write(arr[j] + ", ");
    }
    Console.Write("]");
  }
}
}
 
// This code is contributed by Rajput-Ji

<script>
 
// javascript program to print
// all possible rotations
// of the given array
 
// Global declaration of array
arr = Array.from({length: 10000}, (_, i) => 0);
 
// Function to reverse array
// between indices s and e
function reverse(arr, s , e)
{
    while(s < e)
    {
        var tem = arr[s];
        arr[s] = arr[e];
        arr[e] = tem;
        s = s + 1;
        e = e - 1;
    }
}
 
// Function to generate all
// possible rotations of array
function fun(arr , k)
{
    var n = 4 - 1;
    var v = n - k;
     
    if (v >= 0)
    {
        reverse(arr, 0, v);
        reverse(arr, v + 1, n);
        reverse(arr, 0, n);
    }
}
 
// Driver code
 
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    arr[3] = 4;
     
    for(i = 0; i < 4; i++)
    {
        fun(arr, i);
         
        document.write("[");
        for(j = 0; j < 4; j++)
        {
            document.write(arr[j] + ", ");
        }
        document.write("]<br>");
    }
 
 
// This code is contributed by 29AjayKumar
</script>

[1, 2, 3, 4] [4, 1, 2, 3] [2, 3, 4, 1] [3, 4, 1, 2]

Complejidad Temporal: O (N ² ) 
Espacio Auxiliar: O (1), ya que no se ha ocupado ningún espacio extra.