update

README.md

@@ -2,15 +2,7 @@
 
 ## 1. [LeetCode 题解和总结](/docs/Leetcode_Solutions/)
 
-## 2. [面试问答](/docs/Interview/)
-
-* [面试总结](https://github.com/apachecn/LeetCode/blob/master/docs/Interview/%E5%BC%80%E5%8F%91%E5%B2%97%E4%BD%8D(Java)%E6%80%BB%E7%BB%93.md)
-* [Google 面试题](/docs/Interview/Google/Google.md)
-* [pocketgems 面试题](/docs/Interview/pocketgems/pocketgems.md)
-* [WePay 面试题](/docs/Interview/WePay/WePay.md)
-* [PPd面试题](/docs/Interview/PPd/ppd.md)
-
-## 3. [算法模版](/docs/Algorithm_Templates/)
+## 2. [算法模版](/docs/Algorithm_Templates/)
 
 
 ## 推荐的一些LeetCode网站

docs/Interview/Google/Google.md

-### 第一轮：
-1. Talk about the work experience of you
-
-
-2. 算法题：给一个number，例如21200，
-
-
-
-Idx:      0 1 2 3 4 
-Number:   2 1 2 0 0
-
-- 0th位置有个2，并且整个number里面有2个0；
-- 1th有个1，所以整个number里面有一个1；
-- 2th有个2，所以整个number里面有两个2；
-- 3th有个0，所以整个number里面有0个3；
-- 4th有个0，所以整个number里面有0个4
-
-满足这个property的number是self_describing的
-叫你写一个函数
-def self_describing(self, number), return 这个number是不是满足self_describing，True or False
-
-
-
-3. 算法题，面试官自己工作中的，写了一串，
-- 问你是```BFS```还是DFS，
-- 问你是```recursive```还是iterative，recursive方法有什么limitation
-- 不管结果，你给他的代码转换成```iterative``` or recursive
-
-
-
-
-### 第二轮：
-1. talk about the most challenging work that you have been worked on
-
-
-2. HashTable 和 BST的比较，你知道什么说什么，时间复杂度，实现，插入，删除，查找
-
-3. HashTable 和 BST 的concurrency对比
-
-
-
-4. 算法题
-
-首先，morse_code = {
-              'a': '..',
-              'b': '.-',
-              'c': '...',
-              ‘d’: '-'
-              ,
-              ,
-              .........
-                   }
-给你一串words，
-- 例如['ab','cd']，这时候因为words里面的两个word的对应的morse_code是一样的，所以我们返回他们的morse_code，即['...-']
-- 再例如有很多words，有着相同morse_code的words很多，你要返回所有相同morse_code 的words所对应的那个morse_code,例如['...-', '..']
-
-
-
-

docs/Interview/PPd/ppd.md

-# 第一轮（一个很nice的QA小姐姐）
-### 1. 介绍自己及相关项目
-
-### 2. 一道简单算法热身，2个排好序的数组，如何取出它们中相同的元素
-答：O(N)，就是两个数组同时从```index = 0```开始比较，小的往前进一步，如果相同就加入到```res```中，这样```n```步肯定可以走完。所以是```O(N)```
-
-### 3. 类是怎么加载的
-答：五大步骤：加载、验证、准备、解析、初始化，其中解析根据是静态绑定还是动态绑定, 略...
-详见[类加载机制](https://blog.csdn.net/ns_code/article/details/17881581),当时在这里看到的，就记了一下
-
-### 4. GC 的原理
-答：没引用的对象就是可以回收的了，不定时选择回收与否, 略...
-
-### 5. 栈和堆内存的区别
-答：略...
-
-### 6. 永生代是什么，为啥要有这个
-答：略...
-
-### 7. Spring如何实现AOP和IOC
-答：略...
-
-### 8. 平常开发管理代码用什么方法，Git clone 还是 Git branch，解释一下它们的区别
-答：平常用Git branch，就是按照功能，bug修复开分支，不断merge, 略...
-
-### 9. 解释RESTful的好处
-答：根据方法不同判断api的功能，非常方便，略...
-
-### 10. 遇到的困难和如何解决的
-答：略...
-
-### 11. 你有什么问题要问我的
-答：内心。。没啥要问的哈哈哈😂，略...
-
-
-# 第二轮（一个很严谨的后端开发小哥哥）
-### 1. 45分钟做了一套java试题（20单选，2编程，2问答）
-反馈：说我做得还可以
-
-### 1. 介绍自己及相关项目
-
-### 2. 简单解释下面向对象的基本概念：继承、封装和多态
-答：
-- 继承就是说现在有一个类A，我们如果想要有更多的有着相同功能的类，那么只要继承最开始的这个类A，我们就可以拥有跟类A一样的功能，根据自己条件的不同还可以对A的方法进行重写或者重载
-- 封装使得内部功能和外部隔离开来，一来安全，二来可以更加具有模块化
-- 多态就是说，类似于Father f = new Son();这种，这种可以用于任何时候我们想应用更加specific功能的时候，此时多态就产生效果了。嗯，多态其实就是基于同一个接口，使用不同的实例就可以使用不同的功能
-
-### 3. Java应用程序有没有可能内存泄露？具体场景。如果有一个Java应用程序在生产上发现有内存泄漏问题，作为开发人员你打算如何对其进行问题定位？现在就有这么一个程序，代码也给到你，你怎么弄？流程思路？
-答：第一印象是使用测试工具，先进行模块化检测，我一般手动，注释掉一部分然后检查，采用二分法，一般可以定位到，然后仔细检查下代码逻辑，看看会不会有长期不用的对象仍然被引用着。我觉得工业上肯定会有很多高级工具可以检查内存，但是目前我还没有使用过
-
-### 4. 简单讲讲哈希表的数据结构和算法(get/put操作)。
-答：略...小学生题目不会估计就GG了
-
-### 5. 如果有一个100G的大文件（假定文件里头都是一行行的字符串记录、每个记录约100个字符），要求对这个文件进行排序，请给出你的排序算法。
-答：过程讨论持续15分钟，先后给出3种方法不断优化。
-- 我们可以先遍历所有行，根据每行的前3个字符作为键放到一个hash结构中，这样问题已经可以用O(N^2*lgn)解决了。被否决，有可能前三个字符都是一样的，需要对整个字符串进行排序
-- 或者我们可以先搞一个Trie树，然后遍历一遍全部存好，每一最后字符再多存一个数字表示这一字符串出现次数，然后对这个Trie树进行层次遍历，依次append，返回。回复说文件有100G大小，假设你手头电脑只有8g内存。嗯嗯，我可能会采用先把所有的文件分开很多份分别处理，关键在于最后怎么合并起来还是有序的
-- 其实就是外部排序，先将这个大文件分成很多份，把这些子文件依次读入内存，并利用自定义的有效的内部排序方法（也就是我的方法吧）对它们进行排序，再将排序后得到的有序子文件重新写入外存；可以使用多路归并排序。
-
-### 6. 谈谈你对软件研发生命周期过程的理解，如何确保软件的质量。
-答：生命周期主要有问题定义，可行性分析，系统架构设计，编码实现，测试，验收，最后维护。至于确保软件的质量，就是要选用好的，合适的软件生命周期模型。
-大概模型有瀑布模型，螺旋模型，快速原型模型。
-- 需求明确，使用瀑布模型；
-- 需求很不明确，快速原型模型；
-- 项目不确定性太多使用螺旋模型
-
-### 7. 你是如何管理自己的时间的？举一个你设定并达成目标的例子。
-答：略...
-
-### 8. 你如何理解领导力？举一个由你主动牵头推进的事情。
-答：略...
-
-### 9. 谈谈你的强项和弱项，基于对自己的认识，你打算如何规划你的职业道路？
-答：略...
-
-### 10. 你有什么问题要问我的
-答：这次我准备了，哈哈哈哈😂，不告诉你们，略...
-
-
-# 总结：
-1. 两点最重要：1）开放学习成长的心态，2)积极主动
-2. 后端开发的话，一开始协助做好单元和性能测试，做样例sample，先学习，证明有足够能力后，开始自己独立设计和开发小型模块。最重要的内容是打好基本功，写好像模像样的单元测试，养成良好的工程习惯。
-
-
-
-
-
-
-
-
-

docs/Interview/WePay/WePay.md

-如图，![](https://github.com/Lisanaaa/thinking_in_lc/blob/master/interview%20question/WePay/WePay.jpg)
-
-就是一个slide windows 的题目
-
-```python
-inputs = [5,1,2,100,2,2]
-def alert(inputs, windowSize, allowedIncrease):
-    b = []
-    tmp = {}
-    for i in range(len(inputs) - windowSize):
-        for j in range(i, i+windowSize+1):
-            if j in tmp.keys():
-                if j > len(inputs) - windowSize-1:
-                    tmp.get(j).append(inputs[i+1:i + windowSize+1])
-                else:
-                    tmp.get(j).append(inputs[i:i+windowSize])
-            else:
-                print(j,j, i, i+ windowSize)
-                if j > len(inputs) - windowSize -1:
-                    tmp[j] = [inputs[i+1:i + windowSize+1]]
-                else:
-                    tmp[j] = [inputs[i:i+windowSize]]
-    b = [inputs[i:i+windowSize] for i in range(len(inputs)-windowSize)]
-    print(tmp)
-    for num in tmp.keys():
-        if all(inputs[num] > sum(lis)/windowSize*allowedIncrease for lis in tmp.get(num)):
-            return True
-    b = [sum(i)/windowSize for i in b]
-    for i in range(len(b)):
-        if any(b[i] > b[j]*allowedIncrease for j in range(i)):
-            return True
-    return False
-print(alert(inputs,3,1.5))
-```

docs/Interview/WePay/power_number.md

-
-
-
-
-
-```python
-import heapq
-cache = {}
-def power_number(index):
-    if index in cache:
-        return cache[index]
-    tmp = set()
-    for i in range(2, index+3):
-        for j in range(2, 27):
-            tmp.add(pow(i, j))
-    gene = heapsort(tmp)
-    tmp_index = 0
-    for i in range(index+1):
-        if tmp_index not in cache:
-            cache[tmp_index] = next(gene)
-        else:
-            next(gene)
-        if tmp_index == index:
-            return cache[tmp_index]
-        tmp_index += 1
-
-
-def heapsort(iterable):
-    h = []
-    for value in iterable:
-        heapq.heappush(h, value)
-    for i in range(len(h)):
-        yield heapq.heappop(h)
-
-print(power_number(6500))
-```

docs/Interview/pocketgems/pocketgems.md

-## 1. delete and earn
-```python
-class Solution(object):
-    def deleteAndEarn(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        dp = [0] * 10001
-        for num in nums:
-            dp[num] += num
-        for i in range(2, 10001):
-            dp[i] = max(dp[i]+dp[i-2], dp[i-1])
-        return dp[-1]
-```
-
-## 2. movie ratings
-
-```python
-
-cache = {}
-class Solution(object):
-    def movierating(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        if not nums:
-            return 0
-        if len(nums) == 1:
-            return nums[0] if nums[0] > 0 else 0
-        if (1, len(nums)+1) not in cache:
-            cache[(1, len(nums)+1)] = self.movierating(nums[1:])
-            a = self.movierating(nums[1:])
-        else:
-            a = self.movierating(nums[1:])
-        if (2, len(nums)+2) not in cache:
-            cache[(2, len(nums)+2)] = self.movierating(nums[2:])
-            b = self.movierating(nums[2:])
-        else:
-            b = self.movierating(nums[2:])
-        return max(nums[0]+a, nums[1]+b)
-
-
-
-a = Solution()
-res = a.movierating([-1,-2,-3,-4,-5])
-
-print(res)
-
-```
-
-## 3. roman names
-```python
-class Solution(object):
-    def roman2Int(self, s):
-        lookup = {
-            'M': 1000,
-            'D': 500,
-            'C': 100,
-            'L': 50,
-            'X': 10,
-            'V': 5,
-            'I': 1
-        }
-        res = 0
-        for i in range(len(s)):
-            if i > 0 and lookup[s[i]] > lookup[s[i-1]]:
-                res = res + lookup[s[i]] - 2 * lookup[s[i-1]]
-            else:
-                res += lookup[s[i]]
-        return res
-
-    def royalNames(self, names):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        for x in range(1, len(names)):
-            for i in range(len(names)-x):
-                if names[i].split(' ')[0] > names[i+1].split(' ')[0]:
-                    names[i], names[i+1] = names[i+1], names[i]
-                elif names[i].split(' ')[0] == names[i+1].split(' ')[0]:
-                    if self.roman2Int(names[i].split(' ')[1]) > self.roman2Int(names[i+1].split(' ')[1]):
-                        names[i], names[i + 1] = names[i + 1], names[i]
-        return names
-
-a = Solution()
-res = a.royalNames(['Akk IX', 'Ak VIII', 'Louis IX', 'Louis VIII'])
-print(res)
-```
-
-
-## 4. wealthy sam time
-```python
-class Solution(object):
-    def minMoves(self, nums):
-        """
-        :type nums: List[int]
-        :rtype: int
-        """
-        res = 0
-        minVal = min(nums)
-        for num in nums:
-        	res += num -minVal
-        return res
-```
-
-## 5. design
-
-
-
-
-
-
-
-
-
-
-
-