acm输入和输出

多⾏输⼊，每⾏两个整数

import sys
# 接收输⼊
for line in sys.stdin:
	a, b = line.split(' ')     # 输出
    print(int(a) + int(b))     # 输出换⾏
    print()

2. 多组数据，每组第⼀⾏为n, 之后输⼊n⾏两个整数

while 1:
	try:
		N = int(input())
		for i in range(N):
		l = list(map(int,input().split()))
		print(sum(l))
	except:
break

3. 若⼲⾏输⼊，每⾏输⼊两个整数，遇到特定条件终⽌

import sys
while True:
s = input().split() # ⼀⾏⼀⾏读取
a, b = int(s[0]), int(s[1])
if not a or not b: # 遇到 0, 0 则中断
break
print(a + b)

4. 若⼲⾏输⼊，遇到0终⽌，每⾏第⼀个数为N，表示本⾏后⾯有N个数

import sys
for line in sys.stdin:
nums = line.split()
nums = list(map(int, nums))
n = nums[0]
if not n:
break
print( sum(nums[-n:]) )

5. 若⼲⾏输⼊，每⾏包括两个整数a和b，由空格分隔，每⾏输出后接⼀个空⾏。

while True:
try:
x, y = map(int, (input().split()))
print(x + y)
print()
except:
break

6. 多组n⾏数据，每⾏先输⼊⼀个整数N，然后在同⼀⾏内输⼊M个整数,每组输出之间输出⼀个空⾏

while 1:
try:
N = int(input())
for i in range(N):
n = list(map(int, input().split()))
if n[0] == 0:
print()
continue
print(sum(n[1:]))
if i<N-1:
print()
except:
break

7. 多组测试样例，每组输⼊数据为字符串，字符⽤空格分隔,输出

为⼩数点后两位

while 1:
try:
n = input().replace(" ", "").replace("A", "4").replace("B", "3").replace("C",
"2").replace("D", "1").replace(
"F", "0")
s = 0
for i in n:
if i not in '43210':
print('Unknown')
break
s += int(i)
else:
print(f"{s / len(n):.2f}")
except:
break

8. 多组测试⽤例，第⼀⾏为正整数n, 第⼆⾏为n个正整数，n=0

时，结束输⼊，每组输出结果的下⾯都输出⼀个空⾏

while 1:
try:
n = int(input())
if n == 0:
break
ls = list(map(int, input().split()))
# 遍历
for i in ls:
#操作
print(moves//2)
print()
except:
break

9. 多组测试数据，每组数据只有⼀个整数，对于每组输⼊数据，

输出⼀⾏，每组数据下⽅有⼀个空⾏。

while 1:
try:
n=input()
s=0
for i in n:
print(int(i))
print(s)
print()
except:
break

10. 多组测试数据，每个测试实例包括2个整数M，K

（2<=k<=M<=1000)。M=0，K=0代表输⼊结束。

while True:
M, K = map(int, input().split())
if M == 0 and K == 0:
break
res = M
print(res)

11. 多组测试数据，⾸先输⼊⼀个整数N，接下来N⾏每⾏输⼊两

个整数a和b, 读取输⼊数据到Map

while True:
try:
N = int(input())
myMap = {}
for _ in range(N):
a, b = map(int, input().split())
myMap[a] = b
except:
break

12. 多组测试数据。每组输⼊⼀个整数n，输出特定的数字图形

while True:
try:
n = int(input())
for i in range(1, n + 1):
print(' ' * (n - i), end='')
print(''.join(map(str, range(1, i + 1))) + ''.join(map(str, range(i - 1, 0,
-1))))
for i in range(n - 1, 0, -1):
print(' ' * (n - i), end='')
print(''.join(map(str, range(1, i + 1))) + ''.join(map(str, range(i - 1, 0,
-1))))
except:
break

13. 多⾏输⼊，每⾏输⼊为⼀个字符和⼀个整数，遇到特殊字符

结束

while True:
try:
line = input()
if line == '@':
break
ch, n = line.split()
n = int(n)
except:

14. 第⼀⾏是⼀个整数n，表示⼀共有n组测试数据, 之后输⼊n⾏

字符串

T = int(input())
for _ in range(T):
words = input().split()
for word in words:

15. 第⼀⾏是⼀个整数n，然后是n组数据，每组数据2⾏，每⾏

为⼀个字符串，为每组数据输出⼀个字符串，每组输出占⼀⾏

n = int(input())
for _ in range(n):
line1 = input()
line2 = input()
mid = len(line1) // 2
result = line1[:mid] + line2 + line1[mid:]
print(res

16. 多组测试数据，第⼀⾏是⼀个整数n，接下来是n组字符串，

输出字符串

C = int(input())
for _ in range(C):
s = input()
print(result)

17. 多组测试数据，每组测试数据的第⼀⾏为整数N

（1<=N<=100），当N=0时，输⼊结束，第⼆⾏为N个正整数，
以空格隔开，输出结果为字符串

while True:
n = int(input())
if n == 0:
break
sequence = list(map(int, input().split()))
stack = []
possible = True
for num in sequence:
stack.append(num)
if possible:
print('Yes')
else:
print('No')

18. ⼀组输⼊数据，第⼀⾏为n+1个整数，逆序插⼊n个整数，第

⼆⾏为⼀个整数m, 接下来有m⾏字符串，并根据字符串内容输
⼊不同个数的数据

if __name__ == "__main__":
while True:
mylinklist = MyLinkedList()
try:
# 读取链表⻓度和链表数值
n, *nums = list(map(int, input().split()))
# 初始化链表
for i in range(n):
mylinklist.addAtHead(nums[i])
# 读取操作的个数
m = int(input())
for i in range(m):
# 读取输⼊的操作和对应的索引
s = input().split()
if s[0] == "show":
if mylinklist.printLinkedList() == -1:
print("Link list is empty")
if s[0] == "delete":
t = int(s[1])
if mylinklist.deleteAtIndex(t - 1) == -1:
print("delete fail")
else:
print("delete OK")
if s[0] == "insert":
t = int(s[1])
z = int(s[2])
if mylinklist.addAtIndex(t - 1, z) == -1:
print("insert fail")
else:
print("insert OK")
if s[0] == "get":
t = int(s[1])
getValue = mylinklist.get(t - 1)
if getValue == -1:
print("get fail")
else:
print(getValue)
except:
break

19. 多组测试数据，每⾏为n+1个数字， 输出链表或对应的字符串

# 打印链表
def printLinkedList(head: LinkedNode):
cur = head
while cur:
print(cur.val, end = " ")
cur = cur.next
print()
if __name__ == "__main__":
while True:
try:
# 输⼊5 1 2 3 4 5，表示链表有5个节点，值分别为1 2 3 4 5
n, *nums = map(int, input().split())
except:
break
if n == 0:
print("list is empty")
continue
dummyHead = LinkedNode(0) # 这⾥定义的头结点 是⼀个虚拟头结点，⽽不是真正的链表头结点
cur = dummyHead
for i in range(n): # 开始构造节点
cur.next = LinkedNode(nums[i])
cur = cur.next
printLinkedList(dummyHead.next) # 打印链表
printLinkedList(reverseList(dummyHead.next)) # 打印翻转后的链表

20. 多组输⼊，每组输⼊包含两个字符串，输出字符串

def preorder(root):
if not root:
return []
left = preorder(root.left)
right = preorder(root.right)
return [root.val] + left + right
def inorder(root):
if not root:
return []
left = inorder(root.left)
right = inorder(root.right)
return left + [root.val] + right
def postorder(root):
if not root:
return []
left = postorder(root.left)
right = postorder(root.right)
return left + right + [root.val]
n = int(input())
nodes = [None] * (n + 1)
line_in = []
for i in range(n):
line = input().split()
val, left, right = line[0], int(line[1]), int(line[2])
root = nodes[1]
pre = preorder(root)
ino = inorder(root)
post = postorder(root)
print(''.join(pre))
print(''.join(ino))
print(''.join(post))
def main():
while True:
try:
# 接收⼀⾏作为输⼊，将之分隔成n, m
n, m = map(int, input().split())
# 接收m⾏作为输⼊
for i in range(m):
a, b, l = map(int, input().split())
# 接收⼀⾏作为输⼊，将之分隔成x, y
x, y = map(int, input().split())
if dist[x][y] == float('inf'):
print("No path")
else:
print(dist[x][y])
except EOFError:
break
if __name__ == "__main__":
main()