Anagrams

Given an array of strings, return all groups of strings that are anagrams.

Note: All inputs will be in lower-case.

10/31

Solutions:

The key is to map all the anagrams to the same code, which can be another string or integer, etc.

Keep that in a hashmap and when the code is hit again, we know that an anagram has shown before.

public class Solution {
    public List<String> anagrams(String[] strs) {
        Map<String,String> map = new HashMap<String,String>();
        List<String> ans = new ArrayList<String>();
        for(String s: strs){
            String code = codeStr(s);
            String found = map.get(code);
            if(found == null){
                map.put(code,s);
            }else{
                if(!found.equals("@")){ // note that none of the input strings has special characters
                // so @ can be used to label that the first occurance of that string has been included.
                    ans.add(found);
                    map.put(code,"@");
                }
                ans.add(s);
            }
            
        }
        return ans;
    }
    
    
    private String codeStr(String s){
        int[] cnt = new int[26];
        int len = s.length();
        for(int i=0; i<len; i++){
            char ch = s.charAt(i);
            cnt[ch-'a'] ++;
        }
        StringBuffer buf = new StringBuffer();
        for(int x: cnt){
            buf.append(x);
            buf.append(' ');
        }
        return buf.toString();
    }
}

The time complexity is O(mn), where m is the length of the longest word

scan each word and convert to the code, look up in hashmap and add to the answer

The space complexity is O(mn), the worse case is No Anagrams at all, and m is the space it takes to store the code of the longest word.