Coding也是有颜值的，刷题的时候保持颜值在线很重要

用Python实现一个简单的列表排序，相当于SQL order by 1 desc 2 asc

DE 3级coding水平（算法一般，颜值一般），为了使用 sort(key=lambda x: (-x[0], x[1]))，蠢蠢的构建了一个新的列表。

1. def frequency_sorting(numbers):
   
2.     list1 = []
   
3.     for num in numbers:
   
4.         list1.append([numbers.count(num),num])
   
5.     list1.sort(key=lambda x: (-x[0], x[1]))
   
6.     list2 = []
   
7.     for c in list1:
   
8.         list2.append(c[1])
   
9.     return list2

复制代码

DE 4级coding水平（算法一般，颜值尚可），一样的算法和思路，美颜了一下，看着舒服了一些。

1. def frequency_sorting(numbers):
   
2.     list1 = [[numbers.count(c),c] for c in numbers]
   
3.     list1.sort(key=lambda x: (-x[0], x[1]))
   
4.     return [item[1] for item in list1]

复制代码

DE 5级coding水平（算法OK，颜值OK），为了实现多要素同时排序，不一定要构建新列表用sort(key=lambda x: (-x[0], x[1]))，可以多重嵌套sorted(sorted(numbers), key=numbers.count, reverse=True)，最外层的优先级最高，最里面的优先级最低。

1. def frequency_sorting(numbers):
   
2.     return sorted(sorted(numbers), key=lambda x: numbers.count(x), reverse=True)

复制代码

numbers.count(x)的问题楼上都说了，你的最佳解实际上时间复杂度是n^2*logn。除此之外：
1. 像下面这样的one-liner牺牲了太多可读性。楼主还记得Python的设计哲学之一——可读性吧？业界也不鼓励可读性差的代码

1. return sorted(sorted(numbers), key=lambda x: numbers.count(x), reverse=True)

复制代码

2. 两个嵌套的sorted也不是相当于创建了两个lists吗？而且sorted(nums)的意义在于什么？浪费n*logn的时间复杂度，完全可以只用一个sorted解决。

如果让我来写：

1. from Collections import Counter
   
2. def solution(nums):
   
3.     num_count = Counter(nums)
   
4.     return sorted(nums, key = lambda num: num_count[num], reverse = True)
   
5.     # 如果允许修改原本的nums，直接nums.sort() 也行        
   
6.     # 这道题我假设是保留重复的元素，实际面试时应当先clarify是否需要保留重复元素

复制代码

补充：
楼主clarify题目以后，我发现sorted(nums)确实有意义，可以保留。如果不想排序两次可以通过别的一些方法来实现仅排序一次.

建议进一个大公司然后多参与几次3人以上的code review,

lambda x: numbers.count(x)

这一步是O(N). 性能不好。
正确的应该是 from collections import Counter

DE日常最重要的工作就是数据清理，如何清理一个列表呢？

3级的coding：（硬干，全部转换成字符串，然后把‘[’,']',空格，都删掉，然后把剩下的数字装入新列表）

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
   
9. 
   
10. if __name__ == '__main__':
    
11.     assert flat_list([1, 2, 3]) == [1, 2, 3], "First"
    
12.     assert flat_list([1, [2, 2, 2], 4]) == [1, 2, 2, 2, 4], "Second"
    
13.     assert flat_list([[[2]], [4, [5, 6, [6], 6, 6, 6], 7]]) == [2, 4, 5, 6, 6, 6, 6, 6, 7], "Third"
    
14.     assert flat_list([-1, [1, [-2], 1], -1]) == [-1, 1, -2, 1, -1], "Four"
    
15.     print('Done! Check it')

复制代码

6级的coding：（首先颜值在线，递归算法高级，SUM()巧妙实现列表的拼接）

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

复制代码

关于列表排序的终极总结

1. array = [[1,4,3],[2, 2, 2],[1,4,1]]
   
2. 
   
3. def flat_list(array):
   
4.    
   
5.     return sorted(array,key = lambda x:(x[1],-x[0],x[2]))
   
6. 
   
7.     return sorted(sorted(sorted(array),key=lambda x:x[0],reverse=True),key=lambda x:x[1])
   
8. 
   
9. 
   
10. print(flat_list(array))
    
11. 
    
12. [[2, 2, 2], [1, 4, 1], [1, 4, 3]]

复制代码

对字典类型的原始数据进行清理

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": ""}

我这方法能达到4.5级了吗？

1. def flatten(dictionary):   
   
2.     dic = {}
   
3.     for key in dictionary.keys():
   
4.         if type(dictionary[key]) is str:
   
5.             dic[key] = dictionary[key]
   
6.         elif len(dictionary[key])==0:
   
7.             dic[key] = ''
   
8.         else:
   
9.             item = flatten(dictionary[key])
   
10.             for x in item:
    
11.                 dic[key+'/'+x] = item[x]
    
12.     return dic

复制代码

掌握了sum()列表合并叠加，就可以不用办法了。

1. 
   
2.     list1 = []
   
3.     for x in array:
   
4.         if type(x) != list:
   
5.             list1.append(x)
   
6.         else:
   
7.             list1.extend(flat_list(x))
   
8.     return list1
   
9. 
   
10.     return sum(([x] if type(x) != list else flat_list(x) for x in array),[])

复制代码

又找了一个7级的大神过来看，5级是Senior可以干到退休的那种，6级是经理，7级是staff engineer有人事决定权的总监了。7级说，3级的算法思路可以，但是需要美颜。

3级原始代码

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

复制代码

在3级的算法思路上，7级稍稍开了美颜之后的样子，瞬间不一样了。会用import，比会用sum()，感觉更高级。

1. import re
   
2. 
   
3. def helper(a):
   
4.     return [int(x) for x in re.findall(r'\d+',str(a))]

复制代码

4 - 5 级代码

1. list1 = []
   
2. for x in array:
   
3.     if type(x) != list:
   
4.         list1.append(x)
   
5.     else:
   
6.         list1.extend(flat_list(x))

复制代码

6 级代码

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

复制代码

趁热打铁，出一道题：

c = [1,2,3,4]
d = [4,1,3,2] # c数列中的数值在output新数列中出现的次数。

output：[1, 1, 1, 1, 2, 3, 3, 3, 4, 4]

1. def helper(c,d):
   
2.     return sum(([x]*y for x,y in zip(c,d)),[])

复制代码

再来一道，7级的DE说，10分钟搞定这道题，就可以通过5级DE的VO Coding部分。

You have a set of "words", all in lower case, and each word contains symbols in "alphabetical order". (it's not your typical alphabetical order, but a new and different order.) We need to determine the order of the symbols from each "word" and create a single "word" with all of these symbols, placing them in the new alphabetial order. In some cases, if we cannot determine the order for several symbols, you should use the traditional latin alphabetical order. For example: Given words "acb", "bd", "zwa". As we can see "z" and "w" must be before "a" and "d" after "b". So the result is "zwacbd".

Input: Words as a list of strings.

Output: The order as a string.

Example:

checkio(["acb", "bd", "zwa"]) == "zwacbd"
checkio(["klm", "kadl", "lsm"]) == "kadlsm"
checkio(["a", "b", "c"]) == "abc"
checkio(["aazzss"]) == "azs"
checkio(["dfg", "frt", "tyg"]) == "dfrtyg"

我现在的代码写的有点模样了吧？！

1. def checkio(data):
   
2.     letters = sorted(list(set(sum((list(x) for x in data),[]))))
   
3.     new_data = ''
   
4.     for c in letters:      
   
5.         for item in letters:                  
   
6.             if item not in new_data and all(item not in word or item == word[0] for word in data):                        
   
7.                 new_data += item
   
8.                 for i in range(len(data)):  
   
9.                     data[i] = data[i].replace(item, '')
   
10.                 break                  
    
11.     return new_data
    
12.                     
    
13.    
    
14. 
    
15. #These "asserts" using only for self-checking and not necessary for auto-testing
    
16. if __name__ == '__main__':
    
17.     assert checkio(["acb", "bd", "zwa"]) == "zwacbd", \
    
18.         "Just concatenate it"
    
19.     assert checkio(["klm", "kadl", "lsm"]) == "kadlsm", \
    
20.         "Paste in"
    
21.     assert checkio(["a", "b", "c"]) == "abc", \
    
22.         "Cant determine the order - use english alphabet"
    
23.     assert checkio(["aazzss"]) == "azs", \
    
24.         "Each symbol only once"
    
25.     assert checkio(["dfg", "frt", "tyg"]) == "dfrtyg", \
    
26.         "Concatenate and paste in"

复制代码

插眼插眼插眼插眼插眼插眼插眼mark

看到numbers.count(num)就笑了，但再一看是3级，想着原来是要给后面留空间
但看到最后还是numbers.count(num)，这是在黑DE？