Question

我见过几次的面试问题是

给出employee_id到boss_id的映射（用于直接命令链）只有），回报每个老板间接管理的员工数量。

我在SQL中找到了几个解决方案，但无法找到任何pythonic方法的例子。

更详细的问题定义：

想象一下，我们有一个包含employee_id和boss_id的dict。在下面的例子中，C是A的管理者，C也是B的管理者，F是C的管理者，依此类推。 F是他们自己的经理，因此是层级的根（即CEO）。每位员工直接向一位经理报告。

emp_boss_map = dict([
 ("A","C"),
 ("B","C"),
 ("C","F"),
 ("D","E"),
 ("E","F"),
 ("F","F")])

编写一个函数来构建每个员工下员工数量的字典，而不仅仅是他们的直接下属。

输出应如下所示：

{A:0,B:0,C:2,D:0,E:1,F:5}

如何在Python中解决这个问题？

更新：根据@prune的建议，我使用

撤销了dict

newdict = {}
for key, value in emp_boss_map.items():
    for string in value:
        newdict.setdefault(string, []).append(key)

返回 {＆＃39; C＆＃39;：[＆＃39; A＆＃39;，＆＃39; B＆＃39;]，＆＃39; E＆＃39;：[＆＃39; D＆＃39;]，＆＃39; F＆＃39;：[＆＃39; C＆＃39;，＆＃39; E＆＃39;，＆＃39; F＆＃39;]}

Answer 1

这是树上的闭包问题。首先，反转（反向）字典。从那时起，它是每个子树中节点的直接计数，每个节点上的递归算法：对每个孩子重复，对他们的返回值求和，为每个孩子加1，这就是总数直接报告当前节点。

这会让你感动吗？

full_report = {}

def report_count(node):
    global full_report
    report_list = newdict[node]
    count = len(report_list)     # start with quantity of direct reports

    # Find number of reports for each of those reports
    for report in report_list:
    count += report_count(report)

    full_report[node] = count          # add entry for this node to global count list
    return count + len(report_list)    # return this count to supervisor

我已经为您打开了很多详细信息，例如查找所有根节点（来自原始字典），或者找到比主列表的全局变量更好的内容。

这会让你找到最终解决方案吗？

Answer 2

您可以通过反转字典并递归遍历直到结尾来解决此问题。

result_count=[]
def get_me_the_children(root):
    if reverse_d.get(root,0) == 0:
        return
    for _ in reverse_d.get(root,0):
        if _== root:
            continue
        else:
            get_me_the_children(_)
            print(_,end=" ")
            result_count.append(_)

if __name__ == "__main__":
    input_d = {"A":"A","B":"A","C":"B","D":"B","E":"D","F":"E"}
    reverse_d={}
    result_count_dict = {}

    for key,values in input_d.items():
        reverse_d.setdefault(values,[])
        reverse_d[values].append(key)

    #reverse_d = {'A': ['A', 'B'], 'B': ['C', 'D'], 'D': ['E'], 'E': ['F']}

    for key,value in input_d.items():
        result_count=[]
        print(key,end=": ")
        get_me_the_children(key)
        result_count_dict[key] = len(result_count)
        print("")

    print(result_count_dict) #{'A': 5, 'B': 4, 'C': 0, 'D': 2, 'E': 1, 'F': 0}

    """output:
        A: C F E D B 
        B: C F E D 
        C: 
        D: F E 
        E: F 
        F:  
    """

Answer 3

def m1(dict):
    new_dict = {}
    keys_list = {keys for keys in dict.keys()}
    for key, val in dict.items():
        if key==val:
            continue
        if val not in new_dict.keys():
            new_dict[val] = 1
        else:
            new_dict[val] = new_dict[val] + 1
        if key in new_dict.keys():
            new_dict[val] = new_dict[val] + new_dict[key]
    for keys in keys_list:
        if keys not in new_dict.keys():
            new_dict[keys]=0
    print(new_dict)


emp_boss_map={'A': 'C', 'B': 'C', 'C': 'F', 'D': 'E', 'E': 'F', 'F': 'F'}
m1(emp_boss_map)

Python中间接员工面试挑战的数量

3 个答案: