Given two strings. The task is to check whether the given strings are anagrams of each other or not.
An anagram of a string is another string that contains the same characters, only the order of characters can be different. For example, “abcd” and “dabc” are an anagram of each other.
Examples:
Input: str1 = “listen” str2 = “silent”
Output: “Anagram”
Explanation: All characters of “listen” and “silent” are the same.
Input: str1 = “gram” str2 = “arm”
Output: “Not Anagram”
Check whether two strings are anagrams of each other using sorting
Sort the two given strings and compare, if they are equal then they are anagram of each other.
- Sort both strings.
- Compare the sorted strings:
- If they are equal return True.
- Else return False.
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
bool areAnagram(string str1, string str2)
{
int n1 = str1.length();
int n2 = str2.length();
if (n1 != n2)
return false ;
sort(str1.begin(), str1.end());
sort(str2.begin(), str2.end());
for ( int i = 0; i < n1; i++)
if (str1[i] != str2[i])
return false ;
return true ;
}
int main()
{
string str1 = "gram" ;
string str2 = "arm" ;
if (areAnagram(str1, str2))
cout << "The two strings are anagram of each other" ;
else
cout << "The two strings are not anagram of each "
"other" ;
return 0;
}
|
Java
import java.io.*;
import java.util.Arrays;
import java.util.Collections;
class GFG {
static boolean areAnagram( char [] str1, char [] str2)
{
int n1 = str1.length;
int n2 = str2.length;
if (n1 != n2)
return false ;
Arrays.sort(str1);
Arrays.sort(str2);
for ( int i = 0 ; i < n1; i++)
if (str1[i] != str2[i])
return false ;
return true ;
}
public static void main(String args[])
{
char str1[] = { 'g' , 'r' , 'a' , 'm' };
char str2[] = { 'a' , 'r' , 'm' };
if (areAnagram(str1, str2))
System.out.println( "The two strings are"
+ " anagram of each other" );
else
System.out.println( "The two strings are not"
+ " anagram of each other" );
}
}
|
Python
class Solution:
def isAnagram( self , a, b):
if sorted (a) = = sorted (b):
return True
else :
return False
if __name__ = = '__main__' :
a = "gram"
b = "arm"
if (Solution().isAnagram(a, b)):
print ( "The two strings are anagram of each other" )
else :
print ( "The two strings are not anagram of each other" )
|
C#
using System;
using System.Collections;
class GFG {
public static bool areAnagram(ArrayList str1,
ArrayList str2)
{
int n1 = str1.Count;
int n2 = str2.Count;
if (n1 != n2) {
return false ;
}
str1.Sort();
str2.Sort();
for ( int i = 0; i < n1; i++) {
if (str1[i] != str2[i]) {
return false ;
}
}
return true ;
}
public static void Main( string [] args)
{
ArrayList str1 = new ArrayList();
str1.Add( 'g' );
str1.Add( 'r' );
str1.Add( 'a' );
str1.Add( 'm' );
ArrayList str2 = new ArrayList();
str2.Add( 'a' );
str2.Add( 'r' );
str2.Add( 'm' );
if (areAnagram(str1, str2)) {
Console.WriteLine( "The two strings are"
+ " anagram of each other" );
}
else {
Console.WriteLine( "The two strings are not"
+ " anagram of each other" );
}
}
}
|
Javascript
<script>
function areAnagram(str1,str2)
{
let n1 = str1.length;
let n2 = str2.length;
if (n1 != n2)
return false ;
str1.sort();
str2.sort()
for (let i = 0; i < n1; i++)
if (str1[i] != str2[i])
return false ;
return true ;
}
let str1=[ 'g' , 'r' , 'a' , 'm' ];
let str2=[ 'a' , 'r' , 'm' ];
if (areAnagram(str1, str2))
document.write( "The two strings are"
+ " anagram of each other<br>" );
else
document.write( "The two strings are not"
+ " anagram of each other<br>" );
</script>
|
OutputThe two strings are not anagram of each other
Time Complexity: O(N * logN), For sorting.
Auxiliary Space: O(1) as it is using constant extra space
Check whether two strings are anagrams of each other by using std::string::compare() function
Below is the idea to solve the problem:
1. Use Sort() function to sort both the strings a and b.
2. Use Compare() function to compare between strings a and b.
C++
#include <bits/stdc++.h>
using namespace std;
int isAnagram(string a, string b){
int flag=0;
sort(a.begin(),a.end());
sort(b.begin(),b.end());
if (a.compare(b)==0){
flag=1;
}
else {
flag=0;
}
return flag;
}
int main() {
string a= "geeksforgeeks" ;
string b= "forgeeksgeeks" ;
if (isAnagram(a,b)==1)
cout<< "YES, They are Anagram" <<endl;
else
cout<< "NO, They are not Anagram" <<endl;
return 0;
}
|
Java
import java.util.Arrays;
public class Main {
static boolean isAnagram(String a, String b)
{
char [] arrA = a.toCharArray();
char [] arrB = b.toCharArray();
Arrays.sort(arrA);
Arrays.sort(arrB);
return Arrays.equals(arrA, arrB);
}
public static void main(String[] args)
{
String a = "geeksforgeeks" ;
String b = "forgeeksgeeks" ;
if (isAnagram(a, b)) {
System.out.println( "YES, They are Anagram" );
}
else {
System.out.println( "NO, They are not Anagram" );
}
}
}
|
Python
def is_anagram(a, b):
sorted_a = sorted (a)
sorted_b = sorted (b)
if sorted_a = = sorted_b:
return True
else :
return False
if __name__ = = "__main__" :
a = "geeksforgeeks"
b = "forgeeksgeeks"
if is_anagram(a, b):
print ( "YES, They are Anagram" )
else :
print ( "NO, They are not Anagram" )
|
C#
using System;
class GFG {
static int IsAnagram( string a, string b)
{
int flag = 0;
char [] charArrayA = a.ToCharArray();
char [] charArrayB = b.ToCharArray();
Array.Sort(charArrayA);
Array.Sort(charArrayB);
string sortedA = new string (charArrayA);
string sortedB = new string (charArrayB);
if (sortedA.Equals(sortedB))
flag = 1;
else
flag = 0;
return flag;
}
static void Main( string [] args)
{
string a = "geeksforgeeks" ;
string b = "forgeeksgeeks" ;
if (IsAnagram(a, b) == 1)
Console.WriteLine( "YES, They are anagrams" );
else
Console.WriteLine( "NO, They are not anagrams" );
}
}
|
Javascript
function GFG(a, b) {
let flag = 0;
a = a.split( '' ).sort().join( '' );
b = b.split( '' ).sort().join( '' );
if (a === b) {
flag = 1;
} else {
flag = 0;
}
return flag;
}
const a = "geeksforgeeks" ;
const b = "forgeeksgeeks" ;
if (GFG(a, b) === 1) {
console.log( "YES, They are Anagram" );
} else {
console.log( "NO, They are not Anagram" );
}
|
OutputYES, They are Anagram
Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.
Check whether two strings are anagrams of each other by counting frequency:
The idea is based in an assumption that the set of possible characters in both strings is small. that the characters are stored using 8 bit and there can be 256 possible characters.
So count the frequency of the characters and if the frequency of characters in both strings are the same, they are anagram of each other.
Follow the below steps to Implement the idea:
- Create count arrays of size 256 for both strings. Initialize all values in count arrays as 0.
- Iterate through every character of both strings and increment the count of characters in the corresponding count arrays.
- Compare count arrays. If both count arrays are the same, then return true else return false.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define NO_OF_CHARS 256
bool areAnagram( char * str1, char * str2)
{
int count1[NO_OF_CHARS] = { 0 };
int count2[NO_OF_CHARS] = { 0 };
int i;
for (i = 0; str1[i] && str2[i]; i++) {
count1[str1[i]]++;
count2[str2[i]]++;
}
if (str1[i] || str2[i])
return false ;
for (i = 0; i < NO_OF_CHARS; i++)
if (count1[i] != count2[i])
return false ;
return true ;
}
int main()
{
char str1[] = "gram" ;
char str2[] = "arm" ;
if (areAnagram(str1, str2))
cout << "The two strings are anagram of each other" ;
else
cout << "The two strings are not anagram of each "
"other" ;
return 0;
}
|
C
#include <stdio.h>
#define NO_OF_CHARS 256
bool areAnagram( char * str1, char * str2)
{
int count1[NO_OF_CHARS] = { 0 };
int count2[NO_OF_CHARS] = { 0 };
int i;
for (i = 0; str1[i] && str2[i]; i++) {
count1[str1[i]]++;
count2[str2[i]]++;
}
if (str1[i] || str2[i])
return false ;
for (i = 0; i < NO_OF_CHARS; i++)
if (count1[i] != count2[i])
return false ;
return true ;
}
int main()
{
char str1[] = "gram" ;
char str2[] = "arm" ;
if (areAnagram(str1, str2))
printf ( "The two strings are anagram of each other" );
else
printf ( "The two strings are not anagram of each "
"other" );
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
static int NO_OF_CHARS = 256 ;
static boolean areAnagram( char str1[], char str2[])
{
int count1[] = new int [NO_OF_CHARS];
Arrays.fill(count1, 0 );
int count2[] = new int [NO_OF_CHARS];
Arrays.fill(count2, 0 );
int i;
for (i = 0 ; i < str1.length && i < str2.length;
i++) {
count1[str1[i]]++;
count2[str2[i]]++;
}
if (str1.length != str2.length)
return false ;
for (i = 0 ; i < NO_OF_CHARS; i++)
if (count1[i] != count2[i])
return false ;
return true ;
}
public static void main(String args[])
{
char str1[] = ( "gram" ).toCharArray();
char str2[] = ( "arm" ).toCharArray();
if (areAnagram(str1, str2))
System.out.println( "The two strings are"
+ " anagram of each other" );
else
System.out.println( "The two strings are not"
+ " anagram of each other" );
}
}
|
Python
NO_OF_CHARS = 256
def areAnagram(str1, str2):
count1 = [ 0 ] * NO_OF_CHARS
count2 = [ 0 ] * NO_OF_CHARS
for i in str1:
count1[ ord (i)] + = 1
for i in str2:
count2[ ord (i)] + = 1
if len (str1) ! = len (str2):
return 0
for i in xrange (NO_OF_CHARS):
if count1[i] ! = count2[i]:
return 0
return 1
str1 = "gram"
str2 = "arm"
if areAnagram(str1, str2):
print "The two strings are anagram of each other"
else :
print "The two strings are not anagram of each other"
|
C#
using System;
public class GFG {
static int NO_OF_CHARS = 256;
static bool areAnagram( char [] str1, char [] str2)
{
int [] count1 = new int [NO_OF_CHARS];
int [] count2 = new int [NO_OF_CHARS];
int i;
for (i = 0; i < str1.Length && i < str2.Length;
i++) {
count1[str1[i]]++;
count2[str2[i]]++;
}
if (str1.Length != str2.Length)
return false ;
for (i = 0; i < NO_OF_CHARS; i++)
if (count1[i] != count2[i])
return false ;
return true ;
}
public static void Main()
{
char [] str1 = ( "gram" ).ToCharArray();
char [] str2 = ( "arm" ).ToCharArray();
if (areAnagram(str1, str2))
Console.WriteLine( "The two strings are"
+ " anagram of each other" );
else
Console.WriteLine( "The two strings are not"
+ " anagram of each other" );
}
}
|
Javascript
<script>
let NO_OF_CHARS = 256;
function areAnagram(str1, str2)
{
let count1 = new Array(NO_OF_CHARS);
let count2 = new Array(NO_OF_CHARS);
for (let i = 0; i < NO_OF_CHARS; i++)
{
count1[i] = 0;
count2[i] = 0;
}
let i;
for (i = 0; i < str1.length && i < str2.length;
i++) {
count1[str1[i].charCodeAt(0)]++;
count2[str1[i].charCodeAt(0)]++;
}
if (str1.length != str2.length)
return false ;
for (i = 0; i < NO_OF_CHARS; i++)
if (count1[i] != count2[i])
return false ;
return true ;
}
let str1 = ( "gram" ).split( "" );
let str2 = ( "arm" ).split( "" );
if (areAnagram(str1, str2))
document.write( "The two strings are"
+ "anagram of each other<br>" );
else
document.write( "The two strings are not"
+ " anagram of each other<br>" );
</script>
|
OutputThe two strings are not anagram of each other
Time Complexity: O(n)
Auxiliary Space: O(256) i.e. O(1) for constant space.
Check whether two strings are anagrams of each other using one count array:
Below is the idea to solve the problem:
The above can be modified to use only one count array instead of two. Increment the value in count array for characters in str1 and decrement for characters in str2. Finally, if all count values are 0, then the two strings are anagram of each other.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define NO_OF_CHARS 256
bool areAnagram( char * str1, char * str2)
{
int count[NO_OF_CHARS] = { 0 };
int i;
for (i = 0; str1[i] && str2[i]; i++) {
count[str1[i]]++;
count[str2[i]]--;
}
if (str1[i] || str2[i])
return false ;
for (i = 0; i < NO_OF_CHARS; i++)
if (count[i])
return false ;
return true ;
}
int main()
{
char str1[] = "gram" ;
char str2[] = "arm" ;
if (areAnagram(str1, str2))
cout << "The two strings are anagram of each other" ;
else
cout << "The two strings are not anagram of each "
"other" ;
return 0;
}
|
Java
class GFG{
static int NO_OF_CHARS = 256 ;
static boolean areAnagram( char [] str1,
char [] str2)
{
int [] count = new int [NO_OF_CHARS];
int i;
if (str1.length != str2.length)
return false ;
for (i = 0 ; i < str1.length; i++)
{
count[str1[i]]++;
count[str2[i]]--;
}
for (i = 0 ; i < NO_OF_CHARS; i++)
if (count[i] != 0 )
{
return false ;
}
return true ;
}
public static void main(String[] args)
{
char str1[] = "gram" .toCharArray();
char str2[] = "arm" .toCharArray();
if (areAnagram(str1, str2))
System.out.print( "The two strings are " +
"anagram of each other" );
else
System.out.print( "The two strings are " +
"not anagram of each other" );
}
}
|
Python3
NO_OF_CHARS = 256
def areAnagram(str1,str2):
if ( len (str1) ! = len (str2)):
return False ;
count = [ 0 for i in range (NO_OF_CHARS)]
i = 0
for i in range ( len (str1)):
count[ ord (str1[i]) - ord ( 'a' )] + = 1 ;
count[ ord (str2[i]) - ord ( 'a' )] - = 1 ;
for i in range (NO_OF_CHARS):
if (count[i] ! = 0 ):
return False
return True
str1 = "gram"
str2 = "arm"
if (areAnagram(str1, str2)):
print ( "The two strings are anagram of each other" )
else :
print ( "The two strings are not anagram of each other" )
|
C#
using System;
class GFG{
static int NO_OF_CHARS = 256;
static bool areAnagram( char [] str1,
char [] str2)
{
if (str1.Length != str2.Length)
return false ;
int [] count = new int [NO_OF_CHARS];
int i;
for (i = 0; i < str1.Length; i++)
{
count[str1[i] - 'a' ]++;
count[str2[i] - 'a' ]--;
}
for (i = 0; i < NO_OF_CHARS; i++)
if (count[i] != 0)
{
return false ;
}
return true ;
}
public static void Main(String []args)
{
char []str1 = "gram" .ToCharArray();
char []str2 = "arm" .ToCharArray();
if (areAnagram(str1, str2))
Console.Write( "The two strings are " +
"anagram of each other" );
else
Console.Write( "The two strings are " +
"not anagram of each other" );
}
}
|
Javascript
<script>
let NO_OF_CHARS = 256;
function areAnagram(str1, str2)
{
if (str1.length != str2.length)
return false ;
let count = new Array(NO_OF_CHARS);
for (let i = 0; i < NO_OF_CHARS; i++)
{
count[i] = 0;
}
let i;
for (i = 0; i < str1.length; i++)
{
count[str1[i].charCodeAt(0) - 'a' .charCodeAt(0)]++;
count[str2[i].charCodeAt(0) - 'a' .charCodeAt(0)]--;
}
for (i = 0; i < NO_OF_CHARS; i++)
if (count[i] != 0)
{
return false ;
}
return true ;
}
let str1 = "gram" .split( "" );
let str2 = "arm" .split( "" );
if (areAnagram(str1, str2))
document.write( "The two strings are " +
"anagram of each other" );
else
document.write( "The two strings are " +
"not anagram of each other" );
</script>
|
OutputThe two strings are not anagram of each other
Time Complexity: O(n)
Auxiliary Space: O(256) i.e. O(1), As constant space is used
Thanks to Ace for suggesting this optimization.
Check whether two strings are anagrams of each other by storing all characters in HashMap
Below is the idea to solve the problem:
The idea is a modification of the above approach where instead of creating an array of 256 characters HashMap is used to store characters and count of characters in HashMap. Idea is to put all characters of one String in HashMap and reduce them as they are encountered while looping over other the string.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isAnagram(string a, string b)
{
if (a.length() != b.length()) {
return false ;
}
unordered_map< char , int > Map;
for ( int i = 0; i < a.length(); i++) {
Map[a[i]]++;
}
for ( int i = 0; i < b.length(); i++) {
if (Map.find(b[i]) != Map.end()) {
Map[b[i]] -= 1;
}
else {
return false ;
}
}
for ( auto items : Map) {
if (items.second != 0) {
return false ;
}
}
return true ;
}
int main()
{
string str1 = "gram" ;
string str2 = "arm" ;
if (isAnagram(str1, str2))
cout << "The two strings are anagram of each other"
<< endl;
else
cout << "The two strings are not anagram of each "
"other"
<< endl;
}
|
Java
import java.io.*;
import java.util.*;
class GFG {
public static boolean isAnagram(String a, String b)
{
if (a.length() != b.length()) {
return false ;
}
HashMap<Character, Integer> map = new HashMap<>();
for ( int i = 0 ; i < a.length(); i++) {
if (map.containsKey(a.charAt(i))) {
map.put(a.charAt(i),
map.get(a.charAt(i)) + 1 );
}
else {
map.put(a.charAt(i), 1 );
}
}
for ( int i = 0 ; i < b.length(); i++) {
if (map.containsKey(b.charAt(i))) {
map.put(b.charAt(i),
map.get(b.charAt(i)) - 1 );
}
else {
return false ;
}
}
Set<Character> keys = map.keySet();
for (Character key : keys) {
if (map.get(key) != 0 ) {
return false ;
}
}
return true ;
}
public static void main(String[] args)
{
String str1 = "gram" ;
String str2 = "arm" ;
if (isAnagram(str1, str2))
System.out.print( "The two strings are "
+ "anagram of each other" );
else
System.out.print( "The two strings are "
+ "not anagram of each other" );
}
}
|
Python3
def isAnagram(a, b):
if ( len (a) ! = len (b)):
return False
map = {}
for i in range ( len (a)):
if (a[i] in map ):
map [a[i]] + = 1
else :
map [a[i]] = 1
for i in range ( len (b)):
if (b[i] in map ):
map [b[i]] - = 1
else :
return False
keys = map .keys()
for key in keys:
if ( map [key] ! = 0 ):
return False
return True
str1 = "gram"
str2 = "arm"
if (isAnagram(str1, str2)):
print ( "The two strings are anagram of each other" )
else :
print ( "The two strings are not anagram of each other" )
|
C#
using System;
using System.Collections.Generic;
public class GFG {
public static bool isAnagram(String a, String b)
{
if (a.Length != b.Length) {
return false ;
}
Dictionary< char , int > map
= new Dictionary< char , int >();
for ( int i = 0; i < a.Length; i++) {
if (map.ContainsKey(a[i])) {
map[a[i]] = map[a[i]] + 1;
}
else {
map.Add(a[i], 1);
}
}
for ( int i = 0; i < b.Length; i++) {
if (map.ContainsKey(b[i])) {
map[b[i]] = map[b[i]] - 1;
}
else {
return false ;
}
}
var keys = map.Keys;
foreach ( char key in keys)
{
if (map[key] != 0) {
return false ;
}
}
return true ;
}
public static void Main(String[] args)
{
String str1 = "gram" ;
String str2 = "arm" ;
if (isAnagram(str1, str2))
Console.Write( "The two strings are "
+ "anagram of each other" );
else
Console.Write( "The two strings are "
+ "not anagram of each other" );
}
}
|
Javascript
<script>
function isAnagram(a, b)
{
if (a.length != b.length) {
return false ;
}
let map = new Map();
for (let i = 0; i < a.length; i++) {
if (map.has(a[i])) {
map.set(a[i],
map.get(a[i]) + 1);
}
else {
map.set(a[i], 1);
}
}
for (let i = 0; i < b.length; i++) {
if (map.has(b[i])) {
map.set(b[i],
map.get(b[i]) - 1);
}
else {
return false ;
}
}
let keys = map.keys();
for (let key of keys) {
if (map.get(key) != 0) {
return false ;
}
}
return true ;
}
let str1 = "gram" ;
let str2 = "arm" ;
if (isAnagram(str1, str2))
document.write( "The two strings are anagram of each other" );
else
document.write( "The two strings are not anagram of each other" );
</script>
|
OutputThe two strings are not anagram of each other
Time Complexity: O(N)
Auxiliary Space: O(N), Hashmap uses an extra space
Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.