矿大python学习通实验五（1和2）(已修正欢迎批评指正)

"""
实验5-1：判断奇偶。编写函数，参数为整数，如果参数为奇数，返回True，否则返回False。
在主程序中用户输入一个整数，调用函数判断奇偶并输出结果。
【运行示例1】
3
3是奇数
【运行示例2】
6
6是偶数
"""
def odd(number):
    if number % 2 == 1:
        return True
    else:
        return False
# 主程序
if __name__ == "__main__":
    # 从用户那里获取一个整数输入
    num = int(input())
    # 调用函数判断奇偶，并输出结果
    if odd(num):
        print("{}是奇数".format(num))
    else:
        print("{}是偶数".format(num))

"""
实验5-2：成绩评定。输入学生的成绩，若成绩大于等于0且小于60，则输出“该同学成绩不合格，
需继续努力！”；若成绩大于等于60且小于等于100，则输出“该同学成绩合格啦！”；若输入的成绩大于100或小于0，
则输出“输入的成绩错误！”。 输出提示：输出的所有标点都是中文标点
【要求】定义一个函数passed()来判断给定的一个分数（百分制）是否为合格的成绩，
在主程序中调用passed()函数来判断输入的成绩是否合格。
【运行示例1】
60
该同学成绩合格啦！
【运行示例2】
50
该同学成绩不合格，需继续努力！
【运行示例3】
200
输入的成绩错误
"""
def passed(score):
    # 如果成绩在0到60之间，返回不合格的信息
    if 0 <= score < 60:
        return "该同学成绩不合格，需继续努力！"
    # 如果成绩在60到100之间，返回合格的信息
    elif 60 <= score <= 100:
        return "该同学成绩合格啦！"
    # 如果成绩不在这个范围内，返回错误信息
    else:
        return "输入的成绩错误！"
if __name__ == "__main__":
    score = float(input())
    result = passed(score)
    print(result)

"""
实验5-3：字符串统计。编写一个函数string_num(ch)，参数ch为字符串，统计此字符串中字母、数字、空格和其他字符的个数。
在主程序中输入字符串，调用函数，输出统计的结果。
【运行示例】
a b c123==
统计结果：字母有3个，数字有3个，空格有2个，其他字符有2个。（输出的标点符号为中文输入法，各项数据间没有标点符号）
"""
def string_num(s):
    letters = digits = spaces = others = 0
    for char in s:
        # 判断字符类型并增加相应的计数
        if char.isalpha():
            letters += 1
        elif char.isdigit():
            digits += 1
        elif char.isspace():
            spaces += 1
        else:
            others += 1
    return letters, digits, spaces, others
if __name__ == "__main__":
    inputStr = input()
    letters, digits, spaces, others = string_num(inputStr)
    print("统计结果：字母有{}个，数字有{}个，空格有{}个，其他字符有{}个。".format(letters,digits,spaces,others))

"""
实验5-4：判断互质。编写函数coprime()判断两个自然数是否互质。
输入两个自然数，调用coprime()函数判断它们是否互质并输出结果。
提示：两个正整数互质，就是这两个数的最大公约数为1。
【运行示例1】
9,13
9和13互质
【运行示例2】
9,30
9和30不互质
"""
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a
def coprime(x, y):
    greatest = gcd(x, y)
    # 如果最大公约数为1，则x和y互质
    return greatest == 1
if __name__ == "__main__":
    x,y = eval(input())
    # 调用函数判断它们是否互质，并输出结果
    if coprime(x, y):
        print("{}和{}互质".format(x,y))
    else:
        print("{}和{}不互质".format(x,y))

"""
实验5-5：斐波那契数列。编写函数fib(n)，求斐波那契数列的前n个数据构成的列表。主程序中输入数列的项数，调用fib()函数，输出调用结果。
斐波那契数列的定义请参见3.7.2节的例3-31。
要求：fib()函数返回值是斐波那契数列前n个数据的列表。
【运行示例】
3
[1, 1, 2]
"""
def fib(n):
    sequence = [1, 1]
    if n == 1:
        return [sequence[0]]
    if n == 2:
        return sequence
    # 否则，计算接下来的斐波那契数,并添加到列表中
    for i in range(2, n):
        next_number = sequence[-1] + sequence[-2]
        sequence.append(next_number)
    return sequence
if __name__ == "__main__":
    n = int(input())
    fib_sequence = fib(n)
    print(fib_sequence)
"""
1. (程序题)
实验5-6：找亲密数对。若正整数A的所有因子（包括1但不包括自身，下同）之和为B，而B的因子之和为A，
则称A和B（A≠B）为一对亲密数对。
例如，220的因子之和为1+2+4+5+10+11+20+22+44+55+110=284，而284的因子之和为1+2+4+71+142=220，
因此220与284为一对亲密数对。输入一个整数x，求x以内（不包括x）的所有亲密数对。
要求：
① 编写一个函数FacSum(n)，函数的返回值是给定正整数n的所有因子（包括1但不包括自身）之和。
② 在主程序中输入x，调用已定义的函数FacSum()，
寻找并输出x（包括x)以内的所有亲密数对。在输出每对亲密数对时，要求小的数在前，大的数在后，并去掉重复的数对。
【输出提示】输出的数据中没有空格，所有标点都为英文标点。
【运行示例1】
100
输出为空
【运行示例2】
3000
亲密数对: A=220, B=284
亲密数对: A=1184, B=1210
亲密数对: A=2620, B=2924
"""
def FacSum(n):
    factors = 0
    for i in range(1,n):
        if n % i == 0:
            factors += i
    return factors
x = int(input())
for A in range(2,x):
    B = FacSum(A)
    if B > A and FacSum(B) == A:
        print("亲密数对:A={},B={}".format(A,B))

"""
2. (程序题)
实验5-7：判断回文数。编写一个函数huiwen()，参数是正整数，
判断参数是否是回文数，若是则返回True，否则返回False。
主程序中输入一个正整数M，调用函数huiwen()进行判断，并输出“M是回文数”或“M不是回文数”。
所谓回文数，是指顺读和倒读数字相同。当只有一位数时，也认为是回文数。
【运行示例1】
12321
12321是回文数
【运行示例2】
123
123不是回文数
"""
def huiwen(ss):
    if ss == ss[::-1]:
        return True
    else:
        return False
x = input()
if huiwen(x):
    print("{}是回文数".format(int(x)))
else:
    print("{}不是回文数".format(int(x)))

"""
3. (程序题)
实验5-8：哥德巴赫猜想。编写一个函数prime()判断某个自然数是否为素数。
主程序中调用该函数验证“哥德巴赫猜想”：任何不小于6的偶数均可表示为两个素数之和。
编程输入两个自然数a（a不小于6）和b，将a~b（包括a和b）之间的偶数表示为两个素数之和的形式。
例如：14=3+11或14=7+7或14=11+3，但只需输出一种14=3+11(第一个加数最小的那组)即可。输出时每行显示1个式子。
【输出提示】输出的数据中没有空格，所有标点为英文标点。
【运行示例1】
6,10
6=3+3
8=3+5
10=3+7
【运行示例2】
8,10
8=3+5
10=3+7
"""
def prime(n):
    if n == 1:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

if __name__ == "__main__":
    a, b = map(int, input().split(','))
    if a % 2 != 0:
        a += 1
    for even in range(a, b + 1, 2):
        first = None
        for num in range(2, even // 2 + 1):
            if prime(num) and prime(even - num):
                first = num
                break
        second = even - first
        print("{}={}+{}".format(even, first, second))

"""
4. (程序题)
实验5-9：回文素数。回文素数是指既是素数又是回文数，例如2、3、5、7、11、101等就是回文素数。
编写程序，输入一个自然数x，输出前x个回文素数，每行输出10个，用逗号分隔。
要求：判断回文数和判断素数都用函数实现。
【运行示例1】
10
2,3,5,7,11,101,131,151,181,191,
【运行示例2】
15
2,3,5,7,11,101,131,151,181,191,
313,353,373,383,727,
"""
def prime(n):
    if n == 1:
        return False
    for i in range(2,int(n**0.5)+1):
        if n % i == 0:
            return False
    return True
def huiwen(num):
    return str(num) == str(num)[::-1]
# 一定注意本题问的是前x个回文素数，而非x及之前的数里的回文素数
x = int(input())
primes = []
count = 0  # 记录找到的个数
num = 2
while count < x:
        if prime(num) and huiwen(num):
            primes.append(num)
            count += 1
        num += 1
for i in range(0, len(primes), 10):
    for j in range(10):  # 每行输出10个数
        if i + j < len(primes):
            print(str(primes[i + j]), end=',')
    print()

"""
5. (程序题)
实验5-10：矩阵判断和求和。编写程序判断4×4（4阶）矩阵是否对称，并求矩阵主对角线元素之和。
要求：
① 定义函数isSymmetrical(lst)，函数功能为判断4阶矩阵lst是否对称。如果是对称的则返回True，否则返回False。
② 定义函数matrix_sum(lst)，返回矩阵主对角线元素之和。
③主函数中，输入16个一位正整数，分别赋给4阶矩阵中的各元素。
调用isSymmetrical()函数判断矩阵是否为对称矩阵，调用matric_sum()函数求矩阵主对角线元素和，并输出相应的结果。
【编程提示】（1）矩阵用二维数组表示。
比如运行示例中的矩阵可以表示为lista=[[1,2,3,4],[2,3,4,5],[3,4,5,6],[4,5,6,7]]
(2)主对角线指两个索引号相同的元素，即lista[0,0],lista[1,1],lista[2,2],lista[3,3]
(3)矩阵对称指的是沿着主对角线对折，相同位置的元素相同
【运行示例】
1,2,3,4
2,3,4,5
3,4,5,6
4,5,6,7
矩阵是对称矩阵
矩阵对角线元素和是: 16
"""
def isSymmetrical(matrix):
    for i in range(len(matrix)):
        for j in range(len(matrix)):
            if matrix[i][j] != matrix[j][i]:
                return False
    return True
def matrix_sum(matrix):
    # 计算矩阵主对角线元素之和
    return sum(matrix[i][i] for i in range(len(matrix)))
# 输入16个一位正整数，创建4阶矩阵
matrix = [list(map(int, input().split(','))) for _ in range(4)]
# 判断矩阵是否对称
if isSymmetrical(matrix):
    print("矩阵是对称矩阵")
else:
    print("矩阵不是对称矩阵")
# 计算并输出矩阵对角线元素和
ssum = matrix_sum(matrix)
print(f"矩阵对角线元素和是: {ssum}")