Snapchat

Snapchat 电面准备规划

11-21

电面中常见的30道不同类型的题掌握

Design and implement new features and improve performance on both backend and client side

11-21

整理重点类型

复习heap, trie, dfs找环的基本概念

BQ

你觉得snapchat 怎么样，你有用么？你喜欢什么功能

说阅后即焚好酷啊，我和朋友之间发污污的东西，都用的它，各种stories功能好欢乐啊，还教做饭，喜欢的不行.

为什么想来Snapchat，楼主说我可是你们的用户，特别喜欢里面的Stories里面的Discover类别

每次面试都有10多分钟用来聊snapchat

可以看看他家的科技新闻，挑几个新feature讲讲

客套几句之后，问小编如何改进Snapchat这个产品。殊不知小编早有准备：在面试之前，小编特意和朋友们一起下载了Snapchat使用，结果发现添加好友的功能设计的非常蹩脚，和Wechat"hold together"的易用性差距明显。于是就把这个想法讲出来，面试官一下就共鸣了，气氛融洽了很多。

Project 可能问的很细

项目讨论的框架

context: 简要描述项目背景，为什么要做，意义和影响何在。让面试官快速了解。 action: 你在这个项目中做了什么，贡献是什么。 result: 项目的结果，失败的项目也可以讲，在这个项目中学到了什么，得到了什么样的成长。简历中提到的技术一定要熟悉。站在面试官的角度问自己会问自己什么问题。面试之后，可以问面试官问题，着重问自己关心的问题。

Behavior

Why Snapchat?

介绍一下自己的项目

对于snapchat的产品是怎么看的？(story, chat)

各种culture fit，后面要面的人要取巧的话，看一下snapchat 的wiki, 然后看几篇技术报道，最后youtube上搜一下网红们怎么用的snapchat, 基本就能“看着” 很fit了；

Snapchat 复习重点

区间型dp

Backtracking

BigInt

大数相加

Add Strings

public class Solution {
    public String addStrings(String num1, String num2) {
        StringBuilder sb = new StringBuilder();
        int carry = 0;
        int i = num1.length() - 1, j = num2.length() - 1;
        while(i >= 0 || j >= 0) {
            int n1 = i >= 0 ? num1.charAt(i--) - '0' : 0;
            int n2 = j >= 0 ? num2.charAt(j--) - '0' : 0;
            int sum = n1 + n2 + carry;
            sb.append(sum % 10 + "");
            carry = sum / 10;
        }

        if(carry != 0) {
            sb.append(carry + "");
        }

        return sb.reverse().toString();
    }
}

Basic Calculator

复现了一下 Dijkstra 的 shunting yard algorithm，因为只有 “+” 和 “-” ，运算符优先级上要简单一些。在这个代码基础上扩展任何新的运算符都很容易，加个判断函数就行了。

建个 StringBuilder 存输出的 RPN，一个 Stack 存运算符；

如果看到数字，直接添加到 StringBuilder 中；

如果看到 "(" ，直接添加到 Stack 上；

如果看到 ")"，把 Stack 上的所有运算符 pop 出来添加到 StringBuilder，直到遇见 "(" 为止；

如果看到运算符，把 Stack 上所有 "大于等于当前运算符优先级" 的 pop 出来加到 StringBuilder，最后把自己放入 Stack，此时要么 Stack 为空，要么 Stack.peek() 的优先级比当前运算符小。

优先级："乘除 = 3"， "加减 = 2”

public class Solution {
    public int calculate(String s) {
        if(s == null || s.length() == 0) return 0;
        return solveRPN(getRPN(s));
    }

    public String getRPN(String s) {
        s = s.replace(" ", "");

        StringBuilder sb = new StringBuilder();
        LinkedList<Character> stack = new LinkedList<>();
        for(int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if(Character.isDigit(c)) {
                sb.append(c);
            } else {
                sb.append(' ');

                if(c == '(') {
                    stack.push(c);
                } else if(c == ')') {
                    while(!stack.isEmpty() && stack.peek() != '(') {
                        sb.append(stack.pop());
                        sb.append(' ');
                    }
                    stack.pop();
                } else {
                    // pop out the high proirity
                    while(!stack.isEmpty() && getPrecedence(c) <= getPrecedence(stack.peek())) {
                        sb.append(stack.pop());
                        sb.append(' ');
                    }
                    stack.push(c);
                }
            }
        }

        while(!stack.isEmpty()) {
            sb.append(' ');
            sb.append(stack.pop());
        }

        return sb.toString();
    }

    public int solveRPN(String input) {
        String[] str = input.split(" ");
        LinkedList<Integer> stack = new LinkedList<>();
        for(String s: str) {
            if(s.equals("")) continue;
            if("+-*/".indexOf(s) != -1) {
                int num1 = stack.pop();
                int num2 = stack.pop();
                if(s.equals("+")) stack.push(num1 + num2);
                if(s.equals("-")) stack.push(num2 - num1);
                if(s.equals("*")) stack.push(num2 * num1);
                if(s.equals("/")) stack.push(num2 / num1);
            } else {
                stack.push(Integer.parseInt(s));
            }
        }

        return stack.pop();
    }

    private int getPrecedence(char c) {
        if(c == '+' || c == '-') return 2;
        if(c == '*' || c == '/') return 3;

        return 1;
    }
}

Amicable Pair

例如220与284： 220的全部约数（除掉本身）相加是：1+2+4+5+10+11+20+22+44+55+110=284 284的全部约数（除掉本身）相加的和是：1+2+4+71+142=220

换句话说，亲和数又可以说成是两个正整数中，一方的全部约数之和与另一方的全部约数之和相等。 220的全部约数之和是：1+2+4+5+10+11+20+22+44+55+110+220 = 284+220 = 504 284的全部约数之和是：1+2+4+71+142+284 = 220+284 = 504

public class Solution {
    /**
     * @param k an integer
     * @return all amicable pairs
     */
    public int factorSum(int n) {
        int sum = 1, i;
        for (i = 2; i * i < n; ++i) {
            if (n % i == 0) {
                sum += i + n / i;
            }
        }
        if (i * i == n) {
            sum += i;
        }
        return sum;
    }

    public List<List<Integer>> amicablePair(int k) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        for (int i = 2; i <= k; ++i) {
            int amicable = factorSum(i);
            if (amicable <= i || amicable > k) {
                continue;
            }
            if (factorSum(amicable) == i) {
                ArrayList<Integer> pair = new ArrayList<Integer>();
                pair.add(i);
                pair.add(amicable);
                result.add(pair);
            }
        }
        return result;
    }
}

Snapchat

Snapchat

Snapchat 电面准备规划

分类

11-21

BQ

Behavior

Snapchat 复习重点

BigInt

Basic Calculator

Amicable Pair

results matching ""

No results matching ""