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 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:
The given array contains all integers from 1 to 5 exactly once. Hence, it represents a permutation of length 5.
Naive Approach: in O(N2) Time
This approach is mentioned here
Another Approach: in O(N) Time and O(N) Space
This approach is mentioned here.
Efficient Approach: Using HashTable
- Create a HashTable of N size to store the frequency count of each number from 1 to N
- Traverse through the given array and store the frequency of each number in the HashTable.
- Then traverse the HashTable and check if all the numbers from 1 to N have a frequency of 1 or not.
- Print “Yes” if the above condition is True, Else “No”.
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 string permutation( int arr[], int N)
{ int hash[N + 1] = { 0 };
// Counting the frequency
for ( int i = 0; i < N; i++) {
hash[arr[i]]++;
}
// Check if each frequency is 1 only
for ( int i = 1; i <= N; i++) {
if (hash[i] != 1)
return "No" ;
}
return "Yes" ;
} // Driver code int main()
{ int arr[] = { 1, 1, 5, 5, 3 };
int n = sizeof (arr) / sizeof ( int );
cout << permutation(arr, n) << endl;
return 0;
} |
// Java program to decide if an array // represents a permutation or not class GFG{
// Function to check if an // array represents a permutation or not static String permutation( int arr[], int N)
{ int []hash = new int [N + 1 ];
// Counting the frequency
for ( int i = 0 ; i < N; i++) {
hash[arr[i]]++;
}
// Check if each frequency is 1 only
for ( int i = 1 ; i <= N; i++) {
if (hash[i] != 1 )
return "No" ;
}
return "Yes" ;
} // Driver code public static void main(String[] args)
{ int arr[] = { 1 , 1 , 5 , 5 , 3 };
int n = arr.length;
System.out.print(permutation(arr, n) + "\n" );
} } // This code is contributed by Princi Singh |
# 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) :
hash = [ 0 ] * (N + 1 );
# Counting the frequency
for i in range (N) :
hash [arr[i]] + = 1 ;
# Check if each frequency is 1 only
for i in range ( 1 , N + 1 ) :
if ( hash [i] ! = 1 ) :
return "No" ;
return "Yes" ;
# Driver code if __name__ = = "__main__" :
arr = [ 1 , 1 , 5 , 5 , 3 ];
n = len (arr);
print (permutation(arr, n));
# This code is contributed by Yash_R
|
// C# program to decide if an array // represents a permutation or not using System;
class GFG{
// Function to check if an
// array represents a permutation or not
static string permutation( int []arr, int N)
{
int []hash = new int [N + 1];
// Counting the frequency
for ( int i = 0; i < N; i++) {
hash[arr[i]]++;
}
// Check if each frequency is 1 only
for ( int i = 1; i <= N; i++) {
if (hash[i] != 1)
return "No" ;
}
return "Yes" ;
}
// Driver code
public static void Main( string [] args)
{
int []arr = { 1, 1, 5, 5, 3 };
int n = arr.Length;
Console.Write(permutation(arr, n) + "\n" );
}
} // This code is contributed by Yash_R |
<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)
{ var hash = Array(N+1).fill(0);
// Counting the frequency
for ( var i = 0; i < N; i++) {
hash[arr[i]]++;
}
// Check if each frequency is 1 only
for ( var i = 1; i <= N; i++) {
if (hash[i] != 1)
return "No" ;
}
return "Yes" ;
} // Driver code var arr = [1, 1, 5, 5, 3];
var n = arr.length;
document.write( permutation(arr, n)); </script> |
No
Time Complexity: O(N)
Auxiliary Space Complexity: O(N)