Python学校非计分作业：复杂数据类型

目录

1.冒泡排序

2.有序数组插入

3. 二维矩阵各列求和

9.统计数字个数

 10.某班劳动之星选举程序

11.流行歌曲排行榜程序 

​编辑

 12.在字符串中查找第一个不重复字符

 14.字母数字转换

 15.选择排序

16.评委打分

17.矩阵转置

 26.折半查找

 29.字符串基本操作练习

31.利用字典管理学生基本信息

​编辑

30.运动会参赛人数统计程序

33.成绩排序​编辑

 35.字典构建程序（难！）​编辑

36.判断数据集是否包含了10~19之间的所有数

​编辑

---

1.冒泡排序

num = input().split()
num = [int(x) for x in num]
n = len(num)
for i in range(0,n-1):
    for j in range(0,n-i-1):
        if(num[j]>num[j+1]):
            num[j],num[j+1]=num[j+1],num[j]
print(' '.join(map(str,num)))

2.有序数组插入

n = int(input())
num = input().split()
num = [int(x) for x in num]
x = int(input())
flag = -1
for i in range(0,n):
    if(num[i]>x):
        flag = i
        break
if(flag == -1):#注意如果它大于列表里所有的数
    flag = n
num.insert(flag,x)
print(' '.join(map(str,num)))

3. 二维矩阵各列求和

a,b = map(int,input().split())
num = []#创建二维数组
for _ in range(a):#_的用法是只关注循环的次数
    row = list(map(int,input().split()))#一行一行的数输入
    num.append(row)#添加一行一行的数
sums = [sum(n) for n in zip(*num)]#*用于置换矩阵，将行变为列，zip把其变为元组，然后求置换后的每行的和
print(' '.join(map(str,sums)))

9.统计数字个数

n = list(map(int,input().split()))
count = {}
for num in n:
    if num in count:
        count[num] += 1
    else:
        count[num] = 1
counts = sorted(count.items(),key=lambda x: x[0]) 
for key,value in counts:
    print(f"{key:<6d} {value}")

 10.某班劳动之星选举程序

n = int(input())
students = []
for i in range(n):
    student = input().split()
    students.append(student)
vote = input().split()

votes = {}
for v in vote:
    if v in votes:
        votes[v] += 1
    else:
        votes[v] = 1

max_vote = max(votes.values())

result = [s for s in students if votes.get(s[0],0) == max_vote]

for r in result:
    print(' '.join(r))
    

11.流行歌曲排行榜程序 

n = int(input())
songs = []
for i in range(n):
    song = input().split()
    songs.append(song)

result = sorted(songs,key=lambda x:int(x[2]))

for r in result:
    print(" ".join(r))

 12.在字符串中查找第一个不重复字符

string = input()
flag = {}
x = 0
for s in string:
    if s in flag:
        flag[s] += 1
    else:
        flag[s] = 1
for s in string:
    if flag[s] == 1:
        print(s)
        x = 1
        break
if x == 0:
    print(string,"error")

 14.字母数字转换

zidian = {'abc':'2','def':'3','ghi':'4','jkl':'5','mno':'6','pqrs':'7','tuv':'8','wxyz':'9'}
def fun(string):
    result = ""
    for s in string:
        if s.isalpha():
            for key in zidian:
                if s in key:
                    result += zidian[key]
        elif s in ('0','1','2','3','4','5','6','7','8','9'):
            result += s
        elif s in ('-','*','#','+'):
            result += s
        else:
            return string + ' invalid'
    return result
string = input()
print(fun(string.lower()))

 15.选择排序

m = list(map(int,input().split()))
n = len(m)
for i in range(n):
    min_flag = i
    for j in range(i+1,n):
        if(m[j]<m[min_flag]):
            min_flag = j
    m[i],m[min_flag] = m[min_flag],m[i]

print(' '.join(map(str,m)))

冒泡排序（Bubble Sort）是一种基础的排序算法，它通过多次迭代比较相邻的元素并交换它们的位置来实现排序。在每一次迭代中，较大的元素会逐渐“冒泡”到列表的末尾。

冒泡排序的基本思想如下：

1. 从列表的第一个元素开始，比较相邻的两个元素。
2. 如果顺序不正确（即前一个元素大于后一个元素），则交换它们的位置。
3. 继续向后遍历列表，重复步骤 2，直到到达列表的末尾。
4. 重复以上步骤，每次迭代都会将当前未排序部分的最大元素“冒泡”到末尾。
5. 重复进行多次迭代，直到整个列表排序完成。

冒泡排序的时间复杂度为 O(n^2)，其中 n 是列表的长度。尽管冒泡排序在最坏情况下的效率较低，但对于小型数据集来说，它是一种简单且易于实现的排序算法。

选择排序（Selection Sort）也是一种简单的排序算法，它通过在每一次迭代中选择未排序部分的最小元素，并将其放置在已排序部分的末尾来实现排序。

选择排序的基本思想如下：

1. 将列表分为已排序部分和未排序部分。初始时，已排序部分为空，未排序部分包含整个列表。
2. 在未排序部分中找到最小的元素，并将其与未排序部分的第一个元素交换位置。
3. 将交换后的元素移动到已排序部分的末尾。
4. 重复步骤 2 和步骤 3，直到未排序部分为空。
5. 最终，整个列表将按照从小到大的顺序排序完成。

选择排序的时间复杂度也为 O(n^2)，其中 n 是列表的长度。与冒泡排序相比，选择排序的交换次数较少，因此在某些情况下可能略优于冒泡排序。

16.评委打分

n = list(map(float, input().split()))
s = sorted(n)
s = s[1:-1]
result = sum(s) / len(s)
print("%.2f" % result)

在代码 print("%.2f" % sum(s)/len(s)) 中，由于运算符优先级的问题，sum(s)/len(s) 的计算会在应用格式化字符串 "%.2f" 之前执行。这会导致错误的结果。 

17.矩阵转置

m,n = map(int,input().split())
num = []
for i in range(m):
    s = list(map(int,input().split()))
    num.append(s)
result = list(zip(*num))
for r in result:
    print(' '.join(map(str,r)))

 26.折半查找

s = list(map(int,input().split()))
x = s[-1]
s = s[:-1]
left = 0
right = len(s)-1
flag = -1
while left <= right:
    mi = (left + right) // 2
    if x < s[mi]:
        right = mi - 1
    elif x >s[mi]:
        left = mi + 1
    elif x == s[mi]:
        flag = mi
        break
if flag != -1:
    print(flag)
else:
    print(f"{x} no")

 29.字符串基本操作练习

s,ch1,ch2 = input().split()
print(s[0])
print(s[0:3])
print(s[-3:])
print(len(s))
if ch1 in s:
    print(s.find(ch1))
else:
    print(-1)
print(s.count(ch1))
print(s.replace(ch2,'-'))
print(s.upper())
print(s.split(ch2))

31.利用字典管理学生基本信息

n = int(input())
students = {}
for i in range(n):
    student = input().split()
    students[student[0]] = [student[1],student[2]]
a = list(map(int,input().split()))
b = list(map(int,input().split()))
for key in students:
    if a[0]>int(students[key][0]) or a[1]<int(students[key][0]):
        students[key][0] = '*'+students[key][0]+'cm'
    else:
        students[key][0] = students[key][0]+'cm'
    if b[0]>int(students[key][1]) or b[1]<int(students[key][1]):
        students[key][1] = '*'+students[key][1]+'kg'
    else:
        students[key][1] = students[key][1]+'kg'
    print(key,students[key][0],students[key][1])

元组的话没法这样用students[key][0]

30.运动会参赛人数统计程序

m,n = map(int,input().split())
g = list(input().split())
y = list(input().split())
s1 = sorted(set(g + y))
s2 = sorted(set(g) & set(y))
s3 = sorted(set(g) - set(y))
s4 = sorted(set(y) - set(g))
s5 = sorted(set(s1) - set(s2))

print('所有跳高跳远运动员:',' '.join(s1))
print('两项比赛都参加的有:',' '.join(s2))
print('只参加跳高比赛的有:',' '.join(s3))
print('只参加跳远比赛的有:',' '.join(s4))
print('只参加一项比赛的有:',' '.join(s5))

s1本质是列表 

33.成绩排序

student = []

while True:
    s = input().split()
    if(s[0] == '0'):
        break
    else:
        student.append(s)

result = sorted(student,key = lambda x: (int(x[2]),x[1]))
for s in result:
     print(' '.join(s))

 35.字典构建程序（难！）

n = input().split()
jian = {}
flag = 0
for s in n:
    if s[0].isalpha():
        if s[0] not in jian:
            jian[s[0]] = [s]
        else:
            jian[s[0]].append(s)
    elif flag == 0:
        jian['others'] = [s]
        flag = 1
    else:
        jian['others'].append(s)
        
for key in jian:
    jian[key].sort()

for key in sorted(jian.keys()):
    if(key != 'others'):
       zhi = jian[key]
       count = len(zhi)
       zhi.insert(0,count)
       print(f"{key} : {zhi}")

if 'others' in jian:
    zhi = jian['others']
    count = len(zhi)
    zhi.insert(0,count)
    print(f"others : {zhi}")

def build_dictionary(strings):
    dictionary = {}
    others = []

    for string in strings:
        first_char = string[0].lower()

        if first_char.isalpha():
            if first_char in dictionary:
                dictionary[first_char].append(string)
            else:
                dictionary[first_char] = [string]
        else:
            others.append(string)

    for key in dictionary:
        dictionary[key].sort()

    others.sort()

    if others:
        dictionary['others'] = others

    for key in sorted(dictionary.keys()):
        value = dictionary[key]
        count = len(value)
        value.insert(0, count)
        print(f"{key} : {value}")


# 从键盘输入一组字符串，空格分隔
input_str = input("请输入一组字符串，空格分隔: ")
strings = input_str.split()

# 调用函数构建字典并输出结果
build_dictionary(strings)

36.判断数据集是否包含了10~19之间的所有数

n = list(map(int, input().split()))
num = list(range(10, 20))
if all(x in n for x in num):
    n = tuple(n)
    print(n, "cover all numbers")
else:
    n = tuple(n)
    print(n, "don't cover all numbers")