LC Python 刷题笔记 有志者事竟成

3-4级DE电面时候中等难度的题，5道题里面的第2-3道题

Sort the numbers in an array. But the position of zeros should not be changed.

Input: A List.

Output: An Iterable (tuple, list, iterator ...).

Example:

except_zero([5, 3, 0, 0, 4, 1, 4, 0, 7]) == [1, 3, 0, 0, 4, 4, 5, 0, 7]
except_zero([0, 2, 3, 1, 0, 4, 5]) == [0, 1, 2, 3, 0, 4, 5]

1. def except_zero(items):
   
2.     list1 = []
   
3.     for num in items:
   
4.         if num != 0:
   
5.             list1.append(num)
   
6.     list1.sort()
   
7.    
   
8.     j = 0
   
9.     for i in range(len(items)):
   
10.         if items[i] != 0:
    
11.             items[i] = list1[j]
    
12.             j += 1
    
13.     return items

复制代码

比较经典的排序题

Create and return a new iterable that contains the same elements as the argument iterable items, but with the reversed order of the elements inside every maximal strictly ascending sublist. This function should not modify the contents of the original iterable.

Input: Iterable

Output: Iterable

Example:

reverse_ascending([1, 2, 3, 4, 5]) == [5, 4, 3, 2, 1]
reverse_ascending([5, 7, 10, 4, 2, 7, 8, 1, 3]) == [10, 7, 5, 4, 8, 7, 2, 3, 1]

1. def reverse_ascending(items):
   
2.     if len(items) == 0: return []
   
3.     list1 = []
   
4.     list2 = []
   
5.     block = 0
   
6.     for num in items:
   
7.         if num > block:
   
8.             list2.append(num)
   
9.             block = num
   
10.         else:
    
11.             list2 = sorted(list2,reverse=True)
    
12.             list1 = list1 + list2
    
13.             list2 = []
    
14.             list2.append(num)
    
15.             block = num
    
16.     if list2 != []:
    
17.         list2 = sorted(list2,reverse=True)
    
18.         list1 = list1 + list2
    
19.         return list1
    
20.     else:
    
21.         return list1
    
22. 
    
23. 
    
24. if __name__ == '__main__':
    
25.     print("Example:")
    
26.     print(reverse_ascending([1, 2, 3, 4, 5]))
    
27. 
    
28.     # These "asserts" are used for self-checking and not for an auto-testing
    
29.     assert list(reverse_ascending([1, 2, 3, 4, 5])) == [5, 4, 3, 2, 1]
    
30.     assert list(reverse_ascending([5, 7, 10, 4, 2, 7, 8, 1, 3])) == [10, 7, 5, 4, 8, 7, 2, 3, 1]
    
31.     assert list(reverse_ascending([5, 4, 3, 2, 1])) == [5, 4, 3, 2, 1]
    
32.     assert list(reverse_ascending([])) == []
    
33.     assert list(reverse_ascending([1])) == [1]
    
34.     assert list(reverse_ascending([1, 1])) == [1, 1]
    
35.     assert list(reverse_ascending([1, 1, 2])) == [1, 2, 1]

复制代码

同样的题，SDE可能要modify in place，DE就简单一些，随便建list，加循环，不需要太多考虑复杂度。

A given list should be "compressed" in a way so, instead of two (or more) equal elements, staying one after another, there is only one in the result Iterable (list, tuple, iterator ...).

Input: List.

Output: "Compressed" Iterable (list, tuple, iterator ...).


compress([
  5, 5, 5,
  4, 5, 6,
  6, 5, 5,
  7, 8, 0,
  0]) == [5, 4, 5, 6, 5, 7, 8, 0]
compress([1, 1, 1, 1, 2, 2, 2, 1, 1, 1]) == [1, 2, 1]

1. from typing import Iterable
   
2. 
   
3. 
   
4. def compress(items: list) -> Iterable:
   
5.     if len(items) < 2: return items
   
6.     list1 = []
   
7.     c = float('inf')
   
8.     for num in items:
   
9.         if num != c:
   
10.             list1.append(num)
    
11.             c = num
    
12.     return list1
    
13. 
    
14. 
    
15. if __name__ == '__main__':
    
16.     print("Example:")
    
17.     print(list(compress([
    
18.   5, 5, 5,
    
19.   4, 5, 6,
    
20.   6, 5, 5,
    
21.   7, 8, 0,
    
22.   0])))
    
23. 
    
24.     # These "asserts" are used for self-checking and not for an auto-testing
    
25.     assert list(compress([
    
26.   5, 5, 5,
    
27.   4, 5, 6,
    
28.   6, 5, 5,
    
29.   7, 8, 0,
    
30.   0])) == [5, 4, 5, 6, 5, 7, 8, 0]
    
31.     assert list(compress([1, 1, 1, 1, 2, 2, 2, 1, 1, 1])) == [1, 2, 1]
    
32.     assert list(compress([7, 7])) == [7]
    
33.     assert list(compress([])) == []
    
34.     assert list(compress([1, 2, 3, 4])) == [1, 2, 3, 4]
    
35.     assert list(compress([9, 9, 9, 9, 9, 9, 9])) == [9]
    
36.     print("Coding complete? Click 'Check' to earn cool rewards!")
    

复制代码

Given an iterable of ints , create and return a new iterable whose first two elements are the same as in items, after which each element equals the median of the three elements in the original list ending in that position.

Input: Iterable of ints.

Output: Iterable of ints.

Example:

list(median_three([1, 2, 3, 4, 5, 6, 7])) == [1, 2, 2, 3, 4, 5, 6]
list(median_three([1])) == [1]
list(median_three([-1, 0, 1])) == [-1, 0, 0]

1. from typing import Iterable
   
2. 
   
3. def median_three(els: Iterable[int]) -> Iterable[int]:
   
4.     list1 = els[:2]
   
5.     for i in range(2,len(els)):
   
6.         list2 = els[i-2:i+1]
   
7.         list2.sort()
   
8.         list1.append(list2[1])
   
9.     return list1
   
10. 
    
11. if __name__ == '__main__':
    
12.     print("Example:")
    
13.     print(list(median_three([1, 2, 3, 4, 5, 6, 7])))
    
14.    
    
15.     # These "asserts" are used for self-checking and not for an auto-testing
    
16.     assert list(median_three([1, 2, 3, 4, 5, 6, 7])) == [1, 2, 2, 3, 4, 5, 6]
    
17.     assert list(median_three([1])) == [1]
    
18.     print("Coding complete? Click 'Check' to earn cool rewards!")

复制代码

再次遭到了10万点暴击！！！

There is a list which contains integers or other nested lists which may contain yet more lists and integers which then… you get the idea. You should put all of the integer values into one flat list. The order should be as it was in the original list with string representation from left to right.

Data Pipeline ETL 之前的数据清洗

Input data: A nested list with integers.

Output data: The one-dimensional list with integers.

Example:

flat_list([1, 2, 3]) == [1, 2, 3]
flat_list([1, [2, 2, 2], 4]) == [1, 2, 2, 2, 4]
flat_list([[[2]], [4, [5, 6, [6], 6, 6, 6], 7]]) == [2, 4, 5, 6, 6, 6, 6, 6, 7]
flat_list([-1, [1, [-2], 1], -1]) == [-1, 1, -2, 1, -1]


SDE给DE5定的标准答案：

1. def flat_list(array):
   
2.     return sum(([x] if type(x) != list else flat_list(x) for x in array), [])

复制代码

我的答案：

1. def flat_list(array):
   
2.     list1 = str(array).replace('[','').replace(']','').replace(' ','').split(',')
   
3.     if len(list1) == 0 or list1 == ['']: return []
   
4.     list2 = []
   
5.     for c in list1:
   
6.         if c != '':
   
7.             list2.append(int(c))
   
8.     return list2

复制代码

加油加油！！冲啊，关注下，在职da想跳槽感觉需要刷题，今年bar好高啊，没抽到h1b也很受限

天真         

上一道题是清理列表，这一道题是清理字典。

感觉面试DE，如果刷LC算法可能是在浪费时间，DE不考算法，但是DE的coding操作对基本功要求非常高。

You are given a dictionary where the keys are strings and the values are strings or dictionaries. The goal is flatten the dictionary, but save the structures in the keys. The result should be the a dictionary without the nested dictionaries. The keys should contain paths that contain the parent keys from the original dictionary. The keys in the path are separated by a "/". If a value is an empty dictionary, then it should be replaced by an empty string (""). Let's look at an example:

{
    "name": {
        "first": "One",
        "last": "Drone"
    },
    "job": "scout",
    "recent": {},
    "additional": {
        "place": {
            "zone": "1",
            "cell": "2"}
    }
}

The result will be:

{"name/first": "One",           #one parent
"name/last": "Drone",
"job": "scout",                #root key
"recent": "",                  #empty dict
"additional/place/zone": "1",  #third level
"additional/place/cell": "2"}

Input: An original dictionary as a dict.

Output: The flattened dictionary as a dict.

Example:

flatten({"key": "value"}) == {"key": "value"}
flatten({"key": {"deeper": {"more": {"enough": "value"}}}}) == {"key/deeper/more/enough": "value"}
flatten({"empty": {}}) == {"empty": ""}

1. def flatten(dictionary):
   
2.     if all(type(v) is str for v in dictionary.values()):
   
3.         return dictionary
   
4.     dic = {}
   
5.     for key in dictionary.keys():
   
6.         if type(dictionary[key]) is str:
   
7.             dic[key] = dictionary[key]
   
8.         elif len(dictionary[key])==0:
   
9.             dic[key] = ''
   
10.         else:
    
11.             E = flatten(dictionary[key])
    
12.             for keyE in E:
    
13.                 dic[key+'/'+keyE] = E[keyE]
    
14.     return dic
    
15. 
    
16. 
    
17. 
    
18. if __name__ == '__main__':
    
19.     test_input = {"key": {"deeper": {"more": {"enough": "value"}}}}
    
20.     print('Input : {}'.format(test_input))
    
21.     print('Output: {}'.format(flatten(test_input)))
    
22. 
    
23.     #These "asserts" using only for self-checking and not necessary for auto-testing
    
24.     assert flatten({"key": "value"}) == {"key": "value"}, "Simple"
    
25.     assert flatten(
    
26.         {"key": {"deeper": {"more": {"enough": "value"}}}}
    
27.     ) == {"key/deeper/more/enough": "value"}, "Nested"
    
28.     assert flatten({"empty": {}}) == {"empty": ""}, "Empty value"
    
29.     assert flatten({"name": {
    
30.                         "first": "One",
    
31.                         "last": "Drone"},
    
32.                     "job": "scout",
    
33.                     "recent": {},
    
34.                     "additional": {
    
35.                         "place": {
    
36.                             "zone": "1",
    
37.                             "cell": "2"}}}
    
38.     ) == {"name/first": "One",
    
39.           "name/last": "Drone",
    
40.           "job": "scout",
    
41.           "recent": "",
    
42.           "additional/place/zone": "1",
    
43.           "additional/place/cell": "2"}
    
44.     print('You all set. Click "Check" now!')
    

复制代码

李浩泉 发表于 2020-8-6 23:26
上一道题是清理列表，这一道题是清理字典。

感觉面试DE，如果刷LC算法可能是在浪费时间，DE不考算法，但 ...

lz清理字典这属于电面的难度还是onsite的难度啊？
大龄转码真的心酸，想求问lz说说onsite是不是难度更大，能不能给个例题，好给其他大龄转码的伙伴一个参考啊？感激不尽！

去一般的公司做到senior就有这个工资了吧。不需要天分啥的，有点经验就行。