Coloque los primeros N números naturales en índices que no sean iguales a sus valores en una array

Dado un número entero N ( N > 1 ), la tarea es organizar todos los números enteros del rango [1, N] en una array de modo que ninguno de los elementos sea igual al índice ( indexación basada en 1 ) en el que están presentes en la array.

Ejemplos:

Entrada: N = 2
Salida: 2 1
Explicación: El único arreglo posible de una array de tamaño 2 es 2 1.

Entrada: N=5
Salida: 2 1 5 3 4
Explicación: Una disposición posible de un arreglo de tamaño 5 es 2 1 5 3 4l.

Enfoque: La idea más simple es colocar N en el primer índice y colocar los elementos restantes [1, N – 1] en los índices restantes.

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

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to place first N natural
// numbers in an array such that none
// of the values are equal to its indices
void generatepermutation(int N)
{
 
  // Stores the required array
    vector<int> answer;
 
    // Place N at the first position
    answer.push_back(N);
 
    // Iterate the range [1, N)
    for (int i = 1; i < N; i++)
    {
        // Append elements to the sequence
        answer.push_back(i);
    }
 
    // Print the sequence
    for(int i:answer) cout << i << " ";
 
}
 
// Driver Code
int main()
{
  int N = 4;
  generatepermutation(N);
 
  return 0;
}
 
// This code is contributed by mohit kumar 29.

// Java program for the above approach
import java.util.*;
class GFG
{
 
// Function to place first N natural
// numbers in an array such that none
// of the values are equal to its indices
static void generatepermutation(int N)
{
 
  // Stores the required array
    Vector<Integer> answer = new Vector<Integer>();
 
    // Place N at the first position
    answer.add(N);
 
    // Iterate the range [1, N)
    for (int i = 1; i < N; i++)
    {
        // Append elements to the sequence
        answer.add(i);
    }
 
    // Print the sequence
    for(int i:answer) System.out.print(i+ " ");
}
 
// Driver Code
public static void main(String[] args)
{
  int N = 4;
  generatepermutation(N);
}
}
 
// This code is contributed by 29AjayKumar

# Python program for the above approach
 
# Function to place first N natural
# numbers in an array such that none
# of the values are equal to its indices
def generatepermutation(N):
 
  # Stores the required array
    answer = []
 
    # Place N at the first position
    answer.append(N)
 
    # Iterate the range [1, N)
    for i in range(1, N):
 
        # Append elements to the sequence
        answer.append(i)
 
    # Print the sequence
    print(*answer)
 
 
# Driver Code
N = 4
generatepermutation(N)

// C# program for the above approach
using System;
class GFG
{
 
// Function to place first N natural
// numbers in an array such that none
// of the values are equal to its indices
static void generatepermutation(int N)
{
 
    // Stores the required array
    int[] answer = new int[N];
 
    // Place N at the first position
    answer[0] = N;
 
    // Iterate the range [1, N)
    for (int i = 1; i < N; i++)
    {
       
        // Append elements to the sequence
        answer[i] = i;
    }
 
    // Print the sequence
    foreach(int i in answer) Console.Write(i+ " ");
}
 
// Driver Code
static public void Main ()
{
  int N = 4;
  generatepermutation(N);
}
}
 
// This code is contributed by Dharanendra L V

<script>
 
      // JavaScript program for the above approach
       
      // Function to place first N natural
      // numbers in an array such that none
      // of the values are equal to its indices
      function generatepermutation(N)
      {
        // Stores the required array
        var answer = [];
 
        // Place N at the first position
        answer.push(N);
        console.log(answer);
        // Iterate the range [1, N)
        for (var i = 1; i < N; i++) {
          console.log(answer);
          // Append elements to the sequence
          answer.push(i);
        }
 
        // Print the sequence
        for (var i in answer)
        document.write(answer[i] + "  ");
      }
 
      // Driver Code
      var N = 4;
      generatepermutation(N);
       
</script>

4 1 2 3 

Complejidad temporal: O(N)
Espacio auxiliar: O(1)