add PTA of ZJU_MOOC in Python & part of AdvancedLevel PAT in Python

AdvancedLevel_Python/1001.py

@@ -0,0 +1,26 @@
+n, m = list(map(int, input().split()))
+
+ans = str(n + m)
+
+def get_list(ans):
+    a, b = len(ans) / 3, int(len(ans) % 3)
+    if not b == 0:
+        re = [ans[:b]]
+    else:
+        re = []
+    for i in range(0, int(a)):
+        re.append(ans[b + 3 * i:b + i * 3 + 3])
+    return re
+
+if len(ans) < 4:
+    print(ans)
+else:
+    if int(ans) < 0:
+        re = get_list(ans[1:])
+        tmp = ','.join(re)
+        print('-' + tmp)
+
+    else:
+        re = get_list(ans)
+        print(','.join(re))
+

AdvancedLevel_Python/1002.py

@@ -0,0 +1,37 @@
+p = []
+
+p.append(input().split())
+
+p.append(input().split())
+
+p_dict = [{int(x[2 * i + 1]) : float(x[2 * i+2]) for i in range(int(x[0]))} for x in p]
+
+final = {}
+
+for d in p_dict:
+    for key in d.keys():
+        if not key in final:
+            final[key] = d[key]
+        else:
+            final[key] += d[key]
+
+s = ''
+
+tmp = []
+
+final_sorted_keys = sorted(final, key=lambda x:-x)
+
+k = 0
+
+for i in iter(final_sorted_keys):
+    if not final[i] == 0:
+        tmp.append(str(i))
+        tmp.append(str(round(final[i]* 10) / 10))
+        k += 1
+if k != 0:
+    s += str(k) + ' '
+else:
+    s += str(k)
+s += ' '.join(tmp)
+
+print(s)

AdvancedLevel_Python/1003.py

@@ -0,0 +1,35 @@
+n, m = list(map(int, input().split()))
+
+data = []
+
+if n == 0 :
+    exit(0)
+
+for i in range(m):
+    data.append(input().split())
+
+def build_tree(data):
+    tree = {}
+    for i in data:
+        tree[i[0]] = i[2:]
+    return tree
+
+def deeper(tree):
+    head = '01'
+    layer = [head]
+    ans = []
+    while layer:
+        num_of_leaves = 0
+        next_layer = []
+        for node in layer:
+            if not node in tree.keys():
+                num_of_leaves += 1
+            else:
+                son_of_node = tree[node]
+                next_layer += son_of_node
+        ans.append(num_of_leaves)
+        layer = next_layer
+
+    return ans
+
+print(' '.join(list(map(str, deeper(build_tree(data))))))

AdvancedLevel_Python/1004.py

@@ -0,0 +1,35 @@
+n, m = list(map(int, input().split()))
+
+data = []
+
+if n == 0 :
+    exit(0)
+
+for i in range(m):
+    data.append(input().split())
+
+def build_tree(data):
+    tree = {}
+    for i in data:
+        tree[i[0]] = i[2:]
+    return tree
+
+def deeper(tree):
+    head = '01'
+    layer = [head]
+    ans = []
+    while layer:
+        num_of_leaves = 0
+        next_layer = []
+        for node in layer:
+            if not node in tree.keys():
+                num_of_leaves += 1
+            else:
+                son_of_node = tree[node]
+                next_layer += son_of_node
+        ans.append(num_of_leaves)
+        layer = next_layer
+
+    return ans
+
+print(' '.join(list(map(str, deeper(build_tree(data))))))

AdvancedLevel_Python/1005.py

@@ -0,0 +1,7 @@
+n = input()
+
+s = str(sum([int(i) for i in n]))
+
+database = ['zero', 'one', 'two','three', 'four', 'five', 'six', 'seven', 'eight', 'nine']
+
+print(' '.join([database[int(j)] for j in s]))

AdvancedLevel_Python/1006.py

@@ -0,0 +1,23 @@
+k = int(input())
+
+diary = []
+
+def date2second(date):
+    h,m,s = date.split(':')
+    return 3600 * h + 60 * m + s
+
+for i in range(k):
+    record = input().split()
+    diary.append(record)
+
+diary.sort(key=lambda x:date2second(x[1]))
+
+first_bird = diary[0][0]
+
+diary.sort(key=lambda x:date2second(x[2]))
+
+last_one = diary[-1][0]
+
+print(first_bird + ' ' + last_one)
+
+

AdvancedLevel_Python/1007.py

@@ -0,0 +1,37 @@
+k = int(input())
+
+nums = list(map(int, input().split()))
+
+max_arr = []
+max_ = 0
+
+tmp = 0
+tmp_arr = []
+
+for i in range(len(nums)):
+
+    if tmp > 0:
+        tmp += nums[i]
+
+        tmp_arr.append(nums[i])
+    else:
+        tmp = nums[i]
+
+        tmp_arr = [tmp]
+
+    if tmp > max_:
+        max_ = tmp
+
+    from copy import deepcopy
+
+    max_arr.append(deepcopy(tmp_arr))
+
+if max_ > 0:
+    for arr in max_arr:
+        if sum(arr) == max_:
+            print(max_, arr[0], arr[-1])
+            exit(0)
+elif max_ == 0:
+    print(0,0,0)
+else:
+    print(0, nums[0], nums[-1])

AdvancedLevel_Python/1008.py

@@ -0,0 +1,35 @@
+k = int(input())
+
+nums = list(map(int, input().split()))
+
+max_arr = []
+max_ = 0
+
+tmp = 0
+tmp_arr = []
+
+for i in range(len(nums)):
+
+    if tmp > 0:
+        tmp += nums[i]
+
+        tmp_arr.append(nums[i])
+    else:
+        tmp = nums[i]
+
+        tmp_arr = [tmp]
+
+    if tmp >= max_:
+        max_ = tmp
+
+    from copy import deepcopy
+
+    max_arr.append(deepcopy(tmp_arr))
+
+if max_ > 0:
+    for arr in max_arr:
+        if sum(arr) == max_:
+            print(max_, arr[0], arr[-1])
+            exit(0)
+else:
+    print(0, nums[0], nums[-1])

AdvancedLevel_Python/1009.py

@@ -0,0 +1,30 @@
+a = list(map(float, input().split()))
+
+b = list(map(float, input().split()))
+
+arr1 = [[a[2*i +1], a[2*i+2]] for i in range(int(a[0]))]
+
+arr2 = [[b[2*i + 1], b[2*i+2]] for i in  range(int(b[0]))]
+
+def conv(arr1, arr2):
+
+    matrix = {}
+
+    for x in arr1:
+        def dot(x, arr2):
+            ans = []
+            for y in arr2:
+                ans.append([x[0]+y[0],x[1]*y[1]])
+            return ans
+
+        vector = dot(x, arr2)
+
+        for z in vector:
+            if z[0] in matrix:
+                matrix[z[0]] += z[1]
+            else:
+                matrix[z[0]] = z[1]
+    matrix_ = sorted(matrix, key=lambda x:-x)
+    return str(len([key for key in iter(matrix) if matrix[key] != 0 ])) + ' ' + ''.join([str(int(key)) + ' ' + str(round(matrix[key] *10) / 10) +' ' for key in matrix_ if matrix[key] != 0])
+
+print(conv(arr1, arr2)[:-1])

AdvancedLevel_Python/1011.py

@@ -0,0 +1,15 @@
+def myread():
+    return list(map(float, input().split()))
+
+
+games = [myread() for i in range(3)]
+
+diary = ['W', 'T', "L"]
+
+ans = ' '.join([diary[i] for i in [x.index(max(x)) for x in games]])
+
+from functools import reduce
+
+total = str(round((reduce(lambda x, y:x*y, [max(i) for i in games]) * 0.65 - 1) * 2 * 100) / 100)
+
+print(ans + ' ' + total)

AdvancedLevel_Python/1012.py

@@ -0,0 +1,39 @@
+def myread():
+    return list(map(int, input().split()))
+
+n, m = myread()
+
+database = {}
+
+scores_rank = {'C':[], 'M':[],'E':[],'A':[]}
+
+for i in range(n):
+    tmp = myread()
+    database[str(tmp[0])] = [sum(tmp[1:])] + tmp[1:]
+    scores_rank['C'].append(tmp[1])
+    scores_rank['M'].append(tmp[2])
+    scores_rank['E'].append(tmp[3])
+    scores_rank['A'].append(sum(tmp[1:]))
+
+for key in scores_rank:
+    scores_rank[key].sort(reverse=True)
+
+query = []
+
+diary = [ 'A', 'C', 'M', 'E']
+
+for i in range(m):
+    tmp = input()
+    if not tmp in database.keys():
+        print('N/A')
+    else:
+        finished = False
+        for k in range(n):
+            if not finished:
+                for j in range(4):
+                    if scores_rank[diary[j]][k] <= database[tmp][j]:
+                        print(str(k+1) + ' ' + diary[j])
+                        finished = True
+                        break
+            else:
+                break

AdvancedLevel_Python/1013.py

@@ -0,0 +1,49 @@
+def myread():
+    return list(map(int, input().split()))
+
+
+n, m, k = myread()
+
+graph = [[-1 for i in range(n)] for j in range(n)]
+
+for i in range(m):
+    tmp = myread()
+    graph[tmp[0] - 1][tmp[1] - 1 ] = 1
+    graph[tmp[1] - 1][tmp[0] - 1] = 1
+
+query = myread()
+
+
+def wander(graph, bad, his):
+
+    total = []
+
+    def walk(graph, s, bad, his):
+
+        his.append(s)
+        tmp = [s]
+        layer = [s]
+        while layer:
+            next_layer = []
+            for node in layer:
+                for i in range(n):
+                    if graph[node][i] == 1 and i not in his and i != bad and i not in layer:
+                        next_layer.append(i)
+                        his.append(i)
+                        tmp.append(i)
+            layer = next_layer
+
+        return tmp
+
+    for i in range(n):
+        if i != bad and i not in his:
+            total.append(walk(graph, i, bad, his))
+
+    return len(total) - 1 if len(total) >= 1 else 0
+
+
+for ruined_city in query:
+    his = []
+    print(wander(graph, ruined_city - 1, his))
+
+