ACM模式下Python的输入输出

po主原本是通过c++进行刷题的，对于C++而言还是很方便输入和输出的

最近刷题都在用python，主要是因为python编写起来比较方便，加上想尽快刷掉leetcode上的必刷题，所以一时间不知道应该如何用python进行IO流的输入和输出

————————————————
版权声明：本文为CSDN博主「文山湖的猫」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/single_dog/article/details/125702956

---

 

1.1 获取输入数据

Python输入数据主要通过input()函数实现，input()会读取控制台一行的输入，如果输入有多行的话，需要多次使用input()。

# 输入为: 1 2 3 4 5
a = input()
# a = '1 2 3 4 5'

Python3中的input()会将接受的数据返回为一个string类型，如果一行中有多个数据的话，则需要使用split()进行切割。split()切割后返回一个列表。

#输入为：1 2 3 4 5
a = input().split()
# a = ['1', '2', '3', '4', '5']

#输入为：1，2，3，4，5
b = input().split(',')
#b = ['1', '2', '3', '4', '5']

因为input()返回的是string，分割后也是一个字符列表，如果输入数据是数字则需要进行类型转换。可以单个转换或是用列表批量转换，或者是使用map()并行转换。map()函数返回的是一个迭代器，不能改变值，如果需要改变值的话还需要转换成列表

#输入为： 1
a = int(input()) #单个转换

#输入为：1 2 3 4 5
b = input().split()
c = [int(i) for i in b]

#也可以为
d = [int(i) for i in input().split()]

#使用map进行并行转换
#多行输入转换
e = map(int, input().split())
f = list(e)
#简写：
g = list(map(int, input().split()))

 

1.2 三种情况的输入数据

情况1: 多行输入，同时未指定用例的个数

while True:
    try:
        data = input()
        solve(data)
    except:
        break

情况2: 多行输入， 指定用例个数

n = int(input())
for _ in range(n):
    data = input()
    solve(data) #核心函数

情况3: 多行输入，指定某个条件退出

while True:
    data = input()
    if judge(data):
        break
    solve(data)

2. 输出函数模板

Python3的输出主要靠print()函数，就是把结果打印至终端。需要对print()函数的sep和end两个参数有一定的了解，可以查看菜鸟教程
情况1: 输出单个数字

# 输出 a (a = 1)
print(a)

情况2: 输出多个数字，同时要求以分隔符隔开

# 输出 a=1, b=2, c=3
print(a, b, c) # print默认以空格为分隔符
# output：1 2 3
print(a, b, c, sep=',') # 以逗号为分隔符
# output：1,2,3

情况3：最终结果是一个列表

# 最终结果 res = [1, 2, 3]
# 1. 直接输出列表
print(res)
# 2. 输出列表, 每个元素单独输出
for i in range(len(res)):
    print(res[i])
#output: 1
#        2
#        3

# 3. 输出列表，每个元素单独输出，同时还需要在同一行输出, 以空格分隔
for i in range(len(res)):
    print(res[i], end=' ')  # end的默认值是'\n'，即换行
    # output: 1 2 3 

情况4: 将字符列表合成一个字符串，需要用到join()函数

# res = ['a', 'b', 'c']
# 输出是一个字符串
print("".join(res))
# output: abc

# 输出是一个字符串，且用 * 号分隔
print("*".join(res))
# output: a*b*c
# 如果用 print(res[i], end = '*') 的话，输出就是 a*b*c*了，在末尾还多了一个*

3. 链表的输入输出

acm模式中的链表也是通过输入一个数组来模拟的，所以获取输入数据和前面没有什么不同。
主要在于定义链表结构、将输入数据转化为链表以及输出链表。

#定义链表结构
class ListNode:
    def __init__(self, val, next = None):
        self.val = val
        self.next = next

# 数组转链表
def nums2ListNode(nums):
    dummy = ListNode(None)
    root = ListNode(nums[0])

 

    dummy.next = root
    i = 1
    while i < Len(nums):
        node = ListNode(nums[I])
        root.next = node
        root = root.next
        i += 1
        root.next = None
    return dummy.next
#打印链表
nums = [1,2,3,4,5]
root = nums2ListNode(nums)
while root:
    print(root.val)
    root = root .next

4. 二叉树
4. 二叉树的输入输出
4.1 完全二叉树格式输入
acm模式中一般用输入一行数字代表一个二叉树，一般会以完全二叉树格式输入。这行数字的按照层序遍历的顺序排列，且其中空节点一般会用特定的符号表示，如0或是null
可以直接用数组表示二叉树，例如列表Tree, 将Tree[i]的左子树和右子树分别为Tree[2*i+1]和Tree[2*i+2]，不过会比较占用空间。

中序遍历

def inorder_traversal(nums, index):
    if index >= Len(nums) or nums[index] == -1:
        return 
    left, right = 2 *index + 1, 2 * index +2
    inorder_traversal(nums, left)
    print(nums[index], end = ' ')
    inorder_traversal(nums, right)

if __name__  == "__main__":
    nums = input().split()
    nums = [int(num) if num != 'null' else -1 for num in nums]
    inorder_traversal(nums, 0)

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

#由数组转二叉树
def construct_binary_tree(nums, index):
    if index >= Len(nums):
        return 
    if nums[index] == -1"
        return None
    left = index*2-1
    right = index*2+1
    root = TreeNode(nums[index])
    root.left = construct_binary_tree(nums, left)
    root.right = construct_binary_tree(nums, right)
    return root

#中序遍历
def inorder_traversal(root):
    if not root: return 
    inorder_traversal(root.left)
    print(root.val, end=' ')
    inorder_traversal(root.right)

if __name__ == "__main__":
    nums = input().split()
    nums = [int(num) if num != 'null' else -1 for num in nums]
    root = construct_binary_tree(nums, 0)
    inorder_traversal(root)

4.2 其他格式输入

有部分题目的输入格式不是完全二叉树，例如leetcode的二叉树格式，输入的数组虽然也是按照层序遍历的顺序，但并不是每一层的空节点都会表示出来，而是仅表示与非空节点连接的空节点。

def construct_binary_tree(nums):
     if nums == [] :
        return 
    root = TreeNode(nums[0])
    queue = collections.deque()
    queue.append()
    I = 1
    while I < Len(nums):
        node = queue.popleft()
        if I < Len(nums) and nums[I] != -1:
            node.left = TreeNode(nums[I])
            queue.append(node.left)
        I += 1
        if I <len(nums) and nums[I] != -1:
            node.right = TreeNode(nums[I])
            queue.append(node.right)

        I += 1
    return root

# 中序遍历
def inorder_traversal(root):
    if not root: return
    inorder_traversal(root.left)
    print(root.val, end=' ')
    inorder_traversal(root.right)
  
# 输入 1 null 1 null 1 2
#    1
#  /  \
#null  1
#    /   \
#   null  1
#        /
#       2
if __name__ == "__main__":
    nums = input().split()
    nums = [int(num) if num != 'null' else -1 for num in nums]
    root = construct_binary_tree(nums)
    inorder_traversal(root)
      # 输出 1 1 2 1

 

---

 

Python ACM模式

• 告诉了有多少组数据
• 多组输入数据，但没指定多少组
• 输入一个整数告诉有多少组数据，再输入每组数据的具体值
• 多组数据，并告诉遇到怎么样的数据时结束（例如0 0）
• 多组数据，每组数据第一个代表这一组数据有几个，最后遇到0结束

版权声明：本文为CSDN博主「小成星际」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_40844276/article/details/120596128

告诉了有多少组数据

import sys

# 这里写解决问题的代码，和LeetCode就完全一样了
def solve(arr):
    sum = 0
    for i in range(len(arr)):
        sum += arr[i]
    return sum


if __name__ == '__main__':

    # 接收输入的逻辑，这里先把输入接收过来， 两种选择input()和sys.stdin.readline()
    group_nums = int(input().strip())

    # 对于每一组
    for i in range(group_nums):
        # 接收每一组的输入, 这里不同的题目就不一样了，但一定记住我们接收的还是一行，这是一个字符串
        arr = sys.stdin.readline().strip().split(' ')
        # 元素转成int
        arr = list(map(int, arr))

        # 输入接收过来之后，这里最好打印下看看接收的是不是正确，这个很重要
        # print(arr)

        # 处理具体的问题了
        res = solve(arr)

        # 输出结果
        print(res)

多组输入数据，但没指定多少组

import sys

# 这里写解决问题的代码，和LeetCode就完全一样了
def solve(arr):
    pass

if __name__ == '__main__':

    while True:
        try:
            a, b = map(int, input().strip().split())
            print(a + b)
        except EOFError:
            break

        # 输入接收过来之后，这里最好打印下看看接收的是不是正确，这个很重要
        # print(arr)

        # 处理具体的问题了
        #res = solve(arr)

        # 输出结果
        #print(res)

输入一个整数告诉有多少组数据，再输入每组数据的具体值

import sys

# 这里写解决问题的代码，和LeetCode就完全一样了
def solve(arr):
    pass

if __name__ == '__main__':

    tcase = int(input().strip())
    for case in range(tcase):
        a, b = map(int, input().strip().split())
        print(a + b)

        # 输入接收过来之后，这里最好打印下看看接收的是不是正确，这个很重要
        # print(arr)

        # 处理具体的问题了
        #res = solve(arr)

        # 输出结果
        #print(res)

多组数据，并告诉遇到怎么样的数据时结束（例如0 0）

import sys

# 这里写解决问题的代码，和LeetCode就完全一样了
def solve(arr):
    pass

if __name__ == '__main__':

    while True:
        a, b = map(int, input().strip().split())
        if a == 0 and b == 0:
            break
        print(a + b)

        # 输入接收过来之后，这里最好打印下看看接收的是不是正确，这个很重要
        # print(arr)

        # 处理具体的问题了
        #res = solve(arr)

        # 输出结果
        #print(res)

多组数据，每组数据第一个代表这一组数据有几个，最后遇到0结束

import sys

# 这里写解决问题的代码，和LeetCode就完全一样了
def solve(arr):
    pass

if __name__ == '__main__':

    while True:
        data = list(map(int, input().strip().split()))
        n, array = data[0], data[1:]
        if n == 0:
            break
        print(sum(array))

        # 输入接收过来之后，这里最好打印下看看接收的是不是正确，这个很重要
        # print(arr)

        # 处理具体的问题了
        #res = solve(arr)

        # 输出结果
        #print(res)

 

---