Hackerrank: Sherlock and Anagrams

Problem description: <https://www.hackerrank.com/challenges/sherlock-and-anagrams>

Adding a snapshot of the problem statement:

I am getting only few test cases correct. My algorithm is:
<ol>
<li>Find all substrings of given string.
<li>create code for each substring by using array for each alphabet.
<li>converting that code to string and map that string using hashmap.
<li>increment result if a substring's map value contains non zero value.
</ol>
My code:

 static int sherlockAndAnagrams(String s) {
 HashMap<String,Integer> map = new HashMap<String,Integer>();
 int d,i,k=0;
 int length = s.length();
 int n = length*(length+1)/2;
 String []sub = new String[n]; 
 for (d = 0; d < length; d++){
     for(i = d+1; i <= length; i++)
      {
        sub[k++] = s.substring(d, i);
      }
  }
int []c = new int[26];

  int result=0;;
for(int l=0;l<n;l++){
    for(int m=0;m<25;m++){
    c[m] = 0;
    }
   char []suba = sub[l].toCharArray();  
  for(char ch : suba){
      c[ch-'a']+=1;
  }
  String temp = Arrays.toString(c);
  Integer x = map.get(temp);
  if(x!=null){
      result = result+x;
    map.put(temp,++x);}
  else{
  map.put(temp,1);
   }
  }
  return result;
}

Ok, so a couple of things here.

• You have to count pairs and not how many collide.

• So, it would be result = result + x;

• Also, map.put(...,x++) should be map.put(...,++x); as we are going to update with a pre-incremented value.

• Also, your filling of c goes from 0 to 24 but it should be 0 to 25. It's a better practice to just do Arrays.fill(c,0) for that matter.

For space efficiency, we can completely avoid taking each subarray in an array and rather just sort the subarray based on characters. This way, every anagram will map to the same key in the map, helping you to avoid storing each array explicitly in the sub string array. However, the overall space complexity would remain the same.