Given two unsorted arrays of the same size, write a function that returns true if two arrays are permutations of each other, otherwise false.

**Examples: **

Input: arr1[] = {2, 1, 3, 5, 4, 3, 2} arr2[] = {3, 2, 2, 4, 5, 3, 1} Output: Yes Input: arr1[] = {2, 1, 3, 5,} arr2[] = {3, 2, 2, 4} Output: No

**We strongly recommend you to minimize your browser and try this yourself first.**

A **Simple Solution** is to sort both arrays and compare sorted arrays. The time complexity of this solution is O(nLogn)

A **Better Solution** is to use Hashing.

- Create a Hash Map for all the elements of arr1[] such that array elements are keys and their counts are values.
- Traverse arr2[] and search for each element of arr2[] in the Hash Map. If an element is found then decrement its count in the hash map. If not found, then return false.
- If all elements are found then return true.

Below is the implementation of this approach.

## Java

`// A Java program to find one array is permutation of other array` `import` `java.util.HashMap;` `class` `Permutaions` `{` ` ` `// Returns true if arr1[] and arr2[] are permutations of each other` ` ` `static` `Boolean arePermutations(` `int` `arr1[], ` `int` `arr2[])` ` ` `{` ` ` `// Arrays cannot be permutations of one another unless they are ` ` ` `// of the same length` ` ` `if` `(arr1.length != arr2.length)` ` ` `return` `false` `;` ` ` ` ` `// Creates an empty hashMap hM` ` ` `HashMap<Integer, Integer> hM = ` `new` `HashMap<Integer, Integer>();` ` ` `// Traverse through the first array and add elements to hash map` ` ` `for` `(` `int` `i = ` `0` `; i < arr1.length; i++)` ` ` `{` ` ` `int` `x = arr1[i];` ` ` `if` `(hM.get(x) == ` `null` `)` ` ` `hM.put(x, ` `1` `);` ` ` `else` ` ` `{` ` ` `int` `k = hM.get(x);` ` ` `hM.put(x, k+` `1` `);` ` ` `}` ` ` `}` ` ` `// Traverse through second array and check if every element is` ` ` `// present in hash map` ` ` `for` `(` `int` `i = ` `0` `; i < arr2.length; i++)` ` ` `{` ` ` `int` `x = arr2[i];` ` ` `// If element is not present in hash map or element` ` ` `// is not present less number of times` ` ` `if` `(hM.get(x) == ` `null` `|| hM.get(x) == ` `0` `)` ` ` `return` `false` `;` ` ` `int` `k = hM.get(x);` ` ` `hM.put(x, k-` `1` `);` ` ` `}` ` ` `return` `true` `;` ` ` `}` ` ` `// Driver function to test above function` ` ` `public` `static` `void` `main(String arg[])` ` ` `{` ` ` `int` `arr1[] = {` `2` `, ` `1` `, ` `3` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `};` ` ` `int` `arr2[] = {` `3` `, ` `2` `, ` `2` `, ` `4` `, ` `5` `, ` `3` `, ` `1` `};` ` ` `if` `(arePermutations(arr1, arr2))` ` ` `System.out.println(` `"Arrays are permutations of each other"` `);` ` ` `else` ` ` `System.out.println(` `"Arrays are NOT permutations of each other"` `);` ` ` `}` `}` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to find one ` `# array is permutation of other array` `from` `collections ` `import` `defaultdict` `# Returns true if arr1[] and ` `# arr2[] are permutations of ` `# each other` `def` `arePermutations(arr1, arr2):` ` ` `# Arrays cannot be permutations of one another` ` ` `# unless they are of the same length` ` ` `if` `(` `len` `(arr1) !` `=` `len` `(arr2)):` ` ` `return` `False` ` ` ` ` `# Creates an empty hashMap hM` ` ` `hM ` `=` `defaultdict (` `int` `)` ` ` `# Traverse through the first ` ` ` `# array and add elements to ` ` ` `# hash map` ` ` `for` `i ` `in` `range` `(` `len` `(arr1)):` ` ` ` ` `x ` `=` `arr1[i]` ` ` `hM[x] ` `+` `=` `1` ` ` ` ` `# Traverse through second array ` ` ` `# and check if every element is` ` ` `# present in hash map` ` ` `for` `i ` `in` `range` `(` `len` `(arr2)):` ` ` `x ` `=` `arr2[i]` ` ` `# If element is not present ` ` ` `# in hash map or element` ` ` `# is not present less number ` ` ` `# of times` ` ` `if` `x ` `not` `in` `hM ` `or` `hM[x] ` `=` `=` `0` `:` ` ` `return` `False` ` ` `hM[x] ` `-` `=` `1` ` ` ` ` `return` `True` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` ` ` `arr1 ` `=` `[` `2` `, ` `1` `, ` `3` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `]` ` ` `arr2 ` `=` `[` `3` `, ` `2` `, ` `2` `, ` `4` `, ` `5` `, ` `3` `, ` `1` `]` ` ` `if` `(arePermutations(arr1, arr2)):` ` ` `print` `(` `"Arrays are permutations of each other"` `)` ` ` `else` `:` ` ` `print` `(` `"Arrays are NOT permutations of each other"` `)` ` ` `# This code is contributed by Chitranayal` |

*chevron_right*

*filter_none*

## C#

`// C# program to find one array` `// is permutation of other array` `using` `System;` `using` `System.Collections.Generic;` `public` `class` `Permutaions {` ` ` `// Returns true if arr1[] and arr2[]` ` ` `// are permutations of each other` ` ` `static` `Boolean arePermutations(` `int` `[] arr1, ` `int` `[] arr2)` ` ` `{` ` ` `// Arrays cannot be permutations of one another if` ` ` `// they are not the the same length` ` ` `if` `(arr1.Length != arr2.Length)` ` ` `return` `false` `;` ` ` `// Creates an empty hashMap hM` ` ` `Dictionary<` `int` `, ` `int` `> hM = ` `new` `Dictionary<` `int` `, ` `int` `>();` ` ` `// Traverse through the first array` ` ` `// and add elements to hash map` ` ` `for` `(` `int` `i = 0; i < arr1.Length; i++) {` ` ` `int` `x = arr1[i];` ` ` `if` `(!hM.ContainsKey(x))` ` ` `hM.Add(x, 1);` ` ` `else` `{` ` ` `int` `k = hM[x];` ` ` `hM.Remove(x);` ` ` `hM.Add(x, k + 1);` ` ` `}` ` ` `}` ` ` `// Traverse through second array and check if every` ` ` `// element is present in hash map (and the same` ` ` `// number of times)` ` ` `for` `(` `int` `i = 0; i < arr2.Length; i++) {` ` ` `int` `x = arr2[i];` ` ` `// If element is not present in hash map or` ` ` `// element is not present the same number of` ` ` `// times` ` ` `if` `(!hM.ContainsKey(x))` ` ` `return` `false` `; ` `// Not present in the hash map` ` ` `int` `k = hM[x];` ` ` `if` `(k == 0)` ` ` `return` `false` `; ` `// Not present the same number` ` ` `// of times` ` ` `hM.Remove(x);` ` ` `hM.Add(x, k - 1);` ` ` `}` ` ` `return` `true` `;` ` ` `}` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[] arr1 = { 2, 1, 3, 5, 4, 3, 2 };` ` ` `int` `[] arr2 = { 3, 2, 2, 4, 5, 3, 1 };` ` ` `if` `(arePermutations(arr1, arr2))` ` ` `Console.WriteLine(` `"Arrays are permutations of each other"` `);` ` ` `else` ` ` `Console.WriteLine(` `"Arrays are NOT permutations of each other"` `);` ` ` `}` `}` `/* This code contributed by PrinciRaj1992 */` |

*chevron_right*

*filter_none*

**Output**

Arrays are permutations of each other

The time complexity of this method is O(n) under the assumption that we have a hash function inserts and finds elements in O(1) time.

This article is contributed by **Ravi**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important Java and Collections concepts with the **Fundamentals of Java and Java Collections Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Check if two arrays are permutations of each other using Mathematical Operation
- Minimize count of given operations required to make two given strings permutations of each other
- Check if given string can be formed by two other strings or their permutations
- Stack Permutations (Check if an array is stack permutation of other)
- Generate all binary permutations such that there are more or equal 1's than 0's before every point in all permutations
- Check whether two Strings are Anagram of each other using HashMap in Java
- Check if two Integer are anagrams of each other
- C Program to check if two given strings are isomorphic to each other
- Minimize the sum of product of two arrays with permutations allowed
- Check if every pair of 1 in the array is at least K length apart from each other
- Check if all the pairs of an array are coprime with each other
- Check if a given array contains duplicate elements within k distance from each other
- Check if a Sequence is a concatenation of two permutations
- Count of permutations of an Array having each element as a multiple or a factor of its index
- Minimum number of swaps required for arranging pairs adjacent to each other
- Largest Divisor for each element in an array other than 1 and the number itself
- Count of pairs having each element equal to index of the other from an Array
- Permutations of string such that no two vowels are adjacent
- Print the two possible permutations from a given sequence
- Count of common subarrays in two different permutations of 1 to N