【Python程序设计】实验08(列表和元组)

1、【描述】
输入10个整数，存放在列表中，找出值最大和最小的元素，输出最大值、最小值及它们所在的元素下标。
【输入】
在一行中输入10个整数，其间以空格分隔。
【输出】
第一行输出最大值及其所在的元素下标，最大值和下标以空格间隔。
第二行输出最小值及其所在的元素下标，最小值和下标以空格间隔。
【输入示例】

1 3 5 7 9 6 0 8 2 4

【输出示例】

9 4
0 6

【来源】
《Python程序设计基础》第5章编程题5。

def main():
    line = input().split()
    lst = [int(x) for x in line]
    print(max(lst), lst.index(max(lst)))
    print(min(lst), lst.index(min(lst)))
    
main()

2、【描述】
给定一组整数，要求利用列表把这组数保存起来，实现对列表中的数循环移动。假定共有n个整数，则要使前面各数顺序向后移m个位置，并使最后m个数变为最前面的m个数。
一定要保证在输出结果时，输出的顺序和列表中数的顺序是一致的。
【输入】
第一行包含一个正整数n和一个正整数m，n和m以空格间隔。
第二行包含n个正整数，整数以空格间隔。
【输出】
依次输出经过循环移动后列表中元素值，元素值以空格间隔。
【输入示例】

11 4
15 3 76 67 84 87 13 67 45 34 45

【输出示例】

67 45 34 45 15 3 76 67 84 87 13

【来源】
《Python程序设计基础》第5章编程题7。

n, m = map(int, input().split())
lst = list(map(int, input().split()))
lst1 = lst[0:-m]
lst2 = lst[n - m:len(lst)]
lst3 = lst2 + lst1
for i in lst3:
    print(i, end = ' ')

3、【描述】
给定一个整数列表，求列表中第k大的数。注意，第k大的数意味着从大到小排在第k位的数。
【输入】
第一行输入k。第二行输入n个整数，整数之间以空格分隔。
【输出】
该列表中第k大的数。
【输入示例】

2
4 1 3 2

【输出示例】

3

【来源】
《Python程序设计基础》第5章编程题8。

k = int(input())
line = input().split()
a = [int(x) for x in line]
a.sort(reverse=True)
print(a[k - 1])

4、【描述】
定义函数：def mean_median(t)，该函数接受一个正整数元组作为参数，返回元组中正整数的均值和中位数。一组数据按从小到大的顺序依次排列，位于中间位置的一个数或位于中间位置的两个数的平均值被称为中位数。如果这组数的个数为奇数，则中位数是位于中间位置的数；如果这组数的个数为偶数，则中位数是位于中间位置的两个数的平均值。
【输入】
在一行中顺序输入若干个正整数，其间以空格分隔。
【输出】
输出这些正整数的均值和中位数。
【输入示例】

3 3 0 1 12 13 15 16

【输出示例】

(7.875, 7.5)

def mean_median(t):
    meanValue = sum(t) / len(t)
    new_t = sorted(t)
    if len(new_t) %2 == 1:
        medianValue = new_t[len(new_t) // 2]
    else:
        medianValue = (new_t[len(new_t) // 2 - 1] + new_t[len(new_t) // 2]) /2.0
    return meanValue, medianValue

def main():
    line = input().split()
    lst = [int(x) for x in line]
    print(mean_median(tuple(lst)))

main()

5、

【描述】
给定n行m列的图像各像素点的灰度值，要求用如下方法对其进行模糊化处理：
1. 四周最外侧的像素点灰度值不变；
2. 中间各像素点新灰度值为该像素点及其上下左右相邻四个像素点原灰度值的平均（舍入到最接近的整数）。
【输入】
第一行包含两个整数n和m，表示图像包含像素点的行数和列数。1≤n≤100，1≤m≤100。
接下来n行，每行m个整数，表示图像的每个像素点灰度。相邻两个整数之间用单个空格隔开，每个元素均在0~255之间。
【输出】
n行，每行m个整数，为模糊处理后的图像。相邻两个整数之间用单个空格隔开。
【输入示例】

4 5
100 0 100 0 50
50 100 200 0 0
50 50 100 100 200
100 100 50 50 100

【输出示例】

100 0 100 0 50
50 80 100 60 0
50 80 100 90 200
100 100 50 50 100

n, m = map(int, input().split())
a = []
b = []
for i in range(n):
    a.append([])
    b.append([])
    line = input().split()
    a[i] = [int(x) for x in line]
    b[i] = [int(x) for x in line]
for i in range(1, n - 1):
    for j in range(1, m - 1):
        b[i][j] = int((a[i][j] + a[i - 1][j] + a[i + 1][j] + a[i][j - 1] + a[i][j + 1]) / 5.0 + 0.5)
for i in range(n):
    for j in range(m):
        print(b[i][j], end=' ')
    print()

6、

【描述】
给定M行N列的整数矩阵A，如果A的非边界元素A[i][j]大于相邻的上下左右4个元素，那么就称元素A[i][j]是矩阵的局部极大值。求给定矩阵的全部局部极大值及其所在的位置。
【输入】
在第一行中给出矩阵A的行数M和列数N（3≤M,N≤20）；下面M行，每行给出A在该行的N个元素的值。数字间以空格分隔。
【输出】
每行按照“元素值 行号 列号”的格式输出一个局部极大值，其中行、列编号从1开始。要求按照行号递增输出；若同行有超过1个局部极大值，则该行按列号递增输出。若没有局部极大值，则输出“None 总行数 总列数”。
【输入示例】

4 5
1 1 1 1 1
1 3 9 3 1
1 5 3 5 1
1 1 1 1 1

【输出示例】

9 2 3
5 3 2
5 3 4

def main():
    m, n = map(int, input().split())
    matrix = []
    for row in range(m):
        matrix.append([])
        line = input().split()
        matrix[row] = [eval(x) for x in line]
    flag = False;
    for row in range(1, m - 1):
        for col in range(1, n - 1):
            if matrix[row][col] > matrix[row - 1][col] and \
               matrix[row][col] > matrix[row + 1][col] and \
               matrix[row][col] > matrix[row][col - 1] and \
               matrix[row][col] > matrix[row][col + 1]:
                flag = True
                print("%d %d %d" % (matrix[row][col], row + 1, col + 1))
    if not flag:
        print("None %d %d" % (m, n))

main()

7、【描述】
输入10个整数，将10个整数按升序排列输出，并且奇数在前，偶数在后。
【输入】
输入10个整数，以空格间隔。
【输出】
输出升序排列后，奇数在前，偶数在后的数组元素，以空格间隔。最后一个元素后面没有空格。
【输入示例】

10 9 8 7 6 5 4 3 2 1 

【输出示例】

1 3 5 7 9 2 4 6 8 10

#coding=utf-8
line = input().split()
lst = [int(x) for x in line]
lst.sort()
result = []
# 奇数
for i in range(len(lst)):
    if lst[i] % 2 != 0:
        result.append(lst[i])
# 偶数
for i in range(len(lst)):
    if lst[i] % 2 == 0:
        result.append(lst[i])
for i in range(len(result) - 1):
    print(result[i], end=' ')
print(result[len(lst) - 1])

8、【描述】
编写程序，输入10个数，计算这10个数的均值和标准差。用下面的公式计算均值mean和标准差deviation：

【输入】
一行中给出10个数，其间以空格分隔。
【输出】
第一行为均值。
第二行为标准差。
结果保留2位小数。
【输入示例】

583 566 58 632 244 485 600 432 88 562

【输出示例】

425.00
216.48

import math
def mean(lst):
    return sum(lst) / len(lst)

def deviation(lst):
    mean1 = mean(lst)
    squareSum = 0;
    for i in range(len(lst)):
        squareSum += math.pow(lst[i] - mean1, 2)
    return math.sqrt(squareSum / (len(lst) - 1))

def main():
    line = input().split()
    lst = [float(x) for x in line]
    print("%.2f" % mean(lst))
    print("%.2f" % deviation(lst))
    
main()

9、

【描述】
读入一个整数n，范围是[3,100]，这表示井字棋棋盘的边长。比如n=3就表示是一个3x3的棋盘。然后，要读入n行，每行n个数字，每个数字是1或0，依次表示[0,0]到[n-1,n-1]位置上的棋子。1表示X，0表示O（大写字母O）。

判断其中是否存在某一方获胜，获胜的条件是存在整行或整列或整条对角线或整条反对角线上是相同的棋子。如果存在，则输出代表获胜一方字母：X或O（大写字母X或O）；如果没有任何一方获胜，则输出NIL（三个大写字母，中间是字母I（India的I）。

注意：所给的棋盘上的棋子分布可能出现同一个棋子有多处满足获胜的条件，但是不会出现两种棋子都获胜的情况。
【输入】
一个代表棋盘大小的数字n，后面跟上nxn个0或1的数字。
【输出】
三种输出之一：
X
O
NIL
均为大写字母。
【输入示例】

4
1 0 0 1
0 1 0 0
0 0 1 0
1 0 0 1

【输出示例】

X

def main():
    n = int(input())
    tictactoe = []
    for row in range(n):
        tictactoe.append([])
        line = input().split()
        tictactoe[row] = [eval(x) for x in line]
    tag = -1

    for i in range(n):
        num = tictactoe[i][0]
        for j in range(n - 1):
            if tictactoe[i][j] != tictactoe[i][j + 1]:
                break
            if j == n - 2:
                tag = num

    for j in range(n):
        num = tictactoe[0][j]
        for i in range(n - 1):
            if tictactoe[i][j] != tictactoe[i + 1][j]:
                break
            if i == n - 2:
                tag = num

    for i in range(n - 1):
        if tictactoe[i][i] != tictactoe[i + 1][i + 1]:
            break
        if i == n - 2:
            tag = tictactoe[0][0];

    for i in range(n - 1):
        if tictactoe[n - 1 - i][i] != tictactoe[n - 2 - i][i + 1]:
            break
        if i == n - 2:
            tag = tictactoe[n - 1][0]
    if tag == 1:
        print("X")
    elif tag == 0:
        print("O")
    else:
        print("NIL")

main()

10、【描述】
定义函数：def list_to_tuples(two_dimensional_list)，该函数接受一个二维列表作为参数，内嵌列表的元素是字符串；返回一个二维元组，内嵌元组的内容是内嵌列表的内容的逆序。 
例如，如果输入的二维列表是：[['mean', 'really', 'is', 'jean'], ['world', 'my', 'rocks', 'python']]，函数返回元组：(('jean', 'is', 'really', 'mean'), ('python', 'rocks', 'my', 'world'))。
【输入】
每一行输入一个字符串，字符串中单词之间以空格分隔。每行字符串构成二维列表的一个内嵌列表。可能会有多行输入。
【输出】
一个二维元组。
【输入示例】

mean really is jean
world my rocks python

【输出示例】

(('jean', 'is', 'really', 'mean'), ('python', 'rocks', 'my', 'world'))

def list_to_tuples(two_dimensional_list):
    lst = []
    for i in range(len(two_dimensional_list)):
        item = two_dimensional_list[i]
        item.reverse()
        lst.append(tuple(item))
    return tuple(lst)

def main():
    lst = []
    sentinel = ''
    for line in iter(input, sentinel):
        lst.append(line.split())
    print(list_to_tuples(lst))

main()