Python 初始学习 （实验五）

每天准时更新习题及答案，欢迎关注留言讨论更好的方法

1.【描述】
如果四边形四条边的长度分别为a、b、c、d，一对对角之和为2α，则其面积为：


定义函数：def compute_area(a, b, c, d, alpha)，计算任意四边形的面积。
编写一个main函数，设有一个四边形，其四条边边长分别为 3、4、5、5，一对对角之和为145°，计算它的面积。结果保留2位小数。
【输入】
没有输入。
【输出】
输出对应的四边形面积，结果保留2位小数。

from math import cos
def compute_area(a, b, c, d, alpha):
    p = (a + b + c + d) * 0.5
    area = ((p - a) * ( p - b) * (p - c) * (p - d) - a * b * c * d * cos(alpha) * cos(alpha)) ** 0.5
    return area;

def main():
    PI = 3.14159
    a = 3
    b = 4
    c = d = 5
    alpha = 145 * PI / 360
    print("%.2f" % (compute_area(a, b, c, d, alpha)))

main()

2.【描述】
求一个整数的逆序数。定义函数：def reverse(n)，该函数返回一个整数的逆序数。
当整数含有结尾的0时，输出不应带有前导的0。比如输入100，输出应该是1。
编写一个main函数，输入一个整数，调用reverse函数，显示该整数的逆序数。
【输入】
一行中给出一个整数。
【输出】
一行中输出该整数的逆序数。
【输入示例】

-123

【输出示例】

-321

def reverse(n):
    sign = 1
    result = 0
    if n < 0:
        n = -n
        sign = -1
    while n != 0:
        remainder = n % 10
        result = result * 10 + remainder
        n //= 10
    return sign * result

def main():
    value = int(input())
    print(reverse(value))

main()

3.【描述】
编写程序，计算如下序列的值。结果保留4位小数。

定义函数：def m(i)，返回序列的值。
编写一个main函数，调用m函数，并输出序列的值。
【输入】
在一行中给出一个正整数，表示序列的项数。
【输出】
在一行中输出序列的值，结果保留4位小数。
【输入示例】

901

【输出示例】

3.1427

def m(n):
    total = 0
    flag = 1
    for i in range(1, n + 1):
        item = 1 / (2 * i - 1)
        total += flag * item
        flag = -flag
    return total

def main():
    i = int(input())
    print("%.4f" % (4 * m(i)))

main()

4.【描述】
定义total函数，返回若干个整数的和，体会函数默认参数的使用。
 【输入】
没有输入。
【输出】

100
106
16
36

【提示】
根据total函数被调用时实参的使用和结果的输出，推测total函数的定义。

def total(num1 = 0, num2 = 100, num3 = 0):
    return num1 + num2 + num3

def main():
    print(total())
    print(total(6))
    print(total(6, 10))
    print(total(6, 10, 20))

main()

5.【描述】
编写程序，定义和调用函数：def count_digit(number, digit)，number是整数，digit为[1, 9]区间内的整数，返回number中digit出现的次数。
【输入】
一行中输入两个整数，以空格间隔。
【输出】
见【输出示例】
【输入示例】

-21252 2

【输出示例】

Number of digit 2 in -21252: 3

def count_digit(number, digit):
    t = abs(number)
    cnt = 0;
    while t > 0:
        r = t % 10
        if r == digit:
            cnt += 1
        t //= 10
    return cnt

def main():
    n, d = map(int, input().split())
    c = count_digit(n, d)
    print("Number of digit {0} in {1}: {2}".format(d, n, c))

main()

6.【描述】
输入一个整数，判断它是否是回文整数。如果一个整数的逆序数和原数一样，这个整数就称为回文整数
定义函数：def is_palindrome(n)，如果n是回文数，返回True，否则返回False。
编写一个main函数，输入一个整数，调用is_palindrome函数，判断该整数是否为回文整数。如果该整数是回文数，输出True，否则输出False。
【输入】
一行中给出一个整数。
【输出】
如果该整数是回文数，输出True，否则输出False。
【输入示例】

616

【输出示例】

True

def is_palindrome(n):
    result = 0
    t = n
    while t != 0:
        remainder = t % 10
        result = result * 10 + remainder
        t //= 10
    return n == result

def main():
    value = int(input())
    print(is_palindrome(value))

main()

7.【描述】
编写程序，输出前n（n≤100）个回文素数，每行显示5个，并适当对齐。回文素数是这样一种素数：本身为素数且也是回文数。例如，131是素数，也是回文数。
定义函数：def is_prime(n)，判断n是否是素数，如果是素数，返回True，否则返回False。
定义函数：def is_palindrome(n)，判断n是否是回文数，如果n是回文数，返回True，否则返回False。
编写一个main函数，输入一个正整数n，调用is_prime和is_palindrome函数，输出前n个回文素数。
【输入】
一行中给出一个正整数n。
【输出】
输出前n个回文素数，每行显示5个，每个宽度为6。
【输入示例】

10

【输出示例】

     2     3     5     7    11
   101   131   151   181   191

【提示】
对于整数i，如果is_prime(i)与is_palindrome(i)的返回值都是True，i即为回文素数。

def is_prime(n):
    flag = True
    for divisor in range(2, n // 2 + 1):
        if n % divisor == 0:
            flag = False
            break
    return flag

def is_palindrome(n):
    result = 0
    if n < 0:
        n = -n
    t = n
    while t != 0:
        remainder = t % 10
        result = result * 10 + remainder
        t //= 10
    return n == result

def main():
    n = int(input())
    count = 0
    i = 2
    while count < n:
        if is_prime(i) and is_palindrome(i):
            print(format(i, "6d"), end = '')
            count += 1
            if count % 5 == 0:
                  print()
        i += 1

main()

8.【描述】
无暇素数emirp（英文素数prime的逆序）是这样一种素数：本身为素数，且其逆序数也是素数。例如，17是素数，其逆序数71也是，因此17和71是emirp。
定义函数：def is_prime(n)，判断n是否是素数，如果是素数，函数返回True，否则返回False。
定义函数：def reverse(n)，求n的逆序数，函数返回n的逆序数，如n为17，函数reverse(n)返回71。
编写一个main函数，调用is_prime和reverse函数，输出前n个emirp，每行显示5个，并适当对齐。
【输入】
输入一个正整数n。
【输出】
输出前n个emirp，每行显示5个，每个宽度为5。
【输入示例】

10

【输出示例】

    2    3    5    7   11
   13   17   31   37   71

【提示】
对于整数i，如果is_prime(i)与is_prime(reverse(i))的返回值都是True，i即为无暇素数。

def is_prime(n):
    flag = True
    for divisor in range(2, n // 2 + 1):
        if n % divisor == 0:
            flag = False
            break
    return flag

def reverse(n):
    sign = 1
    result = 0
    if n < 0:
        n = -n
        sign = -1
    while n != 0:
        remainder = n % 10
        result = result * 10 + remainder
        n //= 10
    return sign * result

def main():
    n = int(input())
    count = 0
    i = 2
    while count < n:
        if is_prime(i) and is_prime(reverse(i)):
            print(format(i, "5d"), end = '')
            count += 1
            if count % 5 == 0:
                  print()
        i += 1

main()

9.【描述】
定义函数：def square_root(value)，返回value的平方根。
编写一个main函数，读入一个数，调用square_root函数，输出该数的平方根。
注意：不能使用数学函数sqrt和幂运算符**。
可以通过对下面公式的反复计算近似地得到平方根：

当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值。nextGuess最初的猜测值可以是任意一个值（例如1.0）。这个值就是lastGuess的初始值。如果nextGuess和lastGuess的差小于一个很小的数（例如0.000001），就可以认为nextGuess是value平方根的近似值；否则，nextGuess就赋值给lastGuess，迭代过程继续进行。
【输入】
一行中给出一个数。
【输出】
输出该数的平方根，结果保留6位小数。。
【输入示例】

2

【输出示例】

1.414214

import math

def square_root(value):
    next_guess = 1.0
    last_guess = 0.0
    while math.fabs(next_guess - last_guess) >= 0.000001:
        last_guess = next_guess
        next_guess = (last_guess + (value / last_guess)) * 0.5
    return next_guess

def main():
    value = float(input())
    print(format(square_root(value), ".6f"))

main()

10.【描述】
定义函数：def f(x, n)，用递归求下列数学式子的值，其中x为浮点数，n为整数。

编写一个main函数，读入x和n，输出数学式子的值，结果保留2位小数。
【输入】
一行中给出两个数，其间以空格分隔。
【输出】
输出数学式子的值，结果保留2位小数。
【输入示例】

2 3

【输出示例】

6.00

def f(x, n):
    if n == 1:
        return x
    else:
        return x * (1 - f(x, n - 1))

def main():
    line = input().split()
    x = float(line[0])
    n = int(line[1])
    print("%.2f" % (f(x, n)))

main()