1002 A+B for Polynomials

题目描述：

有两个多项式A和B，分别为两行，第一行的第一个数字是A多项式的项数，后面每两个数字分别为指数和系数。要求对这两个多项式相加，最后输出一个多项式，输出的多项式格式和输入的多项式相同，系数保留一位小数。

---

题目思路：

我们只需要把A和B中指数相同的项，系数相加就可以了，然后从大到小输出不为0的项

---

题目考点：

字典dict数据结构、zip函数、map函数、sorted函数的用法

---

题目踩坑：

① 根据0≤N​K​​ <⋯<N​2​​ <N​1​​ ≤1000此条件可知：

• 指数是要从大到小排列的
• 同一多项式的指数不会有相等的情况

② 输入的项相加后可能为0，系数为0的项不用输出
③ 当两个多项式相加为0时，最后只输出0
④ 系数都要保留一位小数

---

题目代码：

方法一：(笨方法，各种循环遍历，此方法测试点二一直不通过)

a_list = input().split(" ")
b_list = input().split(" ")
i = 1
j = 1
a_dict = {}
b_dict = {}
result_dict = {}
while i < len(a_list):
    a_dict.update({a_list[i]: a_list[i+1]})
    i = i+2

while j < len(b_list):
    b_dict.update({b_list[j]: b_list[j+1]})
    j = j+2

for x in a_dict.keys():
    b_coefficient = b_dict.get(x)
    if b_coefficient is None:
       result_dict.update({x: str(round(float(a_dict.get(x)), 1))})
    else:
        coefficient = round(float(b_coefficient) + float(a_dict.get(x)), 1)
        if coefficient != 0:
            result_dict.update({x: str(coefficient)})
        b_dict.pop(x)
if b_dict != {}:
    for y in b_dict.keys():
        result_dict.update({y: str(round(float(b_dict.get(y)), 1))})

result_dict1 = sorted(result_dict.items(), key=lambda x: x[0], reverse=True)

num = str(len(result_dict1))
result_list = [num]
for t in result_dict1:
    result_list.append(t[0])
    result_list.append(t[1])

print(" ".join(result_list))

方法二：（利用zip函数和for key in (a.keys() | b.keys()) ：省去多余循环）

ins1 = input()
ins2 = input()
a = dict(zip(map(int, ins1.split()[1::2]), map(float, ins1.split()[2::2])))
b = dict(zip(map(int, ins2.split()[1::2]), map(float, ins2.split()[2::2])))
poly = {}

for key in (a.keys() | b.keys()):
    total = a.get(key, 0.0) + b.get(key, 0.0)
    if total != 0.0:
        poly[key] = total

poly = sorted(poly.items(), key=lambda x: x[0], reverse=True)
line = ' '.join(map(lambda x: '{:d} {:.1f}'.format(*x), poly))
k = len(poly)

if k:
    print(k, line)
else:
    print(0)

---

代码分析：

① zip()函数 – zip([iterable, …])

• zip()是Python的一个内建函数，它接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同
• zip函数的返回值是一个zip对象，要用list，dict进行转换

a = [1, 2, 3]
b = [2, 3, 4]
c = [4, 5, 6, 7]
# 返回一个对象
zipped = zip(a, b)
 
# list() 转换为列表
print(list(zipped))
运行结果：
[(1, 2), (2, 3), (3, 4)]
 
# 元素个数与最短的列表一致
zipped = zip(a, c)
print(list(zipped))
print(type(zipped), zipped)
运行结果：
[(1, 4), (2, 5), (3, 6)]
<class 'zip'> <zip object at 0x000001C7C9814180> 
# zip对象可以转化为字典
name_list = ["bob", "jim", "james", "julie", "june"]
number_list = ["1", "2", "3", "4", "5"]
name_and_number = dict(zip(name_list, number_list))
print(name_and_number)
运行结果：
{'bob': '1', 'jim': '2', 'james': '3', 'julie': '4', 'june': '5'}

② map()函数 – map(function, iterator1,iterator2 …iteratorN)

• 功能：对一个序列中的所有元素进行function操作，返回包含每次 function 函数返回值的新列表（map对象），可以用list进行转换
• function：要提供给map（）的必须参数，它将应用于迭代器中所有可用的项目
• iterator：一个可迭代的必须对象。 它可以是列表，元组等。我们还可以将多个迭代器对象传递给map（）函数。

>>> def square(x) :         # 计算平方数
...     return x ** 2
...
>>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
<map object at 0x100d3d550>     # 返回迭代器
>>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]
>>>

③ sorted()函数 --sorted(iterable,key=None, reverse=False)

• sorted()函数可以对所有可迭代的对象进行排序操作
• iterable：可迭代对象
• key：通过这个参数可以自定义排序逻辑
• reverse：指定排序规则，True为降序，False为升序（默认）。
• sorted()函数返回重新排序的列表，与sort()函数的区别在于sort()函数是list列表中的函数，而sorted()函数可以对所有可迭代对象进行排序操作。并且用sort()函数对列表排序时会影响列表本身，而sorted()函数则不会
• sorted()函数虽然可以处理所有可迭代的对象，例如集合、元组、数组，但是输出结果仍然是一个列表。所以如果返回的对象需要匹配输入类型，那么需要将转化为新类型

list1 = [('david', 90), ('mary',90), ('sara',80),('lily',95)]
>>> sorted(list1,key = lambda list1: list1[0])
[('david', 90), ('lily', 95), ('mary', 90), ('sara', 80)]
>>> sorted(list1,key = lambda list1: list1[1])
[('sara', 80), ('david', 90), ('mary', 90), ('lily', 95)]

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10),]  
sorted(students, key=lambda student : student[2])   # sort by age  
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]