akuna capital oa

记得截图没过的test case啊！否则连复习改bug的证据都没了啊！！！

其实也不一定非得要拿面试来测试，做做lc的contest，看看自己哪里不会，也是一样的效果。

注意是单选题还是多选题

hashmap单词查重：实在是简单啊，为啥就只过了一半？

 = 1 和 2 的情况都会取出来。本来想给map写remove的，忘了怎么写了。唉。

// Complete the missingWords function below.
    static List<String> missingWords(String s, String t) {
        //initialization
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        //HashSet<String> set = new HashSet<String>();
        
        List<String> result = new ArrayList<String>();
        String[] s_words = s.split("\s+");
        String[] t_words = t.split("\s+");
        
        //add s
        for (int i = 0; i < s_words.length; i++) {
            map.put(s_words[i], 1);
        }
        
        //add t
        for (int j = 0; j < t_words.length; j++) {
            map.put(t_words[j], map.get(t_words[j]) + 1);
        }
        
        //return
        for (int i = 0; i < s_words.length; i++) {
            if (map.get(s_words[i]) == 1) {
                result.add(s_words[i]);
            }
        }
        return result;
    }

小孩跑步：实在是简单啊，为啥就只过了1/4？

class Result {

    /*
     * Complete the 'getMostVisited' function below.
     *
     * The function is expected to return an INTEGER.
     * The function accepts following parameters:
     *  1. INTEGER n
     *  2. INTEGER_ARRAY sprints
     */

    public static int getMostVisited(int n, List<Integer> sprints) {
    // Write your code here
        //initialization
        int[] count_steps = new int[n];
        Arrays.fill(count_steps, 0);
        
        //for loop
        for (int pos = 0; pos < sprints.size() - 1; pos++) {
            //smaller or bigger
            if (sprints.get(pos) < sprints.get(pos + 1)) {
                for (int i = sprints.get(pos); i < sprints.get(pos + 1); i++) {
                    count_steps[i]++;
                }
            }else {
                for (int i = sprints.get(pos + 1); i < sprints.get(pos); i++) {
                    count_steps[i]++;
                }
            }
        }
        
        //get max
        int max = count_steps[0];
        int index = 0;
        for (int i = 0; i < n; i++) {
            if (count_steps[i] > max) {
                max = count_steps[i];
                index = i;
            } 
            
        }
        
        //return
        return index;
    }

}

给钱多的人卖股票，返回没买到股票的交易id。完全没思路，我ri。

就是先sort出价，再sort时间戳，可惜我tm连怎么给list 排序都不会写……是用heap么？先复习这里，然后顺便想想吧。

写一个Comparator<Object>，然后强制转换为比较数组。

package labs;

import java.util.*;    

public class Example1 {    
    
    public static void sort(int[][] ob, final int[] order) {    
        Arrays.sort(ob, new Comparator<Object>() {    
            public int compare(Object o1, Object o2) {    
                int[] one = (int[]) o1;    
                int[] two = (int[]) o2;    
                for (int i = 0; i < order.length; i++) {    
                    int k = order[i];    
                    if (one[k] > two[k]) {    
                        return 1;    
                    } else if (one[k] < two[k]) {    
                        return -1;    
                    } else {    
                        continue;  //如果按一条件比较结果相等，就使用第二个条件进行比较。  
                    }    
                }    
                return 0;    
            }    
        });   
    }    
    
    public static void main(String[] args) {    
        int array[][] = new int[][] {     
                { 12, 34, 68, 32, 9, 12, 545 },     
                { 34, 72, 82, 57, 56, 0, 213 },     
                { 12, 34, 68, 32, 21, 945, 23 },     
                { 91, 10, 3, 2354, 73, 34, 18 },    
                { 12, 83, 189, 26, 27, 98, 33 },     
                { 47, 23, 889, 24, 899, 23, 657 },     
                { 12, 34, 68, 343, 878, 235, 768 },     
                { 12, 34, 98, 56, 78, 12, 546 },     
                { 26, 78, 2365, 78, 34, 256, 873 } };    
        sort(array, new int[] {0});   //先根据第一列比较，若相同则再比较第二列
        for (int i = 0; i < array.length; i++) {    
            for (int j = 0; j < array[i].length; j++) {    
                System.out.print(array[i][j]);    
                System.out.print("	");    
            }    
            System.out.println();    
        }    
    }    
}

先把heap背一下吧！别的基础数据结构，自己总结的那张纸，也要背。越熟练越好，贝多芬，只有脑子里的存货，考试才可以直接拿来用啊！临时查、临时理解是来不及的。

措施：把cheetsheet和mmp里重要的东西赶紧复习一遍，不做题 光默写都可以，脑子里多存点东西。有面试就赶紧面，没有的话继续刷题。方法是：限时，强迫自己写暴力解 不能光是看了答案之后背出来，这样测不出自己的水平。