AlgoPlan0608

#find common characters

##idea:
- create a hash table (using hashmap) for each word, and count the characters
- for each character in the first word, loop over each map to see if it is in the key set
- if it is in the key set, deduce the value by one till it is zero
- clear out each map
- when counting if one character appears in each map, count its appearance and return the count to zero after each character


class Solution {
    public List<String> commonChars(String[] words) {
        Map<Character, Integer> map = new HashMap();
        List<Map<Character,Integer>> list = new ArrayList();
        List<String> result = new ArrayList();
        for (String s: words){
            for (char c: s.toCharArray()){
                if (map.containsKey(c)){
                    map.put(c, map.get(c)+1);
                }else{
                    map.put(c,1);
                }
            }
            list.add(map);
            for (int k: map.values()){
                System.out.print(k+", ");
            }
            System.out.print(" // ");
            map = new HashMap();
        }
        int count = 0;
        for (char c: words[0].toCharArray()){
            for (Map<Character,Integer> wordmap: list){
                if (wordmap.containsKey(c) && wordmap.get(c) >0){
                    count++;
                    wordmap.put(c, wordmap.get(c)-1);
                }else{

                }
            }
            if (count == words.length) result.add(String.valueOf(c));
            count =0;
        }
        return result;
    }
}


#find intersection of arrays
##find intersection of int in both arrays.
- use the smaller array to store a map of num vs count
- loop over the second array and -- when found one

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if (nums1.length>nums2.length){
            intersect(nums2,nums1);
        }
        Map<Integer,Integer> map = new HashMap();
        for (int num: nums1){
            if(map.containsKey(num)){
                map.put(num,map.get(num)+1);
            }else{
                map.put(num,1);
            }
        }
        int count =0;
        List<Integer> alist = new ArrayList();
        for (int num: nums2){
            count = map.getOrDefault(num,0);
            if (count >0){
                alist.add(num);
                map.put(num, map.get(num)-1);
            }
        }
        int[] intersection = new int[alist.size()];
        for (int k =0; k <  alist.size();k++){
            intersection[k] = alist.get(k);
        }
        return intersection;
    }
}

#find intersection of two arrays (unique ones)

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1.length > nums2.length){
            intersection(nums2,nums1);
        }
        List<Integer> set= new ArrayList();
        for (int k : nums1){
            if (!set.contains(k)){
                set.add(k);
            }
        }
        
        Set<Integer> list = new HashSet();
        for (int j : nums2){
            if (set.contains(j) && !list.contains(j)){
                list.add(j);
            }
        }
        int m = 0;
        int[] result = new int[list.size()];
        for (int ele: list){
            result[m++] = ele;
        }
        return result;
    }
}

#count common strings in two arrays
##idea:
-use two hashmaps where the second one filter strings based on the first map
-count the number of one-occurence strings in the second map

class Solution {
    public int countWords(String[] words1, String[] words2) {
        //the shortest array
        if(words1.length > words2.length){
            countWords(words2, words1);
        }
        
        Map<String, Integer> words = new HashMap();
        for (String s: words1){
            if (!words.containsKey(s)){
                words.put(s, 1);
            }else{
                words.put(s,words.get(s)+1);
            }
        }
        Map<String, Integer> newmap = new HashMap();
        for (String k: words2){
            //if it only appears once in the first array
            if (words.containsKey(k) && words.get(k) ==1){
                //++ so the next time it hits the map,
                //it means it also appears in the second one
                if (newmap.containsKey(k)){
                    newmap.put(k, newmap.get(k)+1);
                }else{
                    newmap.put(k,1);
                }
            }
        }
        int count = 0;
        for (String k: newmap.keySet()){
            if (newmap.get(k)==1){
                count++;
            }
        }
        return count;
    }
}