代码写的较多，有问题可以私聊我！
第四周作业分享
一、题目前言
本周和第三周的作业一样，重点考察程序结构，有一定的难度！
二、题目分享
1. 问题1
描述
储蓄问题。已知某同学有一些零用钱，他想通过银行储蓄增值。问：存多少年，才能达到预期的数额？
（1）存期以一年为单位，存款以元为单位。
（2） 一年期的存款利率均为3%。
输入本金数和预期数，输出需要的年数。
2. 问题2
描述
输入一批整数，输入0时结束，求出其中的最大值与最小值。
3. 问题3
描述
输入一批整数，输入0时结束，求这批数的平均数，结果保留两位小数。
4. 问题4
描述
求sum=2+22+222+…+22…222（有n个2）之值。 例如：当n=5时，sum=2+22+222+2222+22222
输入n，输出结果sum。
5. 问题5
描述
· 黄蓉给瑛姑所出的题目：今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何？
· 即该数除以3余2，除以5余3，除以7余2，问这个数是多少
6. 问题6
描述
判断一个数是否为“水仙花数”，所谓“水仙花数”是指这样的一类数：其各位数的立方和等于这数本身。例如：371是一个“水仙花数”，371=33+23+1**3。
7. 问题7
计算圆周率——蒙特卡洛法
描述
蒙特卡洛（Monte Carlo）方法是由数学家冯·诺伊曼提出的，诞生于上世纪40年代美国的“曼哈顿计划”。蒙特卡洛是一个地名，位于赌城摩纳哥，象征概率。蒙特卡洛方法的原理是通过大量随机样本，去了解一个系统，进而得到所要计算的值。
用蒙特卡洛方法计算圆周率π的原理如下：一个边长为2r的正方形内部相切一个半径为r的圆，圆的面积是πr2，正方形的面积为4r2，二者面积之比是π/4，因为比值与r大小无关，所以可以假设半径 r的值为1。
在这个正方形内部，随机产生n个点，坐标为（x,y），当随机点较多时，可以认为这些点服从均匀分布的规律。计算每个点与中心点的距离是否大于圆的半径(x2+y2>r2)，以此判断是否落在圆的内部。统计圆内的点数c，c与n的比值乘以4，就是π的值。理论上，n越大，计算的π值越准，但由于随机数不能保证完全均匀分布，所以蒙特卡洛法每次计算结果可能不同。
编程实现用蒙特卡洛方法计算π值，为了自动测评的需要，请先读入一个正整数sd作为随机数种子，并要求使用 x,y = random.uniform(-1,1) , random.uniform(-1,1) 语句来生成随机点的坐标值。
8. 问题8
素数问题
描述
素数或称质数，是指一个大于1的整数，除1和它本身外，不能被其他的正整数所整除。 素数判定方法是： 先用一定的方法枚举正整数n所有可能的真因子，并验证每个枚举的数是否为真因子。若是，则停止枚举，确定n为合数；若枚举完也没发现真因子，可确定n为素数。完成以下函数的定义并按要求完成问题：
定义素数函数is_ prime(n) 将素数的判定代码定义为一个函数，接受用户输入的正整数n，返回n是否是素数，n为素数时返回True，不是素数时返回False。 一个整数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n)，所以对于每个数n，并不需要从2判断到n-1，只需要遍历到sqrt(n)即可。因为若sqrt(n)左侧找不到因数，那么右侧也一定找不到因数,这样可以显著提升算法的效率。
定义一个函数output_prime(n)，接受一个正整数number为参数，在函数中调用问题1中定义的判定素数函数，对不大于number的整数一一判定，在同一行中输出不大于n的全部素数。此函数无返回值，直接输出找到的素数。 调用all_prime(n)函数前，先接收用户输入的一个正整数，作为函数调用时的参数。
3.定义寻找回文素数函数 回文是指数或者字符串具有首尾回环性质，从后向前按位颠倒后与原文一样。首尾回环的数字就是回文数，如：12321；首尾回环的字符串就是回文串，如：‘上海自来水来自海上’。 如果一个整数是素数，同时，其对应的字符串是回文字符串时，便称其为回文素数。 编写一个函数，调用前面定义好的素数判定函数和题目给定的回文判定函数完成回文素数的判定，函数无返回值，直接输出找到的回文素数。 输入一个正整数，输出小于这个数的所有回文素数。
寻找反素数 反素数是指一个将其逆向拼写后也是一个素数的非回文数。例如：17和71都是素数且均不是回文数，所以17和71都是反素数。 输入一个正整数n，按从小到大顺序输出所有反素数。
哥德巴赫猜想 1742年，哥德巴赫给欧拉的信中提出了以下猜想“任意一个大于2的整数都可写成三个质数之和”。常见的猜想陈述为欧拉的版本，即任意一个大于2的偶数都可写成两个素数之和，亦称为“强哥德巴赫猜想”或“关于偶数的哥德巴赫猜想”。 编写函数，接收一个大于2的偶数，输出两个素数，并且两个素数之和等于原来的偶数，如果有多个不同组合，则全部输出。若输入的数不是大于2的偶数，输出’Data error!'
输入输出
问题1 如果输入’素数’，再输入一个正整数n，按从小到大顺序输出不大于n的所有素数。
问题2 如果输入’回文素数’，再输入一个正整数n，按从小到大顺序输出小于n的所有回文素数。
问题3 如果输入’反素数’，再输入一个正整数n，输入一个正整数n，按从小到大顺序输出小于n的所有反素数。
问题4 如果输入’哥德巴赫猜想’，接收一个大于2的偶数，输出两个素数，并且两个素数之和等于原来的偶数，如果有多个不同组合，则全部输出，格式参考下面的示例。若输入的数不是大于2的偶数，输出’Data error!'
如果输入不是以上字符串，输出’输入错误’。
9.问题9
计算圆周率
描述
1.割圆法
国魏晋时期的数学家刘徽于公元263年撰写《九章算术注》，其中就有数学史上著名的“割圆术”。刘徽形容他的“割圆术”说：割之弥细，所失弥少，割之又割，以至于不可割，则与圆合体，而无所失矣。这包含了求极限的思想。通过求圆内接正多边形的周长来近似求圆的周长，并使正多边形的周长无限接近圆的周长，进而求得较为精确的圆周率。
设圆半径为1，圆内接正6边形边长也为1，可如下计算正12边形的边长：
2.莱布尼茨级数法
π是个超越数，圆周率的超越性否定了化圆为方这种尺规作图精确求解问题的可能性。有趣的是，π可以用无穷级数表示：
左边的展式是一个无穷级数，被称为莱布尼茨级数（Leibniz），这个级数收敛到π/4，它通常也被称为格雷戈里-莱布尼茨级数，用以纪念莱布尼茨同时代的天文学家兼数学家詹姆斯·格雷戈里。
编程用这个公式计算π值，输入一个小数作为阈值，当最后一项的绝对值小于给定阈值时停止计算并输出得到的π值。
3.蒙特卡洛法
蒙特卡洛（Monte Carlo）方法是由数学家冯·诺伊曼提出的，诞生于上世纪40年代美国的“曼哈顿计划”。蒙特卡洛是一个地名，位于赌城摩纳哥，象征概率。蒙特卡洛方法的原理是通过大量随机样本，去了解一个系统，进而得到所要计算的值。
用蒙特卡洛方法计算圆周率π的原理如下：一个边长为2r的正方形内部相切一个半径为r的圆，圆的面积是πr2，正方形的面积为4r2，二者面积之比是π/4，因为比值与r大小无关，所以可以假设半径 r的值为1。
在这个正方形内部，随机产生n个点，坐标为（x,y），当随机点较多时，可以认为这些点服从均匀分布的规律。计算每个点与中心点的距离是否大于圆的半径(x2+y2>r2)，以此判断是否落在圆的内部。统计圆内的点数c，c与n的比值乘以4，就是π的值。理论上，n越大，计算的π值越准，但由于随机数不能保证完全均匀分布，所以蒙特卡洛法每次计算结果可能不同。
编程实现用蒙特卡洛方法计算π值，为了自动测评的需要，请先读入一个正整数sd作为随机数种子，并要求使用 x,y = random.uniform(-1,1) , random.uniform(-1,1) 语句来生成随机点的坐标值。
- 梅钦法
梅钦公式是格里高利/莱布尼茨计算的公式的变体，但是更实用，它的收敛速度显著增加，这使得它成为了更实用的计算的方法，虽然有若干种类梅钦(Machin-like)公式，但梅钦公式至今仍然是计算值的主要公式，根据此公式计算圆周率值。
5. 拉马努金法
拉马努金曾经提出过很多关于求π的公式，这些公式都有以下几个特点： 等号右边的构造超乎常人想象，收敛速度极快！
比如这个拉马努金在1914年发布的以他自己名字命名著名公式。
输入一个正整数n，根据此公式计算累加n次时的圆周率值。
10. 问题10
中国古代数学问题集锦
描述
中国古代《周髀算经》、《九章算术》和《孙子算经》等数学著作中记载了很多有趣的数学问题，其中很多题目非常适用于计算机求解，下面给出几个有趣的问题。
鸡兔同笼
大约在1500年前，《孙子算经》中就记载了这个有趣的问题。书中是这样叙述的：今有雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何？这四句话的意思是：有若干只鸡兔同在一个笼子里，从上面数，有35个头，从下面数，有94只脚。问笼中各有多少只鸡和兔？
请编一个程序，用户在同一行内输入两个整数h和f（两数之间用空格隔开），代表头和脚的数量，编程计算笼中各有多少只鸡和兔。假设鸡和兔都正常，无残疾。若有解则按照“有c只鸡，r只兔”的格式输出解；若无解则输出“Data Error!”
2.物不知数
“物不知数”出自《孙子算经》。题目为“今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二,问物几何？”意思是说有一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；7个7个数也会多出2个。
请编写一个程序，读入一个正整数n，计算并输出不超过输入数字n且满足条件的物品个数（有多个解时，按从小到大的顺序每个解占一行）。如无解则不输出。
3.二鼠打洞
《九章算术》的“盈不足篇”里有一个很有意思的老鼠打洞问题。原文这么说的：今有垣厚十尺，两鼠对穿。大鼠日一尺，小鼠亦一尺。大鼠日自倍，小鼠日自半。问：何日相逢？各穿几何？这道题的意思就是说，有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打一尺，小老鼠也是一尺。大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。问它们几天可以相逢，相逢时各打了多少。（要求使用循环完成，不允许使用幂运算）
请编写程序，读入1个正整数，代表墙的厚度，单位为尺；计算并输出两鼠相遇所需天数以及相遇时各自打墙厚度。输出分两行，第一行输出1个整数，表示相遇时所需的天数；第二行输出用空格分隔的2个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1位数字。
4.李白买酒
大诗李白，一生好饮酒。一天，他提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
- 宝塔上的琉璃灯
有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有765盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出分八行（1~8行），分别说明相应层上琉璃灯的数目，具体输出内容和格式见下面的说明。
输入输出格式说明
第一行输入一个字符串，若为"鸡兔同笼"、“物不知数”、“二鼠打洞”、“李白买酒”、"宝塔上的琉璃灯"五种之一，则调用相应程序处理中国古代数学问题；若不是，则直接打印’输入错误’并结束程序。
（1）当第一行输入“鸡兔同笼”时，第二行输入以空格分隔的两个整数h和f，h代表鸡兔的总头数，f代表鸡兔的总脚数。
若有解则按照“有c只鸡，r只兔”的格式输出解；若无解则输出“Data Error!”
（2）当第一行输入“物不知数”时，第二行输入一个正整数n（题目保证是正整数）。
计算并输出不超过输入数字n且满足条件的物品个数（有多个解时，按照从小到大的顺序、每个解占一行）。如无解则不输出。
（3）当第一行输入“二鼠打洞”时，第二行输入一个正整数w（题目保证是正整数）代表墙的厚度，单位为尺。
输出分两行，第一行输出1个整数，表示相遇时所需的天数；第二行输出用空格分隔的2个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，要求保留小数点后1位数字。
（4）当第一行输入“李白买酒”时，直接输出李白酒壶中原有酒几斗？
（5）当第一行输入“宝塔上的琉璃灯”时，输出共八行（1~8行），每一行都是一个字符串，第i行输出“第i层上有p只琉璃灯”。
11. 问题11
100以内素数之和
求 100 以内所有素数之和并输出。
素数指从大于 1，且仅能被 1 和自己整除的整数。
提示：可以逐一判断 100 以内每个数是否为素数，然后求和。
12. 问题12
四位玫瑰数
描述
四位玫瑰数是4位数的自幂数。自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。
例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数。
请输出所有4位数的四位玫瑰数，按照从小到大顺序，每个数字一行。
13. 问题13
用户登录的三次机会
给用户三次输入用户名和密码的机会，要求如下：
如输入第一行输入用户名为 ‘Kate’，第二行输入密码为 ‘666666’，输出 ‘登录成功！’，退出程序；
当一共有 3 次输入用户名或密码不正确输出 “3次用户名或者密码均有误！退出程序。”。
三、源代码分享
import matplotlib.pyplot as plt
import math
from math import sqrt
import time
import random
from matplotlib.pyplot import flag
def problem_1():
"""
储蓄问题。
已知某同学有一些零用钱，他想通过银行储蓄增值。问：存多少年，才能达到预期的数额？
（1）存期以一年为单位，存款以元为单位。
（2） 一年期的存款利率均为3%。
输入本金数和预期数，输出需要的年数。
"""
hold_money = eval(input())
fina_money = eval(input())
years = 0
while hold_money < fina_money:
hold_money *= 1.03
years += 1
print('要达到 {:.1f} 元，需要储蓄 {} 年'.format(fina_money, years))
def problem_2():
"""
输入一批整数，输入0时结束，求出其中的最大值与最小值。
"""
lst = []
while True:
a = eval(input())
if a != 0:
lst.append(a)
else:
max_num = max(lst)
min_num = min(lst)
print('最大值是：',max_num,'，最小值是：',min_num)
break
def problem_3():
"""
输入一批整数，输入0时结束，求这批数的平均数，结果保留两位小数。
"""
lst = []
sum = 0
while True:
a = eval(input())
if a != 0:
lst.append(a)
else:
for i in lst:
sum += i
mean = sum / len(lst)
print('{:.2f}'.format(mean))
def problem_4():
"""
求sum=2+22+222+…+22…222（有n个2）之值。 例如：当n=5时，sum=2+22+222+2222+22222
输入n，输出结果sum。
"""
n = eval(input())
sum = 0
a = 0
for i in range(0, n):
a += 2 * (10 ** (i))
sum += a
print(sum)
def problem_5():
"""
黄蓉给瑛姑所出的题目：今有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二，问几何？
即该数除以3余2，除以5余3，除以7余2，问这个数是多少
"""
a = eval(input())
if (a % 3 == 2 and a % 5 == 3 and a % 7 == 2):
print(a,'符合条件')
else:
print(a,'不符合条件')
def problem_6():
"""
判断一个数是否为“水仙花数”，所谓“水仙花数”是指这样的一类数：其各位数的立方和等于这数本身。
例如：371是一个“水仙花数”，371=3**3+2**3+1**3。
"""
a = eval(input())
a_1 = a // 100
a_2 = a // 10 % 10
a_3 = a % 10
if a == a_1 ** 3 + a_2 ** 3 + a_3 ** 3:
print(a,'是水仙花数')
else:
print(a,'不是水仙花数')
def problem_7():
"""
计算圆周率——蒙特卡洛法
"""
import random
counts = 0
a = eval(input())
n = eval(input())
random.seed(a)
for i in range(1, n + 1):
x = random.uniform(-1 , 1)
y = random.uniform(-1 , 1)
if (x ** 2 + y ** 2) <= 1:
counts += 1
pi = counts / n * 4
print(pi)
def problem_8():
def question_judge(question):
#"""接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
if question == '素数': # 如果输入”素数“，再输入一个正整数n，输出不大于n的所有素数
n = int(input())
output_prime(n) # 输出素数
elif question == '回文素数':
n = int(input())
palindromic_prime(n) # 输出回文素数
elif question == '反素数':
n = int(input())
reverse_prime(n) # 输出反素数
elif question == '哥德巴赫猜想':
n = int(input())
goldbach_conjecture(n)
else:
print('输入错误')
def is_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
#"""判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
#减小判定区间，减少循环次数，提升效率"""
def output_prime(number):
for i in range(number):
if is_prime(i) == True:
print(i, end=' ')
#
def palindromic(num):
return str(num) == str(num)[::-1]
# """接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
def palindromic_prime(number):
for i in range(number + 1):
if palindromic(i) and is_prime(i):
print(i, end=' ')
# """接收一个正整数参数number，遍历从0到number之间的所有整数，
#若某个数是素数，且转为字符串后是回文字符串，则称其为回文素数
#找出并在同一行中从小到大输出小于number的所有回文素数，各数字间用一个空格分隔，
#函数无返回值"""
#点击在此输入一行或多行代码
def reverse_num(num):
return int(str(num)[::-1])
def reverse_prime(number):
for i in range(2, number):
if not ((palindromic(i) and is_prime(i))) and is_prime(i) and is_prime(reverse_num(i)):
print(i, end=' ')
#"""接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，数字间用一个空格分隔。
#反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串
#函数无返回值"""
#点击在此输入一行或多行代码
"""
def goldbach_conjecture(num):
if num % 2 == 1:
print('Data error!')
elif num >= 2 and num % 2 == 0:
num_2 = int(num / 2)
for i in range(2, num_2):
for j in range(num_2, num):
if i + j == num and is_prime(i) and is_prime(j):
print('{}={}+{}'.format(num, i, j))
"""
def goldbach_conjecture(num):
prime = []
for item in range(2,num+1):
if is_prime(item):
prime.append(item)
if num % 2 == 1 or num < 4:
print('Data error!')
elif num % 2 == 0:
for i in prime:
for j in prime:
if i + j == num and i <= j:
print(f'{num}={i}+{j}')
if __name__ == '__main__':
problems = input()
question_judge(problems)
def problem_9():
import math
import random
def type_judge(pi_type):
"""接收一个字符串为参数，根据参数调用相应函数计算圆周率。"""
if pi_type == '割圆法':
times = int(input()) # 输入一个表示边数量的正整数
return cutting_circle(times) # 调用函数计算圆周率
elif pi_type == '无穷级数法':
threshold = float(input()) # 输入转为浮点数
return leibniz_of_pi(threshold) # 调用函数计算圆周率
elif pi_type == '蒙特卡洛法':
num = int(input()) # 输入转为整数
s = int(input()) # 输入随机数种子
return monte_carlo_pi(num, s) # 调用函数计算圆周率
elif pi_type == '梅钦法':
return machin_of_pi() # 调用函数计算圆周率
elif pi_type == '拉马努金法':
num = int(input()) # 输入转为整数
return ramanujan_of_pi(num)
else:
return f'未找到{pi_type}计算方法'
def cutting_circle(times):
"""参数times为分割次数
π = 周长/(2*圆的半径)得到π的近似值。
# 半径为1的圆内接正6边形边长也是1
# 边长 side_length
# 半径 radius
# 圆周率 pi
# 三角形的高 height
"""
def cal_length(x):
height = 1 - math.sqrt(1 - (x / 2) ** 2)
return math.sqrt(height ** 2 + (initial_length / 2) ** 2)
initial_length = 1 # 初始边长
k = 6 # 初始六边形
for i in range(times):
initial_length = cal_length(initial_length)
k *= 2
pi = initial_length * k / 2
return pi
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
pi = 4 * p
return pi
def monte_carlo_pi(num, s):
"""接收一个表示随机次数的整数和一个整数做随机数种子，用蒙特卡洛法计算圆周率，返回一个浮点数"""
counts = 0
random.seed(s)
for i in range(1, num + 1):
x = random.uniform(-1, 1)
y = random.uniform(-1, 1)
if (x ** 2 + y ** 2) <= 1:
counts += 1
pi = counts / num * 4
return pi
def machin_of_pi():
"""用梅钦级数计算圆周率，返回圆周率值"""
pi = 16 * math.atan(1 / 5) - 4 * math.atan(1 / 239)
return pi
def ramanujan_of_pi(n):
"""接收一个正整数n为参数，用拉马努金公式的前n项计算圆周率并返回。"""
sum = 0
for i in range(n):
sum += ((2 * math.sqrt(2)) / 9801) * (math.factorial(4 * i) * (1103 + 26390 * i)) / (math.pow(math.factorial(i), 4) * math.pow(396, 4 * i))
pi = 1 / sum
return pi
# 取消以下代码行前面的注释可以调用其中的函数对割圆法和蒙特卡洛法进行演示
# def draw_circle(r, side_num):
# """创建图形和轴，用折线图绘制正多边形。
# @参数 r：圆的半径
# @参数 side_num：正多边形的边数
# """
# fig, ax = plt.subplots() # 创建图形和轴
# plt.subplots_adjust(left=0.1, bottom=0.25)
# x, y = xy_of_polygon(r, side_num)
# plt.plot(x, y, lw=2, color='red') # 设置线宽和颜色
# ax.set_aspect('equal') # 设置坐标轴纵横比相等
# ax.set_xlim(-r-5, r+5) # 设置x轴刻度起止值
# ax.set_ylim(-r-5, r+5)
# plt.draw() # 重新绘制多边形
# plt.show() # 显示图形
#
#
# def cutting_circle(times):
# """
# 接收表示分割次数的整数n 为参数，计算分割n 次时正多边形的边数和圆周率值，返回边数和圆周率值。
# @参数 times：分割次数
# π = 周长/(2*圆的半径)得到π的近似值。
# # 半径为1的圆内接正6边形边长也是1
# # 边长 side_length
# # 半径 radius
# # 圆周率 pi
# # 三角形的高 height
# >>> cutting_circle(4)
# 3.14103195089051
# """
# side_length = 1 # 初始边长
# edges = 6 # 初始边数
# for i in range(times):
# height = 1 - math.sqrt(1 - (side_length / 2) ** 2)
# side_length = math.sqrt(height ** 2 + (side_length / 2) ** 2)
# edges = edges * 2 # 每割一次，边数量加倍
# draw_circle(300, edges) # 调用此函数可演示割圆效果，每次循环绘制一个近似圆，关闭后看下一个
# pi = side_length * edges / 2
# return pi
#
#
# def monte_carlo_show(in_circle_lst, out_circle_lst):
# """
# @参数 in_circle_lst：落在圆内的点的坐标列表
# @参数 out_circle_lst：落在圆外的点的坐标列表
#
# """
# plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
# plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
# plt.figure(figsize=(11, 11)) # 设置画布长宽
# x_in_circle = [x[0] for x in in_circle_lst] # 落在圆内的点的列表x
# y_in_circle = [x[1] for x in in_circle_lst] # 落在圆内的点的列表y
# x_out_circle = [x[0] for x in out_circle_lst] # 落在圆外的点的列表x
# y_out_circle = [x[1] for x in out_circle_lst] # 落在圆外的点的列表y
# plt.scatter(x_out_circle, y_out_circle, s=10, facecolors='blue') # 绘制散点，落在圆外在点颜色用蓝色
# plt.scatter(x_in_circle, y_in_circle, s=5, facecolors='red') # 绘制散点，落在圆内在点颜色用红色
# plt.title('蒙特卡洛法计算圆周率演示') # 图的标题
# plt.show() # 显示绘制结果
#
#
# # 给出turtle模板，学生填monte_carlo代码，帮助学生理解算法，了解turtle绘图
# def monte_carlo_pi_turtle(n, s):
# """用turtle绘图模拟蒙特卡洛n次结果"""
# random.seed(s)
# turtle.tracer(1000)
# turtle.pensize(4)
# turtle.penup()
# turtle.goto(-300, -300)
# turtle.pendown()
# for i in range(4):
# turtle.forward(600)
# turtle.left(90)
# turtle.forward(300)
# turtle.pencolor('green')
# turtle.circle(300)
# hits = 0 # 落在圆内的计数器初值设为 0
# for i in range(1, n + 1):
# x, y = random.uniform(-1, 1), random.uniform(-1, 1) # 生成两个随机数模拟一个点的坐标
# pos = (x ** 2 + y ** 2) ** 0.5 # 计算坐标（x,y）到原点的距离
# if pos <= 1.0: # 如果距离小于等于1，点在圆内
# hits = hits + 1
# turtle.pencolor('red') # 落在圆内在点颜色用红色
# else: # 如果距离大于1，点在圆外
# turtle.pencolor('blue') # 落在圆内在点颜色用蓝色
# turtle.penup()
# turtle.goto(x * 300, y * 300) # 画笔抬起并移动到数值放大400倍的x,y处
# turtle.pendown()
# turtle.dot(3) # 画一个半径为 3 的圆点
# if i % 10000 == 0: # 实验为10000的倍数次时
# turtle.pencolor('black')
# pi = 4 * (hits / i) # 根据落在圆内外的点数量估算PI值
# turtle.penup() # 画笔抬起
# turtle.goto(320, 150 - i // 1000 * 30) # 移动到区域外记录当前PI值
# turtle.pendown() # 画笔抬起
# turtle.write("{}次时PI的值是{:.4f}".format(i, pi), font=("宋体", 18, "normal"))
# turtle.hideturtle() # 隐藏光标
# turtle.update() # 刷新
# turtle.done() # 结束绘制
if __name__ == '__main__':
type_of_pi = input() # 接收用户输入的字符串
cal_pi = type_judge(type_of_pi) # 调用判断类型的函数
print(cal_pi) # 输出函数运行结果
def problem_10():
def type_judge(question):
"""接收一个字符串为参数，根据参数调用不同函数执行不同代码。
这种写法不规范，但把输入、输出都放在一个函数中，方便管理。
"""
if question == '鸡兔同笼':
chicken_rabbit() # 用户输入为'鸡兔同笼'调用此函数
elif question == '物不知数':
amount_of_goods() # 用户输入为'物不知数'调用此函数
elif question == '二鼠打洞':
two_mice() # 用户输入为'二鼠打洞'调用此函数
elif question == '李白买酒':
libai_buy_wine() # 用户输入为'李白买酒'调用此函数
elif question == '宝塔上的琉璃灯':
lamp_on_pagoda() # 用户输入为'宝塔上的琉璃灯'调用此函数
else:
print('输入错误')
def chicken_rabbit():
"""
在同一行内输入用空格分隔的两个整数，代表头和脚的数量，计算并输出笼中各有多少只鸡和兔，
如无解则输出“Data Error!”，函数无返回值。
输入：35 94
输出：有23只鸡，12只兔
输入：100 5
输出：Data Error!
"""
a, b = map(int, input().split(' '))
i = 0
while(i <= a):
if(2 * i + 4 * (a - i) != b):
i += 1
continue
else:
break
if(i <= a):
print('有{}只鸡，{}只兔'.format(i, a - i))
else:
print("Data Error!")
def amount_of_goods():
"""一些物品，不知道有多少个，3个3个数的话，还多出2个；5个5个数则多出3个；
7个7个数也会多出2个。输入一个正整数，从小到大依次输出所有不超过输入数字
且满足条件的物品数量，有多个答案时每行输出一个。
例如输入：200
输出：
23
128
"""
a = eval(input())
for i in range(a + 1):
if i % 3 == 2 and i % 5 == 3 and i % 7 == 2:
print(i)
def two_mice():
"""有一堵十尺厚的墙，两只老鼠从两边向中间打洞。大老鼠第一天打洞一尺，小老鼠也是打洞一尺。
大老鼠每天的打洞进度是前一天的一倍，小老鼠每天的进度是前一天的一半。计算并输出它们几天可以相逢，
相逢时各打了多少尺。
输入格式：输入1 个整数，代表墙的厚度，单位为尺
输出格式：
第一行输出1 个整数，表示相遇时所需的天数
第二行输出2 个浮点数，分别为小鼠和大鼠打洞的距离，单位为尺，保留小数点后1 位数字。
"""
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 libai_buy_wine():
"""大诗人李白，提着酒壶，从家里出来，酒壶中有酒若干。他边走边唱：无事街上走，提壶去买酒，
遇店加一倍，见花喝一斗，五遇店和花，喝光壶中酒，计算并输出壶中原有酒几斗？
"""
n = 0
for i in range(5):
n += 1
n /= 2
print(n)
def lamp_on_pagoda():
"""有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，
已知共有765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。
输出为8行，从上往下数字依次增大。
"""
sum = 0
for i in range(8):
sum += 2**i
x = int(765 / sum)
for i in range(8):
print('第{}层上有{}只琉璃灯'.format(i + 1, 2**i * x))
if __name__ == '__main__':
choice = input() # 接收用户输入的字符串
type_judge(choice) # 调用判断输入的函数决定执行哪个函数
def problem_11():
"""
求 100 以内所有素数之和并输出。
素数指从大于 1，且仅能被 1 和自己整除的整数。
"""
lst = []
for i in range(2, 101):
for n in range(2,i):
if i % n == 0:
break
else:
lst.append(i)
print(sum(lst))
def problem_12():
"""
四位玫瑰数是4位数的自幂数。自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。
例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数。
请输出所有4位数的四位玫瑰数，按照从小到大顺序，每个数字一行。
"""
for i in range(1000, 10000):
i_1 = i // 1000
i_2 = i // 100 % 10
i_3 = i // 10 % 10
i_4 = i % 10
if i == i_1 ** 4 + i_2 ** 4 + i_3 ** 4 + i_4 ** 4:
print(i)
def problem_13():
"""
给用户三次输入用户名和密码的机会，要求如下：
如输入第一行输入用户名为 ‘Kate’，第二行输入密码为 ‘666666’，输出 ‘登录成功！’，退出程序；
当一共有 3 次输入用户名或密码不正确输出 “3次用户名或者密码均有误！退出程序。”。
"""
counts = 0
for i in range(3):
account_name = input()
pass_word = input()
if account_name == 'Kate' and pass_word == '666666':
counts = 1
print('登录成功！')
break
if counts == 0:
print('3次用户名或者密码均有误！退出程序。')
if __name__ == '__main__':
problem_13()
3062
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
