Liveramp Intern OA + 店面1面 + 店面2面 （已跪）

OA: 没什么好说的，大家的题都一样，地里有很多面经，就不写了。

店面1： 还是老题，shortest path in undirected graph。面试官叫 亚历山大 什么的，和他讨论了3种方法，BFS, DFS, bidirectional search。
BFS 是最标准的做法嘛，但是空间复杂度太大了。
然后就说用DFS，比如说先search完depth = 5， 再search depth = 6, 7, ....一直这样search下去
bidirectional search 大家找找以前别人发的帖子，好几个人都分享了一个一篇文章的链接，讲的特别好，一定要看，我就是面试上午看的

店面2：

面试官开始安排的是个A开头的印度人，后面reschedule为tzing了（好像是这么拼的）
问了些传统的behavioral questions过后就开始问技术问题了

1. 投篮问题，3中2算赢好，还是6中4算赢好？要是是8中5呢？
我就是按照地里面大家的回答，还有人这样回答也过了的


“次数越多，结果越接近数学期望，所以如果命中率是90%，应该尽量多投，这样避免意外。如果命中率只有10%，那应该选择3中2，因为投篮次数越少，结果越离散，只投3次因为运气意外赢的可能性比较大。

It depends on whether the person is good at shooting.
According to the law of large numbers (LLN), the  of the results obtained from a large number of trials should be close to the , and will tend to become closer as more trials are performed.

If your shooting probility is greater than 0.6 , I will choose ⅝.  if you are not gooding at playing basketball, I will choose ⅔, and you got that result  by chance. 鏉

然后他就问了这个threshold, 我蒙的是2/3 = 0.667, 5/8 = 0.625, 所以就0.7.....�-涓夊垎鍦�
然后仨小时后收到了onsite邀请. 太震惊了,估计是他家真的缺人了吧. 发面经攒攒人品. ”

但是他问我具体的概率呢？他一直在那里纠结，估计就是这里没有答好，跪了吧。后面我和同学讨论，他说这个概率问题明明可以算出来呀。。。。。。哎，不知道为什么之前地里没有人提到。。。。郁闷的是，我后面才想起其实面试之前和他讨论过，他告诉我可以用概率算出来，大概怎么算。然而我面试的时候就像得了失忆症，什么都没有想起。。。。

单独投一次中的概率为p，那么

3投2中算赢的概率: p1 = C(3, 2) * p^2 * (1 - p) + p^3

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

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

e.g. enforcing that the smallest element in S1 must always be smaller than the smallest element in S2. (This asymmetry enforcement has the nice side-effect of halving the execution time :))

follow up用的是mapreduce。

3. 现在要把一群人分成两组，告诉你一些pair，每个pair中第一个人和第二个人不和，然后让你如何分组使得同一组中不存在不和的组员，当然，也有可能分组失败。

首先不在pair里的人随便分。然后你剩下的就只有pair里的人了，然后贪心就好了，从任意一个人开始，把他放在第一组，把和他不和的人放在第二组。把这些人记录下来。然后检查带有这些人的pair，如果pair的另一半在第一组，不用理他，如果pair的另一半在第二组，返回分组失败。如果pair的另一半现在还没有组。把他放到第一组，并记录下来。在check新记录的人，以此类推。如果没有人要check了，就找一个没有组的人随便放入一组。知道所有人都有组为止。.

1. import java.util.*;
   
2. 
   
3. public class MinPath {
   
4.         List<Integer> findMinPath(int source, int destination) {
   
5.                 Queue<Integer> queue = new LinkedList<>();
   
6.                 Map<Integer, Integer> parent = new HashMap<>();
   
7.                
   
8.                 queue.offer(source);
   
9.                 parent.put(source, null);
   
10.                
    
11.                 boolean find = false;
    
12.                
    
13.                 while(!queue.isEmpty() && !find) {
    
14.                         int size = queue.size();
    
15.                         for (int i = 0; i < size; i++) {
    
16.                                 int cur = queue.poll();
    
17.                                 int next1 = cur * cur;
    
18.                                 int next2 = cur - 1;
    
19.                                 int[] nexts = new int[]{next1, next2};
    
20.                                 for (int next : nexts) {
    
21.                                         if (!parent.containsKey(next)) {
    
22.                                                 queue.offer(next);
    
23.                                                 parent.put(next, cur);
    
24.                                                 if (next == destination) {
    
25.                                                         find = true;
    
26.                                                         break;
    
27.                                                 }
    
28.                                         }
    
29.                                 }
    
30.                                 if (find) {
    
31.                                         break;
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.                
    
36.                 List<Integer> list = new LinkedList<>();
    
37.                 for (Integer key : parent.keySet()) {
    
38.                         System.out.print(key);
    
39.                         System.out.print(" : ");
    
40.                         System.out.print(parent.get(key));
    
41.                         System.out.println();
    
42.                 }
    
43.                 buildPath(list, parent, source, destination);
    
44.                 return list;
    
45.         }
    
46.        
    
47.         static void buildPath(List<Integer> list, Map<Integer, Integer> parent, int source, int destination) {
    
48.                 int cur = destination;
    
49.                 while(cur != source) {
    
50.                         list.add(0, cur);
    
51.                         cur = parent.get(cur);
    
52.                 }
    
53.                 list.add(0, source);
    
54.         }
    
55.        
    
56.         public static void main(String[] args) {
    
57.                 MinPath ob = new MinPath();
    
58.                 List<Integer> list = ob.findMinPath(2, 9);
    
59.                 for(Integer x : list) {
    
60.                         System.out.println(x);
    
61.                 }
    
62.         }
    
63. }
    

复制代码

1. import java.util.*;
   
2. 
   
3. public class DivideGroup {
   
4.         void divide(Set<Character> set, char[][] notMatch) {
   
5.                 Set<Character> set1 = new HashSet<>();
   
6.                 Set<Character> set2 = new HashSet<>();
   
7.                 for (int i = 0; i < notMatch.length; i++) {
   
8.                         if ((set1.contains(notMatch[i][0]) && set1.contains(notMatch[i][1])) ||
   
9.                                         (set2.contains(notMatch[i][0]) && set2.contains(notMatch[i][1]))) {
   
10.                                 System.out.println("Cannot devide");
    
11.                                 return;
    
12.                         }
    
13.                         for (int j = 0; j < 2; j++) {
    
14.                                 if (j == 0) {
    
15.                                         if (set1.contains(notMatch[i][0])) {
    
16.                                                 set1.add(notMatch[i][0]);
    
17.                                         } else if (set2.contains(notMatch[i][0])) {
    
18.                                                 set2.add(notMatch[i][0]);
    
19.                                         } else if (set1.contains(notMatch[i][1]) && !set2.contains(notMatch[i][1])) {
    
20.                                                 set2.add(notMatch[i][0]);
    
21.                                         } else if (!set1.contains(notMatch[i][1]) && set2.contains(notMatch[i][1])) {
    
22.                                                 set1.add(notMatch[i][0]);
    
23.                                         } else if (!set1.contains(notMatch[i][1]) && !set2.contains(notMatch[i][1])) {
    
24.                                                 if (set1.size() < set2.size()) {
    
25.                                                         set1.add(notMatch[i][0]);
    
26.                                                 } else {
    
27.                                                         set2.add(notMatch[i][0]);
    
28.                                                 }
    
29.                                         }
    
30.                                 }
    
31.                                 if (j == 1) {
    
32.                                         if (set1.contains(notMatch[i][1])) {
    
33.                                                 set1.add(notMatch[i][1]);
    
34.                                         } else if (set2.contains(notMatch[i][1])) {
    
35.                                                 set2.add(notMatch[i][1]);
    
36.                                         } else if (set1.contains(notMatch[i][0]) && !set2.contains(notMatch[i][0])) {
    
37.                                                 set2.add(notMatch[i][1]);
    
38.                                         } else if (!set1.contains(notMatch[i][0]) && set2.contains(notMatch[i][0])) {
    
39.                                                 set1.add(notMatch[i][1]);
    
40.                                         } else if (!set1.contains(notMatch[i][0]) && !set2.contains(notMatch[i][0])) {
    
41.                                                 if (set1.size() < set2.size()) {
    
42.                                                         set1.add(notMatch[i][1]);
    
43.                                                 } else {
    
44.                                                         set2.add(notMatch[i][1]);
    
45.                                                 }
    
46.                                         }
    
47.                                 }
    
48.                         }
    
49.                        
    
50.                 }
    
51.                
    
52.                 for (Character c : set) {
    
53.                         if (!set1.contains(c) && !set2.contains(c)) {
    
54.                                 if (set1.size() < set2.size()) {
    
55.                                         set1.add(c);
    
56.                                 } else {
    
57.                                         set2.add(c);
    
58.                                 }
    
59.                         }
    
60.                 }
    
61.                
    
62.                 System.out.print("set1: ");
    
63.                 for (Character c : set1) {
    
64.                         System.out.print(c);
    
65.                 }
    
66.                 System.out.println();
    
67.                
    
68.                 System.out.print("set2: ");
    
69.                 for (Character c : set2) {
    
70.                         System.out.print(c);
    
71.                 }
    
72.                 System.out.println();
    
73.         }
    
74.        
    
75.         public static void main(String[] args) {
    
76.                 DivideGroup ob = new DivideGroup();
    
77.                 Set<Character> set = new HashSet<>(Arrays.asList('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'));
    
78. //                char[][] notMatch = new char[][]{{'j', 'a'}, {'g', 'h'}, {'c', 'j'}, {'c', 'b'}, {'h', 'd'}};
    
79.                 char[][] notMatch = new char[][]{{'j', 'a'}, {'g', 'h'}, {'c', 'j'}, {'c', 'b'}, {'k', 'd'}, {'a', 'c'}};
    
80.                 ob.divide(set, notMatch);
    
81.         }
    
82. }
    

复制代码

我觉得楼主能面试到第二轮就已经很厉害了。我面第一轮就挂了。LiveRamp 招人很少，不妨尝试一下大公司，比如Amazon. 周围人拿到他家的实习，貌似挺容易的。

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

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

据说他家只面不招。。。LZ Move on 吧。
（也是知道他家不咋发offer 所以OA一直拖延了一个月后来直接放弃了）

cser017 发表于 2016-12-10 05:23
据说他家只面不招。。。LZ Move on 吧。
（也是知道他家不咋发offer 所以OA一直拖延了一个月后来直接放弃 ...

嗯嗯～谢谢～对于面试经验不多的，可以用来练习一下面试。没时间就没必要做了