刷题刷的好心累

kanmianjing899 发表于 2022-01-09 01:55:18
我现在跟你的感觉差不多，有的题能看出是啥tag但是写还是写不出。

楼主500题已经刷了4遍啦 hot tag基本都是6-9遍而且已经上岸啦～虽然没怎么见过的新题依然不是很会，经常写错，但是见过的一定能做对，并且followup也能答，所以只面了考原题那些公司，结果也还不错

这里是我马甲呀 发表于 2022-01-09 08:36:31
楼主500题已经刷了4遍啦 hot tag基本都是6-9遍而且已经上岸啦～虽然没怎么见过的新题依然不是很会，经常写错，但是见过的一定能做对，并且followup也能答，所以只面了考原题那些公司，结果也

谢谢，还想问下你是什么签证上的岸？f1还是h4还是绿卡？我是个小f1。

kanmianjing899 发表于 2022-01-09 15:16:53
谢谢，还想问下你是什么签证上的岸？f1还是h4还是绿卡？我是个小f1。

这个帖子发的时候是f1 opt，两个月不到就上岸啦不过公司特别小基本没人认识那种，抽到h1b就跳到了fb现在，从小公司到fb期间都一直在刷（背题）

这里是我马甲呀 发表于 2022-01-09 16:23:02
这个帖子发的时候是f1 opt，两个月不到就上岸啦不过公司特别小基本没人认识那种，抽到h1b就跳到了fb现在，从小公司到fb期间都一直在刷（背题）

听你说了我又有些信心了哈哈。最后问一下你全职前有实习过么？

kanmianjing899 发表于 2022-01-09 16:25:28
听你说了我又有些信心了哈哈。最后问一下你全职前有实习过么？

说实话，就我这刷题水平上岸大概率也是靠去年好市场和攒的人品加comminication还算好捞来的好运气，除了那小厂几道题我都是刷过的原题，其他的面试一个也没过因为题真的不会，就面试官都快告诉我答案了我都写不上，我是转码的之前有实习但是跟cs没什么关系叻

“用行动上的勤奋来掩饰战术上的懒惰”。。。 戳中我了，膝盖疼

重點要搞懂題目, 海刷戰術不見得適合所有人

1. 你对刷题是不是有误解？
2. 我建议你看看这个： https://www.zhihu.com/question/24051063
3. 大部份人是慢思维，至少我是
4. 你应该用几天的时间刷一道题
5. 你有没有想过为什么他们叫你一道题刷几十遍？就是记不住才刷几十遍。就是说刷一次的功效极低， 才要重复。
6. 你再看看这个。每一行代码都ask why. 问得越深越好。你一次就记住了. 你为什么看答案的时候要ask why, 因为你自己写的时候就像dfs, 会有n步骤， 你会开始confuse, swing, 也不知道写什么，为什么要写？
7. so you have to deep thinking for each line of code

e.g. https://leetcode.com/problems/minesweeper/

1. /**
   
2. * @param {character[][]} board
   
3. * @param {number[]} click
   
4. * @return {character[][]}
   
5. */
   
6. 
   
7. var dfs = function(d, b, click) {
   
8.     // * why the cell in board is the underneath actual value? <----
   
9.     // * because if we know the actual value, we can display the value in the board for user
   
10.    
    
11.     // * why click has row and col? <---
    
12.     // * because it is the start position in the grid
    
13.     const r = click[0];
    
14.     const c = click[1];
    
15.     // * this is row, go down
    
16.     const m = b.length;
    
17.     // * this is col, go right
    
18.     const n = b[0].length;
    
19.    
    
20.     let mNum = 0;
    
21.     // * why the dfs queue arr is empty at each dfs level? <---
    
22.     // * because next dfs level, the click will have its own dfs queue
    
23.     // * because 8 directions, cause it own queue, in own dfs level
    
24.     const empty = [];
    
25.    
    
26.     // * why do we hit the directions straight away, there is no loop to travel? <---
    
27.     // * yes, because there is no loop here, so only direction
    
28.    
    
29.     // * if we click a cell, the direction is like a sum with diff direciton of shine, why? <---
    
30.     // * because the middle is the central cell, then 8 directions are the shines
    
31.    
    
32.     // * why we loop the 8 directions? <---
    
33.     // * because click 1 spot, we will hit all 8 directions
    
34.     // * it can be 4 directions or an upgrade: 8 directions
    
35.     for(let [r1, c1] of d) {
    
36.         // * why we need row = curr_row + row_d, col = curr_col + col_d? <---
    
37.         // * because after loop each direction, we have a new move
    
38.         // * we can check boundary with this new move
    
39.         const r2 = r + r1;
    
40.         const c2 = c + c1;
    
41.         
    
42.         // * so this is to check the future boundary
    
43.         if(r2 < 0 || c2 < 0 || r2 >= m || c2 >= n) continue;
    
44.         
    
45.         // * why we only check boundary, we don't have other condi to check? <--
    
46.         // * because after boundary check pass, we will hit mine (M, acc), E (empty, queue), B (blank, seen),
    
47.         // * D (digit, seen), X (reveal, never)
    
48.         // * why we don't need seen here? <---
    
49.         // * because there is no cycle;
    
50.         // * seen good for cycle
    
51.         
    
52.         // * why we need to care mine (M = mine)? <---
    
53.         // * because if we acc all 8 directions, we know the total mine number, so we can assign to start point????????
    
54.         // * why we need to care empty square (E = empty)? <---
    
55.         // * because if we see empty (E), then we can push to arr, then loop this arr -> dfs
    
56.         // * this allow new start point for dfs
    
57.         // * why we don't care revealved square (B = blank)? <--
    
58.         // * because already know before
    
59.         // * not contribute to acc mine or dfs queue
    
60.         // * why we don't care digit? (D = digit)? <--
    
61.         // * because already know before
    
62.         // * not contribute to acc mine or dfs queue
    
63.         // * why we don't care revealed mine (X = explode)? <--
    
64.         // * I don't think we will see this, if we see explode, then it is game over
    
65.         // * the game still going so no care revealed.
    
66.         
    
67.         if(b[r2][c2] === 'M') {
    
68.             // * why acc mine num? <---
    
69.             // * because we need to asssgin to start point
    
70.             // * why we see a future mine here, we stop, we do not do dfs? <----
    
71.             // * because if we see a mine, it means this path cannot go further, so need to stop dfs path!!!!!!!!!
    
72.             ++mNum;   
    
73.         } else if(b[r2][c2] === 'E') {
    
74.             // * if we can see empty, this means dfs path can continue, can keep going <---
    
75.             // * so why put start point to arr? <---
    
76.             // * because those dfs path can go down
    
77.             empty.push([r2, c2]);
    
78.         }
    
79.     } // el
    
80.    
    
81.     // * if we see mine, we need to stop directly, even we have some dfs queue?
    
82.     // * because ...?
    
83.     if(mNum > 0) {
    
84.         b[r][c] = String(mNum);
    
85.     } else {
    
86.         // * so why we revreal the click? <---
    
87.         // * because in this dfs level, this click is used, so reveal it
    
88.         // * the dfs queue is below, is acting like that it will simulate the click further (further reveal)
    
89.         b[r][c] = 'B';
    
90.         
    
91.         // * why the element in queue order is the dir order? <----
    
92.         // * because we loop direction, then add to dfs queue, so dfs queue order === direction order
    
93.         for(let [x, y] of empty) {
    
94.             dfs(d, b, [x, y]);
    
95.         }
    
96.     }
    
97. }
    
98. 
    
99. var updateBoard = function(b, click) {
    
100.     // * why do we need the 8 cell grid direction? <---
     
101.     // * because click 1 spot, then all 8 directions get exploded.
     
102.     const d = [[-1, 0], [-1, 1], [0, 1], [1, 1], [1, 0], [1, -1], [0, -1], [-1, -1]];
     
103.     // * why click has row?
     
104.     // * because it will land on grid
     
105.     const r = click[0];
     
106.     // * why click has col?
     
107.     // * because it will land on the grid
     
108.     const c = click[1];
     
109.    
     
110.     // * why there is no loop then dfs? <---
     
111.     // * because we have a click (start_row, start_col), then we just dfs init, goes down
     
112.    
     
113.     // * why we need to handle click the mine directly? <---
     
114.     // * because if we don't handle here now, when goes into dfs, we only look at future 8 directions.
     
115.     // * the curr one will be ignored, so we need to handle now.
     
116.     // * why M === untouched mine? <----
     
117.     // * because M is the init letter of Mine; it is a good and untouched mine.
     
118.     // * why X === revealed mine? <----
     
119.     // * because X looks like exploding and cross means bad
     
120.     if(b[r][c] === 'M') {
     
121.         b[r][c] = 'X';
     
122.         // * why we need to return the board? <---
     
123.         // * because we click on the mine, then explode, need to return board
     
124.         return b;
     
125.     } else {
     
126.         // * why pass direction, beacuse new_row = row + row_d? <---
     
127.         // * new_col = col + col_d
     
128.         // * so we need the next move
     
129.         dfs(d, b, click);
     
130.         return b;
     
131.     }
     
132. };

复制代码

这里是我马甲呀 发表于 2022-1-9 17:30
说实话，就我这刷题水平上岸大概率也是靠去年好市场和攒的人品加comminication还算好捞来的好运气，除了那 ...

那你在fb做的怎么样啊。