研一Python基础课程第三周课后习题分享（下）（含源代码）

曾经终败给现在 2023-09-27 12:16 19阅读 0赞

![在这里插入图片描述][5348c915ab804f2d8abb6f528d3c69c8.png]

这里分享剩余的八道题，比起前八道，后面八道题相对容易很多！

### 一、题目分享 ###

**第九题：计算圆周率——无穷级数法**

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

π是个超越数，圆周率的超越性否定了化圆为方这种尺规作图精确求解问题的可能性。有趣的是，π可以用无穷级数表示：  
![在这里插入图片描述][9a1e5dc64328444eb68cedb1f6fffb26.png]  
左边的展式是一个无穷级数，被称为莱布尼茨级数（Leibniz），这个级数收敛到π/4，它通常也被称为格雷戈里-莱布尼茨级数，用以纪念莱布尼茨同时代的天文学家兼数学家詹姆斯·格雷戈里。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

编程用这个公式计算π值，输入一个小数作为阈值，当最后一项的绝对值小于给定阈值时停止计算并输出得到的π值。

def leibniz_of_pi(error):
        """接收用户输入的浮点数阈值为参数，返回圆周率值"""
        #=======================================================
        # 补充你的代码
        #=======================================================
    
    
    if __name__ == '__main__':
        threshold = float(input())
        print("{:.8f}".format( leibniz_of_pi(threshold)  ) ) #保留小数点后八位

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

一个正浮点数threshold，限定级数法求解pi值时，迭代累加只加绝对值大于threshold的项。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

输出为一个浮点数，是程序使用级数法求解的pi值，要求保留小数点后八位。

![在这里插入图片描述][20b93fceec284f1aa97cdefed79c611b.png]

**第十题：计算奇数和**

描述

输入一个数，计算1至该数所有奇数的和。

![在这里插入图片描述][ac4417eaa1ae43a0a97ffc2bf3b081d5.png]

**第十一题：麦粒问题**

描述  
麦粒问题。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

在棋盘的第1个小格放1粒麦子，第2个小格放2粒，第三个小格放4粒，第4个小格放8粒，以此类推，直到把64格棋盘放满就行了，那么第n个格子的麦粒有多少颗？

![在这里插入图片描述][f11fb42fdd45447e9acee9215919f91e.png]

**第十二题：寻找水仙花数**

描述

寻找水仙花数。水仙花数是指一个三位数，它每个数位上数的3次幂之和等于它本身。例如：153是水仙花数，因为1³+5³+3³=153。输出所有的水仙花数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬**第十三题：斐波那契数列**

描述

求斐波那契数列中第n个数的值，n是正整数。  
(斐波那契数列是这样的一个数列：1、1、2、3、5、8、13、21、34、… ，第一个数和第二个数是1，从第三个数开始每个元素是前两个元素相加的和。)  
‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭![在这里插入图片描述][85f253d7c4b041f5af3abe781793d931.png]

**第十四题：九九乘法表**

描述  
输出九九乘法表

![在这里插入图片描述][bb65c372696041f1bef3460e297cc1af.png]  
注意：乘法符号可以直接复制 ×

知识点  
print()函数参数：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

sep:用来间隔多个对象，默认值是一个空格。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

end:用来设定以什么结尾。默认值是换行符 ，可以换成其他字符串。

print("你好")
    print("朝晖中学") 
    #不设置end参数，默认会增加一个换行符，输出结果为：
    你好
    朝晖中学
    
    print("你好",end=" ")
    print("朝晖中学") 
    #设置end参数为一个空格，则输出你好后，不会再输出默认的换行符，而是一个空格，则输出结果为：
    你好 朝晖中学

在本题中，输出1×2=2后，默认会输出换行符换到下行，可以使用end参数，输出一个空格，继续输出2×2=4。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

当一行输出结束后，可以单独增加一句print()，不输出任何内容，就会只输出一个默认的换行符，换到下行。

**第十五题：登录程序2**

描述  
登录程序，先判断输入账号是否为“admin”，再判断输入密码是否为“123456”，若账号和密码输入不正确，则要求用户一直输入，直到输入的账号和密码都正确，退出循环并输出“登录成功”。

![在这里插入图片描述][335b1d8f8117439e9433200c87a92c28.png]

**第十六题：猜数游戏2**

描述  
编程实现“猜数游戏”。在给定某数后，让用户进行猜测并输入输，计算机给出相应提示，如偏大、偏小或正确。若所猜测的数正确，则输出猜测次数，否则继续猜数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

在这个过程中，不能确定比较的次数，因此需用while循环语句来实现。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

while循环的判断条件为True，表示循环条件永远满足，只能靠循环体中的break语句跳出循环。

![在这里插入图片描述][9870d73a5f4d412689ca0b67e156d12c.png]

### 二、源代码 ###

**带上篇的代码！**

def problem_1():
        """
        “物不知数”出自《孙子算经》。题目为:
        意思是说有一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；7个7个数也会多出2个。
        现假设物品总数不超过n (n<=1000)，请编程计算满足条件的物品个数并输出。
        """
        n = eval(input())
        flag = 0
        for i in range(n + 1):
            if (i % 3 == 2 and i % 5 == 3 and i % 7 == 2):
                print(i)
                flag += 1
            else:
                flag += 0
        if flag == 0:
            print('No solution!')
    
    
    def problem_2():
        """
        有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打一尺，小老鼠也是一尺。
        大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。问它们几天可以相逢，相逢时各打了多少。
        """
        wall = int(input())
        v_1, v_2, day, t = 1, 1, 0, 1
        s_1, s_2 = 0, 0
        while wall > 0:
            if wall - (s_1 + s_2) < 0:
                t = wall / (v_1 + v_2)
            wall -=  v_1 + v_2
            s_1 += t * v_1
            s_2 += t * v_2
            v_1 *= 2
            v_2 *= 0.5
            day = day + 1
        print(day)
        print(round(s_2, 1), round(s_1, 1))
    
    
    def problem_3():
        """
        诗仙李白，一生好酒。
        一天，他提着酒壶，从家里出来，酒壶中有酒若干。
        他边走边唱：无事街上走，提壶去买酒，遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
        """
        n = 0
        for i in range(5):
            n += 1
            n /= 2
        print(n)
    
    
    def problem_4():
        """
        有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有765盏琉璃灯，计算并输出每层各有多少盏琉璃灯。
        """
        sum = 0
        for i in range(8):
            sum += 2**i
        x = int(765 / sum)
        for i in range(8):
            print(2**i *x)
    
    
    def problem_5():
        # 应纳税额 = (工资薪金所得 - 五险一金 - 个税免征额) × 适用税率 - 速算扣除数
        # 实发工资 =  应发工资  -  五险一金   -  应缴税款
        salary = float(input()) # 薪资
        five_one_insurance_fund = float(input()) # 五险一金
        exemption = float(input()) # 个税免征额
        money = [3000, 12000, 25000, 35000, 55000, 80000]
        rate = [0.03, 0.1, 0.2, 0.25, 0.3, 0.35, 0.45]
        minus = [0, 210, 1410, 2660, 4410, 7160, 15160]
        if salary <= 0:
            print('error')
        elif salary <= exemption:
            output_1 = 0
            output_2 = salary - five_one_insurance_fund - output_1
            print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
        else:
            if salary - five_one_insurance_fund - exemption <= 0:
                output_1 = 0
                output_2 = salary - five_one_insurance_fund - output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary <= 3000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.03 - 0
                output_2 = salary - five_one_insurance_fund -output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary > 3000 and salary <= 12000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.1 - 210
                output_2 = salary - five_one_insurance_fund -output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary > 12000 and salary <= 25000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.2 - 1410
                output_2 = salary - five_one_insurance_fund -output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary > 25000 and salary < 35000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.25 - 2660
                output_2 = salary - five_one_insurance_fund - output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary > 35000 and salary <= 55000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.3 - 4410
                output_2 = salary - five_one_insurance_fund - output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary > 55000 and salary <= 80000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.35 - 7160
                output_2 = salary - five_one_insurance_fund - output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
            elif salary > 80000:
                output_1 = (salary - five_one_insurance_fund - exemption)*0.45 - 15160
                output_2 = salary - five_one_insurance_fund - output_1
                print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(output_1, output_2))
    
    
    def problem_5_1():
        salary = float(input())  # 薪资
        five_one_insurance_fund = float(input())  # 五险一金
        exemption = float(input())  # 个税免征额
        Num = salary-five_one_insurance_fund-exemption
        Taxes = 0
        if salary <= 0 or five_one_insurance_fund <= 0 or exemption <= 0:
            print("error")
        else:
            if Num > 0 and Num <= 3000:
                Taxes = Num * 0.03
            elif Num > 3000 and Num <= 12000:
                Taxes = Num * 0.10 - 210
            elif Num > 12000 and Num <= 25000:
                Taxes = Num * 0.20 - 1410
            elif Num > 25000 and Num <= 35000:
                Taxes = Num * 0.25 - 2660
            elif Num > 35000 and Num <= 55000:
                Taxes = Num * 0.30 - 4410
            elif Num > 55000 and Num <= 80000:
                Taxes = Num * 0.35 - 7160
            elif Num > 80000:
                Taxes = Num * 0.45 - 15160
            Salary = salary - five_one_insurance_fund - Taxes
            print('应缴税款{:.2f}元，实发工资{:.2f}元。'.format(Taxes, Salary))
    
    
    def problem_6():
        total_cost = float(input())         
        annual_salary = float(input())        
        portion_saved = float(input()) / 100
        current_savings = 0
        portion_down_payment = 0.30
        down_payment = portion_down_payment * total_cost
        monthly_deposit = (annual_salary / 12) * portion_saved
        number = down_payment % monthly_deposit
        if number == 0:
            number_of_months = int(down_payment / monthly_deposit)
        else:
            number_of_months = int((down_payment // monthly_deposit) + 1)
        print('首付'+' '+ '%.2f' % (down_payment) +' ' + '元')
        print('月存款'+' ' + '%.2f' % (monthly_deposit) + ' ' + '元')
        print(f'需要{
          number_of_months}个月可以存够首付')
    
    
    def problem_7():
        total_cost = float(input()) # total_cost为当前房价
        annual_salary = float(input()) # 年薪
        portion_saved = float(input()) / 100 # 月存款比例，输入30转为0.30（即30%）
        semi_annual_raise = float(input()) / 100 # 输入每半年加薪比例，输入7转化为0.07（即7%）
        portion_down_payment = 0.3 # 首付比例，浮点数
        down_payment = portion_down_payment * total_cost # 首付
        print('首付',down_payment)
        current_savings = 0 # 存款金额，从0开始
        number_of_months = 0
        monthly_salary = annual_salary / 12 #月工资
        monthly_deposit = monthly_salary * portion_saved
        def year_off_money(number_of_months, monthly_salary, semi_annual_raise, monthly_deposit ):
            enough = True
            current_saving = 0
            while enough:
                number_of_months = number_of_months + 1
                current_saving += monthly_deposit
                if current_saving >= down_payment:
                    print(f'需要{
          number_of_months}个月可以存够首付')
                    enough = False
                    return
                if number_of_months % 12 == 0:
                    print("第{}个月月末有{:,.0f}元存款".format(number_of_months, current_saving))  # 每12个月输出一次存款，保留0位小数，使用千分符
                if number_of_months % 6 == 0:
                    monthly_deposit = monthly_deposit * (1 + semi_annual_raise)  # 六月之期已到，加薪
        year_off_money(number_of_months, monthly_salary, semi_annual_raise, monthly_deposit)
    
    
    def problem_8():
        total_cost = float(input()) # total_cost为当前房价
        annual_salary = float(input())  # 年薪
        portion_saved = float(input()) / 100  # 月存款比例，输入30转为30%
        semi_annual_raise = float(input()) /100  # 输入每半年加薪比例，输入7转化为7%
        portion_down_payment = 0.3 # 首付比例，浮点数
        down_payment = portion_down_payment * total_cost # 首付款
        print('首付',down_payment)
        number_of_months = 0
        monthly_salary = annual_salary / 12
        monthly_deposit = monthly_salary * portion_saved # 每个月存的钱
        def year_off_money(number_of_months, monthly_salary, semi_annual_raise, monthly_deposit):
            enough = True
            current_savings = 0
            while enough:
                number_of_months += 1
                current_savings *= (1 + 0.0225 / 12)
                current_savings += monthly_deposit
                if current_savings >= down_payment:
                    print(f'需要{
          number_of_months}个月可以存够首付')
                    enough = False
                    return
                if number_of_months % 12 == 0:
                    print("第{}个月月末有{:,.0f}元存款".format(number_of_months, current_savings))
                if number_of_months % 6 == 0:
                    monthly_deposit = monthly_deposit * (1 + semi_annual_raise)
            
        year_off_money(number_of_months, monthly_salary, semi_annual_raise, monthly_deposit)
    
    
    def problem_8_1():
        total_cost = float(input()) # total_cost为当前房价
        annual_salary = float(input())  # 年薪
        portion_saved = float(input()) / 100  # 月存款比例，输入30转为30%
        semi_annual_raise = float(input()) /100  # 输入每半年加薪比例，输入7转化为7%
        portion_down_payment = 0.3 # 首付比例，浮点数
        down_payment = portion_down_payment * total_cost # 首付款
        print('首付',down_payment)
        number_of_months = 0
        monthly_salary = annual_salary / 12
        monthly_deposit = monthly_salary * portion_saved # 每个月存的钱
        current_savings = 0
        enough = True
        while enough:
            number_of_months += 1
            current_savings *= (1 + 0.0225 / 12)
            current_savings += monthly_deposit
            if current_savings >= down_payment:
                a = number_of_months
                enough = False
            if number_of_months % 12 == 0:
                print("第{}个月月末有{:,.0f}元存款".format(number_of_months, current_savings))
            if number_of_months % 6 == 0:
                monthly_deposit = monthly_deposit * (1 + semi_annual_raise)
        print(f'需要{
          number_of_months}个月可以存够首付') 
    
    
    def problem_9():
        def leibniz_of_pi(error):
            """接收用户输入的浮点数阈值为参数，返回圆周率值"""
            #=======================================================
            # 补充你的代码
            #=======================================================
            n = 1
            a = 1
            p = 0
            while True:
                b = (-1) ** (n - 1)
                if 1 / a <= error:
                    break
                else:
                    p += (1 / a) * b
                    a += 2
                    n += 1
                    continue
            return 4 * p
    
    
        if __name__ == '__main__':
            import time
            threshold = float(input())
            print("{:.8f}".format( leibniz_of_pi(threshold)  ) )
    
    
    def problem_10():
        """
        输入一个数,计算1至该数所有奇数的和。
        """
        a = eval(input())
        sum = 0
        for i in range(1, a + 1):
            if i % 2 == 0:
                continue
            else:
                sum += i
        print(sum)
    
    
    def problem_11():
        """
        麦粒问题。
        在棋盘的第1个小格放1粒麦子，第2个小格放2粒，第三个小格放4粒，第4个小格放8粒，以此类推，直到把64格棋盘放满就行了.
        那么第n个格子的麦粒有多少颗？
        """
        a = eval(input())
        sum  = 1
        for i in range(1, a + 1):
            sum += 2 ** (i-1)
        print(sum)
    
    
    def problem_12():
        """
        寻找水仙花数。
        水仙花数是指一个三位数，它每个数位上数的3次幂之和等于它本身。例如：153是水仙花数，因为1³+5³+3³=153。输出所有的水仙花数。
        """
        for i in range(100, 1000):
            a = i // 100 # 百位数
            b = (i // 10) % 10
            c = i % 10
            if a **3 + b **3 + c ** 3 == i:
                print(i)
    
    
    def problem_13():
        """
        求斐波那契数列中第n个数的值，n是正整数。
        (斐波那契数列是这样的一个数列：1、1、2、3、5、8、13、21、34、… ，第一个数和第二个数是1，从第三个数开始每个元素是前两个元素相加的和。)
        """
        """
        # 递归会超时
        n = eval(input())
        def f(n):
            if n == 1 or n == 2 :
                return 1
            return f(n-1) + f(n-2)
        print(f(n))
        """
        n = eval(input())
        def f(n):
            a, b = 1, 1
            for i in range(n - 1):
                a, b = b, a + b
            return a
        print(f(n))
    
    
    def problem_14():
        """
        输出九九乘法表
        """
        for i in range(1, 10): 
            for j in range(1, 10): 
                if j <= i: 
                    print('%d×%d=%d'%(j, i ,i*j), end = ' ')
            print(end='\n')
    
    
    def problem_15():
        """
        登录程序，先判断输入账号是否为“admin”，再判断输入密码是否为“123456”.
        若账号和密码输入不正确，则要求用户一直输入，直到输入的账号和密码都正确，退出循环并输出“登录成功”。
        """
        account = 'admin'
        pass_word = '123456'
        enough = True
        while enough:
            first_input = input()
            if first_input != account:
                print('输入的账号是：',first_input, '错误！') 
            else:
                print('输入的账号是：',first_input, '正确！')
                enough = False
        enough = True
        while enough:
            second_input = input()
            if second_input != pass_word:
                print('输入的密码是：',second_input,'错误！')
            else:
                print('输入的密码是：',second_input, '正确！')
                enough = False
        print('登录成功!')
    
    
    def problem_16():
        """
        编程实现“猜数游戏”。在给定某数后，让用户进行猜测并输入输，计算机给出相应提示，如偏大、偏小或正确。
        若所猜测的数正确，则输出猜测次数，否则继续猜数。
        """
        num = 66
        enough = True
        counts = 0
        while enough:
            a = eval(input())
            if a < num:
                print('偏小')
                counts += 1
            elif a > num:
                print('偏大')
                counts += 1
            else:
                counts += 1
                print('正确，共猜了',counts,'次')
                enough = False
    
    
    if __name__ == '__main__':
        problem_16()

[5348c915ab804f2d8abb6f528d3c69c8.png]: https://img-blog.csdnimg.cn/5348c915ab804f2d8abb6f528d3c69c8.png
[9a1e5dc64328444eb68cedb1f6fffb26.png]: https://img-blog.csdnimg.cn/9a1e5dc64328444eb68cedb1f6fffb26.png
[20b93fceec284f1aa97cdefed79c611b.png]: https://img-blog.csdnimg.cn/20b93fceec284f1aa97cdefed79c611b.png
[ac4417eaa1ae43a0a97ffc2bf3b081d5.png]: https://img-blog.csdnimg.cn/ac4417eaa1ae43a0a97ffc2bf3b081d5.png
[f11fb42fdd45447e9acee9215919f91e.png]: https://img-blog.csdnimg.cn/f11fb42fdd45447e9acee9215919f91e.png
[85f253d7c4b041f5af3abe781793d931.png]: https://img-blog.csdnimg.cn/85f253d7c4b041f5af3abe781793d931.png
[bb65c372696041f1bef3460e297cc1af.png]: https://img-blog.csdnimg.cn/bb65c372696041f1bef3460e297cc1af.png
[335b1d8f8117439e9433200c87a92c28.png]: https://img-blog.csdnimg.cn/335b1d8f8117439e9433200c87a92c28.png
[9870d73a5f4d412689ca0b67e156d12c.png]: https://img-blog.csdnimg.cn/9870d73a5f4d412689ca0b67e156d12c.png