python：一篇文章掌握ACM模式下的所有情况输入

1.A+B(1)

输入描述：
输入包括两个正整数a,b(1 <= a, b <= 1000),输入数据包括多组。

输出描述：
输出a+b的结果

示例1
输入例子：
1 5
10 20
输出例子：
6
30

while True:
    try:
        a = list(map(int, input().split(" ")))
        print(sum(a))
    except:
        break

2.A+B(2)

输入描述：
输入第一行包括一个数据组数t(1 <= t <= 100)
接下来每行包括两个正整数a,b(1 <= a, b <= 1000)

输出描述：
输出a+b的结果

示例1
输入例子：
2
1 5
10 20
输出例子：
6
30

n = int(input())
for i in range(n):
    a = list(map(int, input().split(" ")))
    print(sum(a))

3.A+B(3)

输入描述：
输入包括两个正整数a,b(1 <= a, b <= 10^9),输入数据有多组, 如果输入为0 0则结束输入

输出描述：
输出a+b的结果

示例1
输入例子：
1 5
10 20
0 0
输出例子：
6
30

while True:
    a = list(map(int, input().split(" ")))
    if a[0] == 0 and a[1] == 0:
        break
    else:
        print(sum(a))

4.A+B(4)

输入描述：
输入数据包括多组。
每组数据一行,每行的第一个整数为整数的个数n(1 <= n <= 100), n为0的时候结束输入。
接下来n个正整数,即需要求和的每个正整数。

输出描述：
每组数据输出求和的结果

示例1
输入例子：
4 1 2 3 4
5 1 2 3 4 5
0
输出例子：
10
15

while True:
    a = list(map(int, input().split(" ")))
    if a[0] == 0:
        break
    else:
        print(sum(a[1:]))

5.A+B(5)

输入描述：
输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

输出描述：
每组数据输出求和的结果

示例1
输入例子：
2
4 1 2 3 4
5 1 2 3 4 5
输出例子：
10
15

n = int(input())
for i in range(n):
    a = list(map(int, input().split(" ")))
    print(sum(a[1:]))

6.A+B(6)

输入描述：
输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。

输出描述：
每组数据输出求和的结果

示例1
输入例子：
4 1 2 3 4
5 1 2 3 4 5
输出例子：
10
15

while True:
    try:
        a = list(map(int, input().split(" ")))
        print(sum(a[1:]))
    except:
        break

7.A+B(7)

输入描述：
输入数据有多组, 每行表示一组输入数据。

每行不定有n个整数，空格隔开。(1 <= n <= 100)。

输出描述：
每组数据输出求和的结果

示例1
输入例子：
1 2 3
4 5
0 0 0 0 0
输出例子：
6
9
0

while True:
    try:
        a = list(map(int, input().split(" ")))
        print(sum(a))
    except:
        break

8.字符串排序(1)

输入描述：
输入有两行，第一行n

第二行是n个字符串，字符串之间用空格隔开

输出描述：
输出一行排序后的字符串，空格隔开，无结尾空格

示例1
输入例子：
5
c d a bb e
输出例子：
a bb c d e

n = int(input())
a = sorted(list(input().split(" ")))
for i in range(n):
    print(a[i], end=" ")

9.字符串排序(2)

输入描述：
多个测试用例，每个测试用例一行。

每行通过空格隔开，有n个字符，n＜100

输出描述：
对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开

示例1
输入例子：
a c bb
f dddd
nowcoder
输出例子：
a bb c
dddd f
nowcoder

while True:
    try:
        a = sorted(list(input().split(" ")))
        n = len(a)
        for i in range(n):
            print(a[i], end=" ")
        print()
    except:
        break

10.字符串排序(3)

输入描述：
多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100

输出描述：
对于每组用例输出一行排序后的字符串，用’,'隔开，无结尾空格

示例1
输入例子：
a,c,bb
f,dddd
nowcoder
输出例子：
a,bb,c
dddd,f
nowcoder

while True:
    try:
        a = sorted(list(input().split(",")))
        n = len(a)
        temp = ""
        for i in range(n):
            temp = temp + a[i] + ","
        print(temp[:-1])
    except:
        break

11.链表（将输入的数组转为单链表）

class ListNode(object):
    def __init__(self, val):
        self.val = val
        self.next = None


# 通过尾插法获得链表
def nums_to_linklist(nums):
    if not nums:
        return None

    head = ListNode(nums[0])
    tail = head
    for i in nums[1:]:
        node = ListNode(i)
        tail.next = node
        tail = node
    return head


if __name__ == '__main__':
    nums = ['1', '2', '3', '4', '5']
    head = nums_to_linklist(nums)
    while head:
        print(head.val, end="->")
        head = head.next
    print(None)

结果

1 2 3 4 5 

12.二叉树（将输入的数组转为二叉树）

import collections


class BiTree(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


def nums_to_tree(nums):
    if not nums:
        return None
    queue = collections.deque()
    root = BiTree(nums[0])
    queue.append(root)
    i = 1
    while i < len(nums):
        node = queue.popleft()
        if i < len(nums) and nums[i] != -1:
            node.left = BiTree(nums[i])
            queue.append(node.left)
        i += 1

        if i < len(nums) and nums[i] != -1:
            node.right = BiTree(nums[i])
            queue.append(node.right)
        i += 1

    return root


# 中序遍历
def in_order(root):
    if not root:
        return None

    in_order(root.left)
    print(root.val, end=" ")
    in_order(root.right)


# 输入 1 null 1 null 1 2
#    1
#  /  \
# null  1
#      /  \
#   null  1
#        /
#       2
if __name__ == '__main__':
    nums = ['1', 'null', '1', 'null', '1', '2']
    nums = [int(i) if i != "null" else -1 for i in nums]
    root = nums_to_tree(nums)
    in_order(root)

结果

1 1 2 1