基础算法题总结6--python输入输出格式

python 涉及的函数

python 的基础数据结构有：列表、元组、序列、集合、字典等
Python 的输入输出包括了从控制台上获取的数据以及链表、栈、树等自输入的设计

map () 函数会根据提供的函数对指定序列做映射，返回一个迭代器
map(function, iterable, …)

• function 函数
• iterable 一个或多个序列

input () 函数接受一个标准输入数据，返回为 string 类型
input([prompt])

• prompt: 提示信息

list () 方法用于将元组或字符串转换为列表，返回列表
list(seq)

• seq: 要转换为列表的元组或字符串

join () 方法用于将序列中的元素以指定的字符连接生成一个新的字符串，返回通过指定字符连接序列中元素后生成的新字符串
str.join(sequence)

• sequence: 要连接的元素序列

测试用例如果以行的形式输入
list(map(int,input().split()))

有可能会出现 EOF 的错误，为了避免这个错误的出现，需要将输入套上 try…except… 异常检测

具体的题目练习

其中的 a+b 和字符串的输入输出问题的来源是牛客网

a+b(1)

输入描述：输入包括两个正整数 a,b (1 <= a, b <= 10^9), 输入数据包括多组。
输入格式：
1 5
10 20
输出格式：
6
30

import sys
for line in sys.stdin:
    a = line.split()
    print(int(a[0]) + int(a[1]))

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

a+b(2)

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

while True:
    try:
        t = int(input())
        for i in range(t):
            nums = list(map(int, input().split(' ')))
            print(nums[0]+nums[1])
    except:
        break

while True:
    try:
        t = int(input())
        for i in range(t):
            a,b = map(int, input().split(' '))
            print(a+b)
    except:
        break

a+b(3)

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

输入格式：
1 5
10 20
0 0

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

a+b(4)

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

输入格式：
4 1 2 3 4
5 1 2 3 4 5
0

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

a+b(5)

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

while True:
    try:
        n = int(input())
        for _ in range(n):
            nums = list(map(int, input().split()))
            print(sum(nums[1:]))
    except:
        break

a+b(6)

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

while True:
    try:
        nums = list(map(int, input().split()))
    except:
        break
    n = nums[0]
    sumvalue = 0
    for i in range(1,n+1):
        sumvalue += nums[i]
    print(sumvalue)

a+b(7)

输入描述:
输入数据有多组，每行表示一组输入数据。
每行不定有 n 个整数，空格隔开。(1 <= n <= 100)。

while True:
    try:
        nums = list(map(int, input().split()))
    except:
        break
    ## print(sum(nums))
    sumValue = 0
    for _ in nums:
        sumValue += _
    print(sumValue)

字符串排序 (1)

输入描述：
输入有两行，第一行 n
第二行是 n 个空格隔开的字符串

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

输入:
5
c d a bb e

输出:
a bb c d e

while True:
    try:
        n = int(input())
        arr = input().split(' ')
    except:
        break
    arr = sorted(arr)
    out = ' '.join(arr)
    print(out)

字符串排序 (2)

输入描述：
多个测试用例，每个测试用例一行。
每行通过空格隔开，有 n 个字符，n＜100
输出描述:
对于每组测试用例，输出一行排序过的字符串，每个字符串通过空格隔开

while True:
    try:
        arr = input().split(' ')
    except:
        break
    arr = sorted(arr)
    out = ' '.join(arr)
    print(out)

字符串排序 (3)

输入描述:
多个测试用例，每个测试用例一行。
每行通过，隔开，有 n 个字符，n＜100
输出描述:
对于每组用例输出一行排序后的字符串，用’,’隔开，无结尾空格

while True:
    try:
        arr = input().split(',')
    except:
        break
    arr = sorted(arr)
    out = ','.join(arr)
    print(out)

自测本地提交为 0

输入描述:
输入有多组测试用例，每组空格隔开两个整数
输出描述:
对于每组数据输出一行两个整数的和

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

class ListNode:  ## 链表的节点
    def __init__(self,val):
        self.val = val
        self.next = None

class LinkList:  ## 链表
    def __init__(self):
        self.head = None

def initList(self,data):  ## 初始化链表，将列表转换成链表
        self.head = ListNode(data[0])
        start = self.head
        p = self.head

for i in data[1:]:
            node = ListNode(i)
            p.next = node
            p = p.next
        return start

def printList(self,head):  ## 输出链表
        if head == None:
            return
        node = head
        while node != None:
            if node.next:
                print(node.val, end='-->')
            else:
                print(node.val, end='')
            node = node.next

if __name__ == "__main__":
    l = LinkList() ## 初始化链表对象
    data1 = [1,2,3,4]
    data2 = [3,4,5,6]
    l1 = l.initList(data1) ## 创建链表
    l2 = l.initList(data2)
    l.printList(l1)  ## 输出链表
    print("\r")
    l.printList(l2)
    print("\r")

栈 (后进先出)

使用顺序表实现栈

class Stack:
    def __init__(self):
        self.stack = []

def empty(self):  ## 判断栈是否为空
        return len(self.stack) == 0
        # return self.stack == []

def length(self):
        return len(self.stack)

def push(self,item):  ##进栈
        self.stack.append(item)

def pop(self):  ## 出栈
        if self.empty():
            return None
        return self.stack.pop()

def top(self):  ## 查看栈顶元素

if self.empty():
            return None
        return self.stack[-1]

if __name__ == "__main__":
    stack = Stack() ## 初始化栈对象
    stack.push(1)
    stack.push(2)
    stack.push(3)
    stack.push(4)
    print(stack.pop()) ## 4
    print(stack.top()) ## 3
    print(stack.length()) ## 3