Python

• 1-2
• 1-3
• 1-5
• 1-6
• 1-9
• 7-1 统计不同数字字符的个数 (10 分)
• 7-2 马鞍点测试 (10 分)
• 7-3 求矩阵中的逆鞍点 (10 分)
• 7-4 判断对称方阵 (10 分)
• 7-5 统计字符个数 (10 分)
• 7-6 删除重复元素 (10 分)
• 7-7 变换数组元素 (10 分)
• 7-8 简单的归并 (10 分)
• 7-9 蛇形矩阵 (10 分)
• 7-10 两个矩阵之积 (10 分)

列表lst=[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]，则 lst[3:8:2]的结果是[-10, 35, 49]。

• T
• F

[1,2,[3]]+[4,5]的结果是[1,2,3,4,5]。

• T
• F

可以利用内置函数list()、tuple()、dict()、set()、frozenset()把其它类型的数据转换成为列表、元组、字典、可变集合和不可变集合，但不能创建空列表、空元组、空字典和空集合。(1分)

• T
• F

列表和元组中的元素必须具有相同类型，如：同为字符串类型、数值类型等等。

• T
• F

a=[1,2,3]

b=a

a[0]=4

print(b)

b[1]=5

#则输出结果为：[4, 5, 3]

• T
• F

7-1 统计不同数字字符的个数 (10 分)
输入只包含数字字符的字符串，统计串中不同字符的出现次数。

输入格式:
测试数据有多组，处理到文件尾。对于每组测试，输入一个字符串（不超过80个字符）。

输出格式:
对于每组测试，按字符串中出现字符的ASCII码升序逐个输出不同的字符及其个数（两者之间留一个空格），每组输出之后空一行，输出格式参照输出样例。

输入样例:
12123
输出样例:
1 2
2 2
3 1

仅供参考

while True:
    try:
        dict1={}
        var = input()
        for i in var:
            if i not in dict1:
                dict1[i]=var.count(i)
        # print(dict1)
        list1=list(dict1.items())
        list1.sort(key=lambda x:x[0])
        # print(list1)
        for i in list1:
            if i==list1[-1]:
                print('%c %d'%(i[0],i[1]),end='')
            else:
                print('%c %d'%(i[0],i[1]))
        print('n')
    except:
        break

7-2 马鞍点测试 (10 分)
如果矩阵A中存在这样的一个元素A[i][j]满足下列条件：A[i][j]是第i行中值最小的元素，且又是第j列中值最大的元素，则称之为该矩阵的一个马鞍点。请编写程序求出矩阵A的马鞍点。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 对于每组测试数据，首先输入2个正整数m、n（1 ≤ m，n ≤ 100），分别表示二维数组的行数和列数。 然后是二维数组的信息，每行数据之间用一个空格分隔，每个数组元素均在int型范围内。简单起见，假设二维数组的元素各不相同，且每组测试数据最多只有一个马鞍点。

输出格式:
对于每组测试数据，若马鞍点存在则输出其值，否则输出“Impossible”。注意，引号不必输出。

输入样例:
1
4 3
6 7 11
2 17 13
4 -2 3
5 9 88
输出样例:
6

仅供参考

T=int(input())
for t in range(T):
        m,n=map(int,input().split())
        s=[[0]*n]*m
        for i in range(0,m):
            s[i]=input().split()

        for i in range(0,m):
            for j in range(0,n):
                x=s[i][j]
                x=eval(x)
                s[i][j]=x


        list1=list()
        list2=list()
        for i in range(0,m):
            min=s[i][0]
            for j in range(0,n):
                if(min>s[i][j]):
                    min=s[i][j]

            list1.append(min)
        for i in range(0,n):
            max=s[0][i]
            for j in range(0,m):
                if(max 
7-3 求矩阵中的逆鞍点 (10 分) 
7-3 求矩阵中的逆鞍点 (10 分)
求出n×m二维整数数组中的所有逆鞍点。这里的逆鞍点是指在其所在的行上最大，在其所在的列上最小的元素。若存在逆鞍点，则输出所有逆鞍点的值及其对应的行、列下标。若不存在逆鞍点，则输出“Not”。要求至少使用一个自定义函数。

输入格式:
测试数据有多组，处理到文件尾。每组测试的第一行输入n和m（都不大于100），第二行开始的n行每行输入m个整数。

输出格式:
对于每组测试，若存在逆鞍点，则按行号从小到大、同一行内按列号从小到大的顺序逐行输出每个逆鞍点的值和对应的行、列下标，每两个数据之间一个空格；若不存在逆鞍点，则在一行上输出“Not”（引号不必输出）。

输入样例:
3 3
97 66 96
85 36 85
88 67 91
3 4
73 89 74 76
6 33 74 0
27 57 6 32
输出样例:
85 1 0
85 1 2
Not
 
仅供参考
 c++
 
#include
using namespace std;
const int N =5000;
int num[N][N];
int tmax[N];
int tmin[N];
int main(void){
	int m,n;
	while(~scanf("%d%d",&m,&n)){
		for(int i=0;i>num[i][j];
				if(!i) tmin[j]=num[i][j];
				if(!j) tmax[i]=num[i][j];
				tmax[i]=max(tmax[i],num[i][j]);
				tmin[j]=min(tmin[j],num[i][j]);
			}
		}
		int f=0;
		for(int i=0;i 
7-4 判断对称方阵 (10 分) 
7-4 判断对称方阵 (10 分)
输入一个整数n及一个n阶方阵，判断该方阵是否以主对角线对称，输出“Yes”或“No”。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组数据的第一行输入一个整数n（1 
仅供参考
 
T=eval(input())
for i in range(T):
    n=int(input())
    s=[[0]*n]*n
    for i in range(0,n):
        s[i]=input().split()

    for i in range(0,n):
        for j in range(0,n):
            x=s[i][j]
            x=eval(x)
            s[i][j]=x
 

    isSymmetrical=True
    for i in range(n):
        for j in range(n):
            if s[i][j]!=s[j][i]:
                isSymmetrical=False
                break
        if isSymmetrical==False:
            break

    if isSymmetrical==True:
        print('Yes')
    else:
        print('No')
 
7-5 统计字符个数 (10 分) 
7-5 统计字符个数 (10 分)
输入若干的字符串，每个字符串中只包含数字字符和大小写英文字母，统计字符串中有出现的不同字符的出现次数。

输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个字符串（不超过80个字符）。

输出格式:
对于每组测试，按字符串中有出现的字符的ASCII码升序逐行输出不同的字符及其个数（两个数据之间留一个空格），每两组测试数据之间留一空行，输出格式参照输出样例。

输入样例:
12123
A1c1B
输出样例:
1 2
2 2
3 1

1 2
A 1
B 1
c 1
 
仅供参考
 
f=1
while True:
    
    try:
        str=input()
        l=[]
        for s in str:
            l.append(s)

        nums=[]
        for i in range(ord('0'),ord('9')+1):
            nums.append(chr(i))
        for i in range(ord('A'),ord('Z')+1):
            nums.append(chr(i))
        for i in range(ord('a'),ord('z')+1):
            nums.append(chr(i))

        dct={}.fromkeys(nums,0)
        lst=[]
        for i in nums:
            dct[i]=l.count(i)
        if f!=1:
            print()

        for i in dct:
            if dct.get(i)!=0:
                print(i,dct.get(i),sep=" ")        
        f=0
    except:
        break

 
7-6 删除重复元素 (10 分) 
7-6 删除重复元素 (10 分)
对于给定的数列，要求把其中的重复元素删去再从小到大输出。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据先输入一个整数n（1≤n≤100），再输入n个整数。

输出格式:
对于每组测试，从小到大输出删除重复元素之后的结果，每两个数据之间留一个空格。

输入样例:
1
10 1 2 2 2 3 3 1 5 4 5
输出样例:
1 2 3 4 5
 
仅供参考
 
T=int(input())
for i in range(T):
    lst=list(map(int,input().split()))
    lst.remove(lst[0])
    s=set(lst)
    l=list(s)
    l.sort()
    for i in l:
        if i==l[-1]:
            print(i)
        else:
            print(i,end=' ')

 
7-7 变换数组元素 (10 分) 
7-7 变换数组元素 (10 分)
变换的内容如下： （1）将长度为10的数组中的元素按升序进行排序； （2）将数组的前n个元素换到数组的最后面。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每行测试数据输入1个正整数n（0 < n < 10），然后输入10个整数。

输出格式:
对于每组测试数据，输出变换后的全部数组元素。元素之间以一个空格分隔（最后一个数据之后没有空格）。

输入样例:
1
2 34 37 98 23 24 45 76 89 34 68
输出样例:
34 34 37 45 68 76 89 98 23 24
 
仅供参考
 
T=int(input())
for i in range(T):
    lst=list(map(int,input().split()))

    n=lst.pop(0)

    lst.sort()

    en=lst[0:n]

    for i in range(n):
        lst.remove(lst[0])
    lst.extend(en)

    for i in lst:
        if i== lst[-1]:
            print(i)
        else:
            print(i,end=' ')

 
7-8 简单的归并 (10 分) 
7-8 简单的归并 (10 分)
已知数组A和B各有m、n个元素，且元素按值非递减排列，现要求把A和B归并为一个新的数组C，且C中的数据元素仍然按值非递减排列。 例如，若A=(3，5，8，11)，B=(2，6，8，9，11，15，20)， 则C=(2，3，5，6，8，8，9，11，11，15，20)

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 每组测试数据输入两行，其中第一行首先输入A的元素个数m（1≤m≤100），然后输入m个元素。第2行首先输入B的元素个数n（1≤n≤100），然后输入n个元素。

输出格式:
对于每组测试数据。分别输出将A、B合并后的数组C的全部元素。输出的元素之间以一个空格分隔（最后一个数据之后没有空格）。

输入样例:
1
4 3 5 8 11
7 2 6 8 9 11 15 20
输出样例:
2 3 5 6 8 8 9 11 11 15 20
 
仅供参考
 
T=int(input())
for i in range(T):
    lst1=list(map(int,input().split()))
    lst1.remove(lst1[0])
    lst2=list(map(int,input().split()))
    lst2.remove(lst2[0])
    lst=[]
    lst.extend(lst1)
    lst.extend(lst2)
    lst=sorted(lst)
    for i in lst:
        if i==lst[-1]:
            print(i)
        else:
            print(i,end=' ')

 
7-9 蛇形矩阵 (10 分) 
7-9 蛇形矩阵 (10 分)
蛇形矩阵是由1开始的自然数依次排列成的一个上三角矩阵（参看 输出样例）。要求输入整数n，构造并输出蛇形矩阵。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个正整数N（N不大于100)。

输出格式:
对于每组测试，输出一个共有N行的蛇形矩阵。每行的每两个数字之间留一个空格。

输入样例:
在这里给出一组输入。例如：

1
5
输出样例:
1 3 6 10 15
2 5 9 14
4 8 13
7 12
11
 
仅供参考
 
T=int(input())
for N in range(T):
    n=int(input())

    s = [[0 for i in range(n)] for j in range(n)]

    s[0][0]=1
    i,j=1,0

    x=2
    while i 
7-10 两个矩阵之积 (10 分) 
7-10 两个矩阵之积 (10 分)
输入整数m、p、n，再输入一个m行p列的整数矩阵A和一个p行n列的整数矩阵B，求两个矩阵的乘积AB

输入格式:
测试数据有多组，处理到文件尾。每组测试数据的第一行输入n（1 
仅供参考
 
while(True):
    try:
        lis1,lis2 = [],[]
        m,p,n = map(int,input().split())
        for i in range(m):
             nums = list(map(int,input().split()))
             lis1.append(nums)
        for i in range(p):
             nums = list(map(int,input().split()))
             lis2.append(nums)
        res = []
        for a in range(m):
             res.append([])
             for b in range(n):
                 lis4 = []
                 lis3 = lis1[a]
                 for c in range(p):
                    lis4.append(lis2[c][b])
                 res_num = sum(map(lambda x,y:x*y,lis3,lis4))
                 res[a].append(res_num)
        for i in res:
             r = n
             for o in i:
                 r = r - 1
                 print(o,end='')
                 if(r>0):
                        print(end=' ')
             print()
    except:
        break