Jane Street 电面

来源：对这家感兴趣是因为前段时间在地里看到一个帖子https://www.1point3acres.com/bbs/thread-538912-1-1.html，说得我心动了，然后又上linkedin查了查这家的employee，基本上都是top school出来的，而且很少有跳槽出去的，感觉很不可思议，就去他们官网投了software developer的简历，投完过了大概一星期收到HR邮件安排下一步

他们先安排我和一个engineer电话聊了半小时，这个就类似tech公司的HR面，主要是我问关于他们公司的问题，同时对方也问我一些常规问题，比如对下一份工作最看重什么，为什么考虑他们家等等，感觉面试官语速很快，也是聪明人

然后HR就安排第一轮电面，可能因为他们家engineer不多，电面也约不到很早的时间，感觉投的人也挺多的

电面形式：1 hr 电话面试，用coderpad写code，但不需要编译，只要口头跑testcase

题目：分成三个小问，难度是层层递进的，后面的小问可以使用前面的function，感觉这种形式的面试题都很不错，每个面试者能做出来的问题数量不一样，容易有区分度，而且每个小问要完成的东西不多，很容易有思路怎么做

您好！
本帖隐藏的内容需要积分高于 180 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 180 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

感受：面试官很聪明，经常能看出我代码中的小问题并且给出提示，让我自己找出来问题在哪，而且我讲解思路的时候也会及时回应，是非常愉快的一次面试体验

结果：第二天收到拒信，有点惊讶，因为题都做出来了，聊天也没问题，根据我经历过的面试，同样的表现在其他的tech company都是必过的……非要说哪里不好的话，就是不够bug free吧，经过修改和面试官提示才全部写对，那感觉他们家bar也太高了……问了下HR，没给具体的feedback，但也没说有冷冻期之类的，可能过段时间就可以重新申

如果面经对你有帮助的话，请帮忙加一点大米，谢谢！

1. // Source: https://www.1point3acres.com/bbs/thread-547993-1-1.html
   
2. class StringCompressor {
   
3.   // for continuous_compress
   
4.   char continuous_curr_char;
   
5.   int continuous_curr_cnt{0};
   
6. 
   
7.   // for compress_seqs
   
8.   unordered_map<int, string> buffer;
   
9.   int next_expected_seq_num{0};
   
10. 
    
11.   public:
    
12.   vector<pair<char, int>> compressed_tuples(const string& chars) {
    
13.     vector<pair<char, int>> res;
    
14.     char curr_char;
    
15.     int curr_cnt = 0;
    
16.     for (char c : chars) {
    
17.       if (curr_cnt == 0 || curr_char == c) {
    
18.         ++curr_cnt;
    
19.         curr_char = c;
    
20.       } else {
    
21.         res.emplace_back(curr_char, curr_cnt);
    
22.         curr_char = c;
    
23.         curr_cnt = 1;
    
24.       }
    
25.     }
    
26.     res.emplace_back(curr_char, curr_cnt);
    
27.     return res;
    
28.   }
    
29. 
    
30.   vector<pair<char, int>> continuous_compress(const string& chars) {
    
31.     vector<pair<char, int>> res;
    
32.     char curr_char = continuous_curr_char;
    
33.     int curr_cnt = continuous_curr_cnt;
    
34.     for (char c : chars) {
    
35.       if (curr_cnt == 0 || curr_char == c) {
    
36.         ++curr_cnt;
    
37.         curr_char = c;
    
38.       } else {
    
39.         res.emplace_back(curr_char, curr_cnt);
    
40.         curr_char = c;
    
41.         curr_cnt = 1;
    
42.       }
    
43.     }
    
44.     continuous_curr_char = curr_char;
    
45.     continuous_curr_cnt = curr_cnt;
    
46.     return res;
    
47.   }
    
48. 
    
49.   vector<pair<char, int>> compress_seqs(int seq_num, const string& chars) {
    
50.     buffer[seq_num] = chars;
    
51.     if (seq_num != next_expected_seq_num) {
    
52.       return {};
    
53.     }
    
54. 
    
55.     string s;
    
56.     int curr_seq_num;
    
57.     for (curr_seq_num = next_expected_seq_num; buffer.find(curr_seq_num) != buffer.end(); ++curr_seq_num) {
    
58.       s += buffer[curr_seq_num];
    
59.       buffer.erase(curr_seq_num);
    
60.     }
    
61. 
    
62.     next_expected_seq_num = curr_seq_num;
    
63.     return continuous_compress(s);
    
64.   }
    
65. };
    
66. 
    
67. void testCompress() {
    
68.   StringCompressor compressor;
    
69. 
    
70.   // Expected: {a, 2},{b, 2},{c, 3},
    
71.   for (auto p : compressor.compressed_tuples("aabbccc")) {
    
72.     cout << "{" << p.first << ", " << p.second << "}," ;
    
73.   }
    
74.   cout << endl;
    
75. 
    
76.   // Expected: {a, 1},{b, 11},
    
77.   for (auto p : compressor.compressed_tuples("abbbbbbbbbbb")) {
    
78.     cout << "{" << p.first << ", " << p.second << "}," ;
    
79.   }
    
80.   cout << endl;
    
81. 
    
82.   // Expected: {a, 3}, {b, 5}, {c, 2}, {d, 1}
    
83.   for (auto p : compressor.continuous_compress("aaabbb")) {
    
84.     cout << "{" << p.first << ", " << p.second << "}," ;
    
85.   }
    
86.   for (auto p : compressor.continuous_compress("bbccd")) {
    
87.     cout << "{" << p.first << ", " << p.second << "}," ;
    
88.   }
    
89.   for (auto p : compressor.continuous_compress("ee")) {
    
90.     cout << "{" << p.first << ", " << p.second << "}," ;
    
91.   }
    
92.   cout << endl;
    
93. 
    
94.   compressor = StringCompressor();
    
95.   for (auto p : compressor.compress_seqs(2, "ccc")) {
    
96.     cout << "{" << p.first << ", " << p.second << "}," ;
    
97.   }
    
98.   for (auto p : compressor.compress_seqs(1, "bbc")) {
    
99.     cout << "{" << p.first << ", " << p.second << "}," ;
    
100.   }
     
101.   for (auto p : compressor.compress_seqs(0, "aa")) {
     
102.     cout << "{" << p.first << ", " << p.second << "}," ;
     
103.   }
     
104.   for (auto p : compressor.compress_seqs(3, "cdd")) {
     
105.     cout << "{" << p.first << ", " << p.second << "}," ;
     
106.   }
     
107.   cout << endl;
     
108. }

复制代码

遇到了原题， 特地回来加米。

以及大家不要像我一样， 背了leetcode 那题的答案， 被面试官来了一句 你为什么要用 anchor 为名字， 你是不是见过这题：）

😅

JS里面都是天才

请问一下楼主，第一轮一定是engineer聊天吗？我也收到了，但是不知道第一轮是个怎么样的形式

已加米，想问下楼主，有一个sequence number和一个string的第三问怎么做啊？

elidrinkscoffee 发表于 2020-8-25 05:38
遇到了原题， 特地回来加米。

以及大家不要像我一样， 背了leetcode 那题的答案， 被面试官来了一句 你 ...

请教拿到Jane St的面试有多难呢？敢问各位拿到面试的牛牛都是啥背景？top本科？

感谢分享！

1. package src;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.LinkedList;
   
5. import java.util.List;
   
6. import java.util.PriorityQueue;
   
7. 
   
8. class StringCompression {
   
9.     // 第一问：LC 443，不用改input，直接输出List<Tuple<char, int>>
   
10.     public List<String> stringCompressionQ1(String input) {
    
11.         List<String> res = new ArrayList<>();
    
12.         int i = 0;
    
13.         while (i < input.length()) {
    
14.             char curChar = input.charAt(i);
    
15.             int cnt = 1;
    
16.             i++;
    
17.             while (i < input.length() && curChar == input.charAt(i)) {
    
18.                 cnt++;
    
19.                 i++;
    
20.             }
    
21.             res.add(curChar + " " + cnt);
    
22.         }
    
23.         return res;
    
24.     }
    
25. 
    
26.     // 第二问：新的这个function会被call很多次，每次还是给一个string，
    
27.     // 比如第一次aaabbb，第二次bbccd，第三次ee，对应的输出分别是(a - 3)，
    
28.     // (b - 5, c - 2)，(d - 1)，也就是不输出每个string最后一个tuple的结果，
    
29.     // 而是要等下一次输入看还有没有一样的char相连，然后一起输出结果；
    
30.     // 比如如果有一次的输入是kkk，那就什么都不输出
    
31.     char tailChar;
    
32.     int count = 0;
    
33. 
    
34.     public List<String> stringCompressionQ2(String input) {
    
35.         List<String> res = new LinkedList<>();
    
36.         int i = 0;
    
37.         while (i < input.length()) {
    
38. 
    
39.             if (this.tailChar == '\u0000') {
    
40.                 tailChar = input.charAt(i);
    
41.             }
    
42. 
    
43.             while (i < input.length() && this.tailChar == input.charAt(i)) {
    
44.                 this.count++;
    
45.                 i++;
    
46.             }
    
47. 
    
48.             if (i == input.length()) {
    
49.                 break;
    
50.             }
    
51.             res.add(tailChar + " " + this.count);
    
52.             this.tailChar = input.charAt(i);
    
53.             this.count = 0;
    
54.         }
    
55.         return res;
    
56.     }
    
57. 
    
58.     public class InputSequence {
    
59.         int seq;
    
60.         String input;
    
61. 
    
62.         public InputSequence(int s, String i) {
    
63.             seq = s;
    
64.             input = i;
    
65.         }
    
66.     }
    
67. 
    
68.     PriorityQueue<InputSequence> buffer = new PriorityQueue<>(
    
69.             (InputSequence a, InputSequence b) -> Integer.compare(a.seq, b.seq));
    
70.     int curSeq = 0;
    
71. 
    
72.     // 第三问：新的function的输入有一个sequence number和一个string，
    
73.     // 比如(2, ccc)，(1, bbc)，(0, aa)，(3, cdd)，那么在接受前两个输入的时
    
74.     // 候不用输出什么东西，但在第三个输入出现的时候，因为我们已经有了从0到2的所有输入，
    
75.     // 所以输出整合的string对应的压缩结果，也就是aabbcccc对应的(a - 2, b - 2)；
    
76.     // 注意我们不输出c的结果，而是在接收3对应的string以后，继续输出(c - 5)；整体
    
77.     // 的意思就是一旦有了从头开始的一段连续的string，就输出它对应的结果，然后等下一
    
78.     // 段连续的string‍‌‌‌‍‌‌‍‍‍‌‍‍‌‍‍‍‍‌出现
    
79. 
    
80.     public List<String> stringCompressionQ3(InputSequence input) {
    
81.         buffer.add(input);
    
82.         StringBuilder sb = new StringBuilder();
    
83.         while (!buffer.isEmpty() && buffer.peek().seq == curSeq) {
    
84.             InputSequence next = buffer.poll();
    
85.             curSeq = next.seq + 1;
    
86.             sb.append(next.input);
    
87.         }
    
88.         return stringCompressionQ2(sb.toString());
    
89.     }
    
90. 
    
91.     public static void main(String[] args) {
    
92.         System.out.println("=== String Copression ===");
    
93.         StringCompression solution = new StringCompression();
    
94. 
    
95.         // List<String> q1Res = solution.stringCompressionQ1("aaabbbcc");
    
96.         // for (String s : q1Res) {
    
97.         // System.out.println(s);
    
98.         // }
    
99. 
    
100.         // List<String> q2Res = solution.stringCompressionQ2("aaab");
     
101.         // for (String s : q2Res) {
     
102.         // System.out.println(s);
     
103.         // }
     
104.         // System.out.println("-----");
     
105.         // List<String> q2Res2 = solution.stringCompressionQ2("bbccd");
     
106.         // for (String s : q2Res2) {
     
107.         // System.out.println(s);
     
108.         // }
     
109.         // System.out.println("-----");
     
110.         // List<String> q2Res3 = solution.stringCompressionQ2("ee");
     
111.         // for (String s : q2Res3) {
     
112.         // System.out.println(s);
     
113.         // }
     
114. 
     
115.         List<String> q3Res1 = solution.stringCompressionQ3(solution.new InputSequence(2, "ccc"));
     
116.         for (String s : q3Res1) {
     
117.             System.out.println(s);
     
118.         }
     
119.         System.out.println("-----");
     
120.         List<String> q3Res2 = solution.stringCompressionQ3(solution.new InputSequence(1, "bbc"));
     
121.         for (String s : q3Res2) {
     
122.             System.out.println(s);
     
123.         }
     
124.         System.out.println("-----");
     
125.         List<String> q3Res3 = solution.stringCompressionQ3(solution.new InputSequence(3, "d"));
     
126.         for (String s : q3Res3) {
     
127.             System.out.println(s);
     
128.         }
     
129.         System.out.println("-----");
     
130.         List<String> q3Res4 = solution.stringCompressionQ3(solution.new InputSequence(0, "aa"));
     
131.         for (String s : q3Res4) {
     
132.             System.out.println(s);
     
133.         }
     
134.     }
     
135. }

复制代码