Given an array arr containing N positive integers, the task is to check if the given array arr represents a permutation or not.
A sequence of N integers is called a permutation if it contains all integers from 1 to N exactly once.
Examples:
Input: arr[] = {1, 2, 5, 3, 2}
Output: No
Explanation: The given array is not a permutation of numbers from 1 to N, because it contains 2 twice, and 4 is missing for the array to represent a permutation of length 5.Input: arr[] = {1, 2, 5, 3, 4}
Output: Yes
Explanation:
Given array contains all integers from 1 to 5 exactly once. Hence, it represents a permutation of length 5.
Naive Approach: Clearly, the given array will represent a permutation of length N only, where N is the length of the array. So we have to search for each element from 1 to N in the given array. If all the elements are found then the array represents a permutation else it does not.
Algorithm:
- Initialize a flag variable “isPermutation” to true.
- Initialize a variable “N” to the length of the array.
-
Loop through integers from 1 to N:
- Initialize a flag variable “found” to false.
- Loop through the array elements and If the integer “i” is found in the array, set “found” to true and break the loop.
- If “found” is false, set “isPermutation” to false and break the loop.
- If “isPermutation” is true, print “Array represents a permutation”.
- Else, print “Array does not represent a permutation”.
Below is the implementation of the approach:
// C++ code for the approach #include <bits/stdc++.h> using namespace std;
// Function to check if an Array is a // permutation of numbers from 1 to N bool isPermutation( int arr[], int n) {
// Check for each element from 1 to N in the array
for ( int i=1; i<=n; i++) {
bool found = false ;
for ( int j=0; j<n; j++) {
if (arr[j] == i) {
found = true ;
break ;
}
}
// If any element is not found, array is not a permutation
if (!found) {
return false ;
}
}
// All elements found, array is a permutation
return true ;
} // Driver's code int main() {
// Input
int arr[] = { 1, 2, 5, 3, 2 };
int n = sizeof (arr)/ sizeof (arr[0]);
// Function Call
if (isPermutation(arr, n)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
} |
// Java code for the approach import java.util.*;
public class GFG {
// Function to check if an Array is a
// permutation of numbers from 1 to N
public static boolean isPermutation( int [] arr, int n)
{
// Check for each element from
// 1 to N in the array
for ( int i = 1 ; i <= n; i++) {
boolean found = false ;
for ( int j = 0 ; j < n; j++) {
if (arr[j] == i) {
found = true ;
break ;
}
}
// If any element is not found,
// array is not a permutation
if (!found) {
return false ;
}
}
// All elements found, array
// is a permutation
return true ;
}
// Driver's code
public static void main(String[] args)
{
int [] arr = { 1 , 2 , 5 , 3 , 2 };
int n = arr.length;
if (isPermutation(arr, n)) {
System.out.println( "Yes" );
}
else {
System.out.println( "No" );
}
}
} |
# Function to check if a list is a permutation of numbers from 1 to N def is_permutation(arr):
n = len (arr)
# Check for each element from 1 to N in the list
for i in range ( 1 , n + 1 ):
found = False
for j in range (n):
if arr[j] = = i:
found = True
break
# If any element is not found, the list is not a permutation
if not found:
return False
# All elements found, the list is a permutation
return True
# Driver's code arr = [ 1 , 2 , 5 , 3 , 2 ]
# Function Call if is_permutation(arr):
print ( "Yes" )
else :
print ( "No" )
|
using System;
public class GFG {
// Function to check if an Array is a
// permutation of numbers from 1 to N
public static bool IsPermutation( int [] arr, int n)
{
// Check for each element from
// 1 to N in the array
for ( int i = 1; i <= n; i++) {
bool found = false ;
for ( int j = 0; j < n; j++) {
if (arr[j] == i) {
found = true ;
break ;
}
}
// If any element is not found,
// array is not a permutation
if (!found) {
return false ;
}
}
// All elements found, array
// is a permutation
return true ;
}
// Driver's code
public static void Main( string [] args)
{
int [] arr = { 1, 2, 5, 3, 2 };
int n = arr.Length;
if (IsPermutation(arr, n)) {
Console.WriteLine( "Yes" );
}
else {
Console.WriteLine( "No" );
}
}
} // This code is contributed by Samim Hossain Mondal. |
// Function to check if an Array is a permutation of numbers from 1 to N function isPermutation(arr, n) {
// Check for each element from 1 to N in the array
for (let i = 1; i <= n; i++) {
let found = false ;
for (let j = 0; j < n; j++) {
if (arr[j] === i) {
found = true ;
break ;
}
}
// If any element is not found, array is not a permutation
if (!found) {
return false ;
}
}
// All elements found, array is a permutation
return true ;
} // Driver's code const arr = [1, 2, 5, 3, 2]; const n = arr.length; if (isPermutation(arr, n)) {
console.log( "Yes" );
} else {
console.log( "No" );
} |
No
Time Complexity: O(N2)
Efficient Approach:
The above method can be optimized using a set data structure.
- Traverse the given array and insert every element in the set data structure.
- Also, find the maximum element in the array. This maximum element will be value N which will represent the size of the set.
- After traversal of the array, check if the size of the set is equal to N.
- If the size of the set is equal to N then the array represents a permutation else it doesn’t.
Below is the implementation of the above approach:
// C++ Program to decide if an // array represents a permutation or not #include <bits/stdc++.h> using namespace std;
// Function to check if an // array represents a permutation or not bool permutation( int arr[], int n)
{ // Set to check the count
// of non-repeating elements
set< int > hash;
int maxEle = 0;
for ( int i = 0; i < n; i++) {
// Insert all elements in the set
hash.insert(arr[i]);
// Calculating the max element
maxEle = max(maxEle, arr[i]);
}
if (maxEle != n)
return false ;
// Check if set size is equal to n
if (hash.size() == n)
return true ;
return false ;
} // Driver code int main()
{ int arr[] = { 1, 2, 5, 3, 2 };
int n = sizeof (arr) / sizeof ( int );
if (permutation(arr, n))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} |
// Java Program to decide if an // array represents a permutation or not import java.util.*;
class GFG{
// Function to check if an // array represents a permutation or not static boolean permutation( int []arr, int n)
{ // Set to check the count
// of non-repeating elements
Set<Integer> hash = new HashSet<Integer>();
int maxEle = 0 ;
for ( int i = 0 ; i < n; i++) {
// Insert all elements in the set
hash.add(arr[i]);
// Calculating the max element
maxEle = Math.max(maxEle, arr[i]);
}
if (maxEle != n)
return false ;
// Check if set size is equal to n
if (hash.size() == n)
return true ;
return false ;
} // Driver code public static void main(String args[])
{ int arr[] = { 1 , 2 , 5 , 3 , 2 };
int n = arr.length;
if (permutation(arr, n))
System.out.println( "Yes" );
else
System.out.println( "No" );
} } // This code is contributed by Surendra_Gangwar |
# Python3 Program to decide if an # array represents a permutation or not # Function to check if an # array represents a permutation or not def permutation(arr, n):
# Set to check the count
# of non-repeating elements
s = set ()
maxEle = 0 ;
for i in range (n):
# Insert all elements in the set
s.add(arr[i]);
# Calculating the max element
maxEle = max (maxEle, arr[i]);
if (maxEle ! = n):
return False
# Check if set size is equal to n
if ( len (s) = = n):
return True ;
return False ;
# Driver code if __name__ = = '__main__' :
arr = [ 1 , 2 , 5 , 3 , 2 ]
n = len (arr)
if (permutation(arr, n)):
print ( "Yes" )
else :
print ( "No" )
# This code is contributed by Princi Singh |
// C# Program to decide if an // array represents a permutation or not using System;
using System.Collections.Generic;
class GFG{
// Function to check if an // array represents a permutation or not static bool permutation( int []arr, int n)
{ // Set to check the count
// of non-repeating elements
HashSet< int > hash = new HashSet< int >();
int maxEle = 0;
for ( int i = 0; i < n; i++) {
// Insert all elements in the set
hash.Add(arr[i]);
// Calculating the max element
maxEle = Math.Max(maxEle, arr[i]);
}
if (maxEle != n)
return false ;
// Check if set size is equal to n
if (hash.Count == n)
return true ;
return false ;
} // Driver code public static void Main(String []args)
{ int []arr = { 1, 2, 5, 3, 2 };
int n = arr.Length;
if (permutation(arr, n))
Console.WriteLine( "Yes" );
else
Console.WriteLine( "No" );
} } // This code is contributed by Princi Singh |
<script> // JavaScript Program to decide if an // array represents a permutation or not // Function to check if an // array represents a permutation or not function permutation(arr, n)
{ // Set to check the count
// of non-repeating elements
let hash = new Set();
let maxEle = 0;
for (let i = 0; i < n; i++) {
// Insert all elements in the set
hash.add(arr[i]);
// Calculating the max element
maxEle = Math.max(maxEle, arr[i]);
}
if (maxEle != n)
return false ;
// Check if set size is equal to n
if (hash.length == n)
return true ;
return false ;
} // Driver Code let arr = [ 1, 2, 5, 3, 2 ];
let n = arr.length;
if (permutation(arr, n))
document.write( "Yes" );
else
document.write( "No" );
</script> |
No
Time Complexity: O(N log N), Since every insert operation in the set is an O(log N) operation. There will be N such operations hence O(N log N).
Auxiliary Space: O(N)
Efficient Approach:-
- As we have to check all elements from 1 to N in the array
- So think that if we just sort the array then if the array element will be from 1 to N then the sequence will be like 1,2,3_____,N.
- So we can just sort the array and can check is all the elements are like 1,2,3,____,N or not.
Implementation:-
// C++ Program to decide if an // array represents a permutation or not #include <bits/stdc++.h> using namespace std;
// Function to check if an // array represents a permutation or not bool permutation( int arr[], int n)
{ //sorting the array
sort(arr,arr+n);
//traversing the array to find if it is a valid permutation ot not
for ( int i=0;i<n;i++)
{
//if i+1 element not present
//or dublicacy is present
if (arr[i]!=i+1) return false ;
}
return true ;
} // Driver code int main()
{ int arr[] = { 1, 2, 5, 3, 2 };
int n = sizeof (arr) / sizeof ( int );
if (permutation(arr, n))
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} //This code is contributed by shubhamrajput6156 |
// Java Program to decide if an // array represents a permutation or not import java.util.*;
class GFG
{ // Function to check if an
// array represents a permutation or not
static boolean permutation( int arr[], int n)
{
// sorting the array
Arrays.sort(arr);
// traversing the array to find if it is a valid permutation ot not
for ( int i = 0 ; i < n; i++)
{
//if i+1 element not present
//or dublicacy is present
if (arr[i]!=i+ 1 ) return false ;
}
return true ;
}
// Driver Code
public static void main(String[] args) {
int arr[] = { 1 , 2 , 5 , 3 , 2 };
int n = arr.length;
if (permutation(arr, n))
System.out.println( "Yes" );
else
System.out.println( "No" );
return ;
}
} // this code is contributed by bhardwajji |
# Python3 Program to decide if an # array represents a permutation or not # Function to check if an # array represents a permutation or not def permutation(arr, n):
# sorting the array
arr.sort()
# traversing the array to find if it is a valid permutation or not
for i in range (n):
# if i+1 element not present
# or dublicacy is present
if arr[i] ! = i + 1 :
return False
return True
# Driver code if __name__ = = '__main__' :
arr = [ 1 , 2 , 5 , 3 , 2 ]
n = len (arr)
if permutation(arr, n):
print ( "Yes" )
else :
print ( "No" )
|
// C# Program to decide if an // array represents a permutation or not using System;
public class GFG
{ // Function to check if an
// array represents a permutation or not
public static bool permutation( int [] arr, int n)
{
//sorting the array
Array.Sort(arr);
//traversing the array to find if it is a valid permutation ot not
for ( int i = 0;i < n;i++)
{
//if i+1 element not present
//or dublicacy is present
if (arr[i] != i + 1)
{
return false ;
}
}
return true ;
}
internal static void Main()
{
int [] arr = {1, 2, 5, 3, 2};
int n = arr.Length;
if (permutation(arr, n))
{
Console.Write( "Yes" );
Console.Write( "\n" );
}
else
{
Console.Write( "No" );
Console.Write( "\n" );
}
}
} //This code is contributed by bhardwajji |
// Function to check if an // array represents a permutation or not function permutation(arr, n) {
// sorting the array
arr.sort();
// traversing the array to find if it is a valid permutation or not
for (let i = 0; i < n; i++) {
// if i+1 element not present
// or dublicacy is present
if (arr[i] !== i + 1) {
return false ;
}
}
return true ;
} // Driver code const arr = [1, 2, 5, 3, 2]; const n = arr.length; if (permutation(arr, n)) {
console.log( "Yes" );
} else {
console.log( "No" );
} // This code is Contributed by Shushant Kumar |
No
Time Complexity:- O(NLogN)
Space Complexity:- O(1)
Another Efficient Approach: create a boolean array that help in if we already visited that element return False
else Traverse the Whole array
Below is the implementation of above approach
#include <cstring> #include <iostream> using namespace std;
bool permutation( int arr[], int n)
{ // create a boolean array to keep track of which numbers
// have been seen before
bool x[n];
// initialize the boolean array with false values
memset (x, false , sizeof (x));
// check each number in the array
for ( int i = 0; i < n; i++) {
// if the number has not been seen before, mark it
// as seen
if (x[arr[i] - 1] == false ) {
x[arr[i] - 1] = true ;
}
// if the number has been seen before, the array
// does not represent a permutation
else {
return false ;
}
}
// check if all numbers from 1 to n have been seen in
// the array
for ( int i = 0; i < n; i++) {
// if a number has not been seen in the array, the
// array does not represent a permutation
if (x[i] == false ) {
return false ;
}
}
// if the array has passed all checks, it represents a
// permutation
return true ;
} int main()
{ // initialize the array to be checked
int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof (arr) / sizeof (arr[0]);
// check if the array represents a permutation
if (permutation(arr, n)) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
return 0;
} |
import java.util.Arrays;
public class Main {
public static boolean permutation( int [] arr, int n) {
// create a boolean array to keep track of which numbers
// have been seen before
boolean [] x = new boolean [n];
// initialize the boolean array with false values
Arrays.fill(x, false );
// check each number in the array
for ( int i = 0 ; i < n; i++) {
// if the number has not been seen before, mark it
// as seen
if (x[arr[i] - 1 ] == false ) {
x[arr[i] - 1 ] = true ;
}
// if the number has been seen before, the array
// does not represent a permutation
else {
return false ;
}
}
// check if all numbers from 1 to n have been seen in
// the array
for ( int i = 0 ; i < n; i++) {
// if a number has not been seen in the array, the
// array does not represent a permutation
if (x[i] == false ) {
return false ;
}
}
// if the array has passed all checks, it represents a
// permutation
return true ;
}
public static void main(String[] args) {
// initialize the array to be checked
int [] arr = { 1 , 2 , 3 , 4 , 5 };
int n = arr.length;
// check if the array represents a permutation
if (permutation(arr, n)) {
System.out.println( "YES" );
} else {
System.out.println( "NO" );
}
}
} // This code is contributed by shiv1043g |
# Python code for the above approach # Function to check if an # array represents a permutation or not # time complexity O(N) # space O(N) def permutation(arr, n):
# crete a bool array that check if the element
# we traversing are already exist in array or not
x = [ 0 ] * n
# checking for every element in array
for i in range (n):
if x[arr[i] - 1 ] = = 0 :
x[arr[i] - 1 ] = 1
else :
return False
# for corner cases
for i in range (n):
if x[i] = = 0 :
return False
return True
# Drive code if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 ]
n = len (arr)
if (permutation(arr, n)):
print ( "YES" )
else :
print ( "NO" )
# This code is contributed by Shushant Kumar |
using System;
public class Gfg
{ public static bool permutation( int [] arr, int n)
{
// create a boolean array to keep track of which numbers
// have been seen before
bool [] x = new bool [n];
// initialize the boolean array with false values
for ( int i = 0; i < n; i++)
{
x[i] = false ;
}
// check each number in the array
for ( int i = 0; i < n; i++)
{
// if the number has not been seen before, mark it
// as seen
if (x[arr[i] - 1] == false )
{
x[arr[i] - 1] = true ;
}
// if the number has been seen before, the array
// does not represent a permutation
else
{
return false ;
}
}
// check if all numbers from 1 to n have been seen in
// the array
for ( int i = 0; i < n; i++)
{
// if a number has not been seen in the array, the
// array does not represent a permutation
if (x[i] == false )
{
return false ;
}
}
// if the array has passed all checks, it represents a
// permutation
return true ;
}
public static void Main()
{
// initialize the array to be checked
int [] arr = { 1, 2, 3, 4, 5 };
int n = arr.Length;
// check if the array represents a permutation
if (permutation(arr, n))
{
Console.WriteLine( "YES" );
}
else
{
Console.WriteLine( "NO" );
}
}
} |
// Function to check if an array represents a permutation or not // time complexity O(N) // space O(N) function permutation(arr, n) {
// create a boolean array to check if the element we're
// traversing already exists in the array or not
let x = new Array(n).fill( false );
// check for every element in array
for (let i = 0; i < n; i++) {
if (x[arr[i] - 1] == false ) {
x[arr[i] - 1] = true ;
} else {
return false ;
}
}
// for corner cases
for (let i = 0; i < n; i++) {
if (x[i] == false ) {
return false ;
}
}
return true ;
} // Drive code let arr = [1, 2, 3, 4, 5]; let n = arr.length; if (permutation(arr, n)) {
console.log( "YES" );
} else {
console.log( "NO" );
} // This code is contributed by shushant kumar |
YES
Time Complexity: O(N)
Auxiliary Space: O(N)