Python练习题六

博主：👍不许代码码上红
欢迎：🐋点赞、收藏、关注、评论。

一、判断双对称矩阵

题目

对于一个n阶方阵，请判断该方阵是否双对称， 即既左右对称又上下对称。
若是则输出“yes”，否则输出“no”。

思路

先判断矩阵的每一行是否对称，再判断矩阵的每一列。

代码

T=int(input())
for i in range(T):
    n=int(input())
    list=[]
    for i in range(n):
        list.append(input().split())
    flag=0
    k=int(n/2)
    for i in range(k):
        if list[i]!=list[n-i-1]:
            flag=1
            break
    if flag!=1:
        for list2 in list:
            for j in range(k):
                if list2[i]!=list2[n-i-1]:
                    flag=1
                    break
    if flag==0:
        print("yes")
    else:
        print("no")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

结果

二、武林盟主

题目

在传说中的江湖中，各大帮派要选武林盟主了，如果龙飞能得到超过一半的帮派的支持就可以当选，而每个帮派的结果又是由该帮派帮众投票产生的，如果某个帮派超过一半的帮众支持龙飞，则他将赢得该帮派的支持。现在给出每个帮派的帮众人数，请问龙飞至少需要赢得多少人的支持才可能当选武林盟主？

思路
先将所有帮派人数从多到少排序，只需要计算出所给的帮派中，一半帮派数是多少，然后在这一半帮派中每个帮派一半人是多少，所选出的这一半帮派中，每个帮派一半人数之总和便是最终结果。

代码

try:
    while True:
        n, *lst = map(int, input().split())
        i = 0
        result = 0
        lst.sort()  # 从小到大排序就能保证最后的支持帮众人数最少
        while i <= n//2:  # 帮派超过半数
            result += (int(lst[i]//2) + 1)  # 每个帮派的人数超过半数
            i += 1
        print(result)
except EOFError:
    pass

1
2
3
4
5
6
7
8
9
10
11
12
13

运行

三、交换数组元素

题目

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

思路
先用sort函数对数组排序，然后将前n个元素与后n个交换位置。

代码

def print_list(lst):
    for i in range(len(lst)):
        if i != len(lst) - 1:
            print(lst[i], end=' ')
        else:
            print(lst[i])
def reverse_list(lst, index, legth):
    start = index
    end = index + legth - 1
    while start < end:
        lst[start], lst[end] = lst[end], lst[start]
        start += 1
        end -= 1


t = int(input())
for i in range(t):
    n, *lst = map(int, input().split())
    lst.sort()
    reverse_list(lst, 0, n)
    reverse_list(lst, n, len(lst) - n)
    reverse_list(lst, 0, len(lst))
    print_list(lst)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行

四、简单的归并

题目

已知数组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)

思路
代码

def print_list(lst):
    for i in range(len(lst)):
        if i != len(lst) - 1:
            print(lst[i], end=' ')
        else:
            print(lst[i])


t = int(input())
for i in range(t):
    m, *lstA = map(int, input().split())
    n, *lstB = map(int, input().split())
    x = 0
    y = 0
    lstC = []
    while x < m and y < n:
        if lstA[x] <= lstB[y]:
            lstC.append(lstA[x])
            x += 1
        else:
            lstC.append(lstB[y])
            y += 1
    while x < m:
        lstC.append(lstA[x])
        x += 1
    while y < n:
        lstC.append(lstB[y])
        y += 1
    print_list(lstC)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

运行

五、保持数列有序

题目

有n个整数，已经按照从小到大顺序排列好，现在另外给一个整数x，请将该数插入到序列中，并使新的序列仍然有序。

思路
代码

def print_list(lst):
    for i in range(len(lst)):
        if i != len(lst) - 1:
            print(lst[i], end=' ')
        else:
            print(lst[i])



def print_list(lst):
    for i in range(len(lst)):
        if i != len(lst) - 1:
            print(lst[i], end=' ')
        else:
            print(lst[i])



try:
    while True:
        n, x, *lst = map(int, input().split())
        lst.append(x)  # 为什么要这样，因为不这样会超出索引返回，不可以直接lst[n](会提示超出索引范围)
        start = n  # 因为可能存在这个要插入的数是最大值
        for i in range(n):
            if x < lst[i]:
                start = i
                break
        for j in range(n, start, -1):
            lst[j] = lst[j-1]
        lst[start] = x
        print_list(lst)
except EOFError:
    pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

运行

六、部分逆置

题目

输入n个整数，把第i个到第j个之间的全部元素进行逆置，并输出逆置后的n个数。

思路

代码

def print_list(lst):
    for i in range(len(lst)):
        if i != len(lst) - 1:
            print(lst[i], end=' ')
        else:
            print(lst[i])


t = int(input())
for i in range(t):
    n, i, j, *lst = map(int, input().split())
    lst[i-1:j] = reversed(lst[i-1:j])  # reversed 函数返回一个反转的迭代器。
    print_list(lst)
1
2
3
4
5
6
7
8
9
10
11
12
13

运行

七、n马n担问题

题目

有n匹马，驮n担货，大马驮3担，中马驮2担，两匹小马驮1担，问有大、中、小马各多少匹? （某种马的数量可以为0）

思路
代码

try:
    while True:
        n = int(input())
        for i in range(n+1):  # 为减少时间复杂度，采用双层循环
            for j in range(n+1):
                if i*3 + j*2 + (n-i-j)/2 == n:
                    print(i, j, n-i-j)
except EOFError:
    pass
1
2
3
4
5
6
7
8
9

运行

八、Fibonacci分数序列

题目

求Fibonacci分数序列的前n项之和。Fibonacci分数序列的首项为2/1，
后面依次是：3/2，5/3，8/5，13/8，21/13……

思路
代码

try:
    while True:
        n = int(input())
        count = 0
        a = 2
        b = 1
        result = 0
        while count < n:
            result += a/b
            t = a
            a = a+b
            b = t
            count += 1
        print('%.6f' % result)
except EOFError:
    pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行

九、最小回文数

题目

若一个数正向看和反向看等价，则称做回文数。例如：6，2552，12321均是回文数。
给出一个正整数n，求比n大的最小的回文数。（n和运算结果均不会超出int类型范围）

思路
代码

def symmetric(n):
    my_str = str(n)
    if my_str == my_str[::-1]:
        return True
    else:
        return False


t = int(input())
for i in range(t):
    n = input()
    end = int(n+n)  # 肯定不会超过这个范围，相当于字符串拼接。这个也肯定是回文字符串
    n = int(n)
    for i in range(n+1, end+1):
        if symmetric(i):
            print(i)
            break


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行

十、猴子吃桃

题目

猴子第一天摘下若干个桃子，当即吃了2/3，还不过瘾，又多吃了一个，第二天早上又将剩下的桃子吃掉2/3，又多吃了一个。以后每天早上都吃了前一天剩下的2/3再多一个。到第n天早上想再吃时，发现只剩下k个桃子了。求第一天共摘了多少桃子。

思路
设第一天有x个 ，第一天吃了2/3x+1,剩余x-2/3x -1 = 1/3x-1
第二天有y个，第二天吃了2/3y1,剩余1/3y-1
可以类推出来前一天的数量是（剩余的+1）*3

代码

t = int(input())
for i in range(t):
    n, k = map(int, input().split())
    sum = k
    for j in range(1, n):
        sum = (sum+1)*3
    print(sum)

1
2
3
4
5
6
7
8

运行