trjhtr

Given two strings, check whether two given strings are anagram of each
other or not. An anagram of a string is another string that contains
same characters, only the order of characters can be different. For
example, “act” and “tac” are anagram of each other.

Input:

The first line of input contains an integer T denoting the number of
test cases. Each test case consist of two strings in 'lowercase' only,
in a separate line.

Output:

Print "YES" without quotes if the two strings are anagram else print
"NO".

Constraints:

1 ≤ T ≤ 30

1 ≤ |s| ≤ 100

Example:

Input:

2

geeksforgeeks

forgeeksgeeks

allergy

allergic

Output:

YES

NO

My approach:

/*package whatever //do not write package name here */

import java.util.Scanner;
import java.io.IOException;
import java.util.HashMap;

class GFG 

 private static String isAnagram (String str1, String str2)
 
 HashMap <Character, Integer>occurs = new HashMap<>();

 if (str1.length() != str2.length())
 
 return "NO";
 

 for (char ch: str1.toCharArray())
 
 if (!(occurs.containsKey(ch)))
 
 occurs.put(ch,1);
 
 else
 
 int count = occurs.get(ch);
 occurs.put(ch,count + 1);
 
 

 for (char ch: str2.toCharArray())
 
 if (!(occurs.containsKey(ch)))
 
 return "NO";
 
 else
 
 int count = occurs.get(ch);
 count = count - 1;
 if (count < 0)
 
 return "NO";
 
 else
 
 occurs.put(ch,count);
 
 
 

 return "YES"; 
 

 public static void main (String args) throws IOException 
 Scanner sc = new Scanner (System.in);
 int numTests = sc.nextInt();

 for (int i = 0; i < numTests; i++)
 
 String str1 = sc.next();
 String str2 = sc.next();
 System.out.println(isAnagram(str1, str2));
 
 

I have the following questions with regards to the above code:

1) How can I further improve my approach?

2) Is there a better way to solve this question?

3) Are there any grave code violations that I have committed?

4) Can space and time complexity be further improved?

Reference

Your use of the counting system using a HashMap is a functional approach to solving the problem, and algorithmically it's relatively good (has time complexity of $O(N)$). But, for a prolem like this, it's easier to normalize each input value in to a sorted array or string, than in to a counting HashMap.

Consider the following function:

public static final String normalize(value) 
 if (value == null) 
 return null;
 
 char chars = value.toCharArray();
 Arrays.sort(chars);
 return new String(chars);

Now, all values that are anagrams will have the same normalize result (they have the same characters in the same sorted order).

Your code would simply become:

private static String isAnagram (String str1, String str2) 
 return Objects.equals(normalize(str1), normalize(str2));

Note that in this case, Objects is java.util.Objects.

Further, by putting the normalization in to a separate function it reduces the amount of logic duplication in your code.

Now, you ask if there are any grave violations... and I have to answer "yes". In Java it is common practice to put { braces on the same line as the code block definition. For example your code:

 for (char ch: str1.toCharArray())
 
 if (!(occurs.containsKey(ch)))
 
 occurs.put(ch,1);
 
 else
 
 int count = occurs.get(ch);
 occurs.put(ch,count + 1);
 
 

should be:

 for (char ch: str1.toCharArray()) 
 if (!(occurs.containsKey(ch))) 
 occurs.put(ch,1);
 else 
 int count = occurs.get(ch);
 occurs.put(ch,count + 1);