Valid Anagram, Group Anagrams

Valid Anagram

Given two strings s and t, write a function to determine if t is an anagram of s.
For example,
s = “anagram”, t = “nagaram”, return true.
s = “rat”, t = “car”, return false.
Note:
You may assume the string contains only lowercase alphabets.

HashMap Solution

public static boolean isAnagram(String s, String t) {
    	s.toLowerCase();
    	t.toLowerCase();
    	if(s.length()!=t.length()) return false;
    	HashMap<Character, Integer> map=new HashMap<Character, Integer>();
    	for(int i=0; i<s.length();i++){
    		if(!map.containsKey(s.charAt(i))){
    			map.put(s.charAt(i), 1);
    		}
    		else map.put(s.charAt(i), map.get(s.charAt(i))+1);
    	}
    	for(int i=0;i<t.length();i++){
    		if(map.containsKey(t.charAt(i))){
    			if(map.get(t.charAt(i))>=1){
    				map.put(t.charAt(i), map.get(t.charAt(i))-1);
    			}
    			else return false;
    		}
    		else if(!map.containsKey(t.charAt(i))) return false;
    	}
    	return true;  	
    }

Sort Solution

public boolean isAnagramSort(String s, String t) {
        if (s == null || t == null) {
            return (s == null && t == null) ? true : false;
        }
        if (s.equals(t)) {
            return true;
        }
        if (s.length() != t.length()) {
            return false;
        }

        char[] s1 = s.toCharArray();
        char[] t1 = t.toCharArray();

        Arrays.sort(s.toCharArray());
        Arrays.sort(t.toCharArray());

        return  new String(s1).equals(new String(t1)) ? true : false;
    }

---

Group Anagrams

Given an array of strings, group anagrams together.
For example, given: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”],
Return:
[
[“ate”, “eat”,”tea”],
[“nat”,”tan”],
[“bat”]
]
Note:
For the return value, each inner list’s elements must follow the lexicographic order.
All inputs will be in lower-case.

Sort + Hashmap Solution

public static List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List<String>> dict = new HashMap<String, List<String>>();
        for (int i = 0; i < strs.length; i++) {
            String s = strs[i];
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String sortedString = String.valueOf(chars);

            if (dict.containsKey(sortedString)) {
                dict.get(sortedString).add(s);
            } else {
                List<String> list = new ArrayList<String>();
                list.add(s);
                dict.put(sortedString, list);
            }
        }
        List<List<String>> res = new ArrayList<List<String>>();
        for (List<String> list : dict.values()) {
            if (list.size() >= 1)
                Collections.sort(list);
                res.add(list);
        }
        return res;
    }