循环结构编程实例补充

你的任务是模拟着中汽车的控制软件的一部分，输入是一系列表示开关和换挡的值，按照下面的顺序：

1. 左、右滑动门的仪表盘开关，儿童锁开关，主解锁开关（0 表示关闭，1 表示启用）
2. 左、右滑动门的内部和外部把手（0 或 1）
3. 换挡设置（P N D 1 2 3 R 之一）
   输出可能为：左边门打开；右边门打开；两边门都打开；两边门都打不开
   0左门的仪表盘开关(0 or 1): 0
   1右门的仪表盘开关(0 or 1): 0
   2儿童锁开关(0 or 1): 0
   3主解锁开关(0 or 1): 1
   4车内的左门把手(0 or 1): 0
   5车外的左门把手(0 or 1): 1
   6车内的右门把手(0 or 1): 0 .
   7车外的右门把手(0 or 1): 0 .
   8换挡位置(P,N,D,1,2,3orR):P
   左边门打开.

num=list(input("请输入状态"))
//打开主控开关并停车
if num[3]=="1" and num[8]=="p":
    /# 是儿童座椅情况
    if num[2] == "1":
        if (num[0] == "1" or  num[5]=="1" )and (num[1] == "1" or num[7]=="1"):
            print("都开1")
        elif num[0] == "1" or num[5]=="1":
            print("左开2")
        elif num[1] == "1" or num[7]=="1":
            print("右开3")
        else:
            print("都关3")

//不是儿童座椅情况
    else:
        if (num[0] == "1" or num[4] == '1' or num[5]=="1" )and (num[1] == "1" or num[6] == '1' or num[7]=="1"):
            print("左右门都开4")
        elif num[0] == "1" or num[4] == '1' or num[5] == "1":
            print("左开5")
        elif num[1] == "1" or num[6] == '1' or num[7] == "1":
            print("右开6")
        else:
            print("都关")

未打开主控开关或未停车
else:
    print("都关")

数字转罗马数字

数字使用下面的规则组成：

1. 只能表示 3999 以内的数
2. 如十进制系统一样，千位，百位，十位，个位也是分别表示的
3. 数字 1 到 9 的表示规则如下 I 1 II 2 III 3 IV 4 V 5 VI 6 VII 7 VIII 8 IX 9
   可以得出的规律是：在 V 或者 x 前面的 I 表示从这个值中减去，在 V 后面的 I表示从这个值中加上，并且同一行内不能超过三个 I。
4. 十位和百位也是这样处理的。除了用字母 X L C 和 C D M 分别替换 I V X
   输入案例：1978
   输出案例：MCMXXVII

a = [1000, 900, 500, 400,  100,  90,   50,  40,   10,   9,   5,   4,    1 ]
m = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I']
s = ""
num=int(input("请输入数字："))
if num > 3999 or num < 1:
    exit()
for i in range(len(a)):
  //# 从大到小满足输出一个高位罗马字符
    while num >= a[i]:
        num -= a[i]
        s += m[i]
print(s)

'''Fibonacci 数列

Fibonacci 数列由下面的序列定义：第一个和第二个数都为 1，从第三个数开始，值为
前面两个数的和。 f1 = 1 f2 = 1 fn = fn-1 + fn+1
上面的序列可以形式化为： fold1 = 1 fold2 = 1 fnew = fold1 + fold2
然后 fold1 的值应该更新为 fold2 的值，fold2 的值应该更新为 fnew 的值，该过程重
复需要的次数。请编程输入 n，输出 Fibonacci 数列的第 n 项。
提示：本案例需要用到选择和循环
输入输出案例如下
输入案例：7
输出案例：Fibonacci 数列的第 7 项是 13

n=int(input("请输入斐波拉契数列的几项："))
fold1 = 1
fold2 = 1
for i in range(3,n+1):
    fnew = fold1 + fold2
    fold1=fold2
    fold2=fnew
if n==1 or n==2:
    print("第{}项为：{}".format(n,1))
elif n>2:
    print("第{}项为：{}".format(n,fnew))
else:
    print("输入有误：")

蒙特卡罗模拟求 pi 值：扔飞镖实验

往半径为 1 的圆的外切正方形内中扔飞镖，如果飞镖落在圆中，表示命中。如果扔的次
数足够多，那么扔飞镖命中的次数 tries 与扔的总次数 tries 的比值非常接近圆的面积和正方
形的面积比，因为这里圆的半径为 1，正方形的边长为 2，所以这个比值非常接近于 pi/4 的
值，这样就可以求出圆周率 pi 的近似值。提示：为了生成介于边界 a 和边界 b 之间的浮点数，可以使用如下的方法：

r = random()
x = a + (b-a) * r
输出案例：pi 的近似值是: 3.166（各位同学注意：这个值每次输出的不一样）
'''
import  random
tries=int(input("请输入样本总数:"))
sum=0
for i in range(tries):
    x = random.uniform(0, 1)
    y = random.uniform(0, 1)
    if (x * x + y * y) < 1:
        sum += 1
pi = 4.0 * sum / tries
print("经过{}次得到Π的近似值为：{}".format(tries,pi))

蒙特卡罗模拟求 pi 值：布冯投针实验

下图为多条间距 2 英寸的直线。现有长度为 1 英寸的针，把针（红色的短线代表）往图
上投掷，如果落在线上，称为一次命中，一次命中的次数用变量 hits 表示，测试的总次数用
tries 表示。布冯发现测试的次数如果足够多，tries/hits 的比值接近于圆周率 pi。
对于该实验，需要生成两个随机数：一个用来描述针的起始位置 Ylow，一个用来描述针
与 x 轴的夹角 a。然后需要测试针是否与某条直线有接触，可采用如下的判断方法。
生成针起始位置的点：与 X 坐标不相关，因此假设 Y 坐标 Ylow是介于 0 到 2 之间的任
意随机数。针与 x 轴的夹角可以是 0 到 180 度之间的任意随机数。那么针的上端点 Yhigh 的
坐标为 Yhigh = Ylow+sina # 针的长度为 1，注意 sina 中 a 的单位是弧度，不是度。
如果 Yhigh大于等于 2，那么就一次命中了。如下图所示：
尝试 10 000 次，输出比值 tries/hits，看是否和 pi 接近。
提示：本案例需要用到循环和选择
输入输出案例如下
输入案例：无
输出案例：通过实验，我们估计 pi 的值是 3.1249023468016626（各位
同学注意：这个值每次输出的不一样）

import random
import math
D = 2# 平行线距离
L = 1# 针的长度
hits = 10000# 实验次数
tries = 0# 触碰次数
for i in range(1, hits+1):
    Ylow =random.uniform(0,D/2)
    Yhigh= random.uniform(0, math.pi/ 2)
    if Ylow < (L / 2) * math.sin(Yhigh):
        tries += 1
//# 计算π
P = tries/hits
print('π = {}'.format((2*L)/(P*D)))

'''如果一个整数除了 1 和他自己以外不能被其他任何数字整除，那么这个数就是素数。

编写程序提示用户输入一个整数，输出小于该数的所有素数。例如用户输入 20，那么
程序应该输出235711131719
注意这个问题的解决要使用到循环的嵌套。在 for 循环中嵌套另外一个 for 循环。在最
里层的循环重要结合选择

import math
num = int(input("请输入一个整数："))
if num < 2:
    print("输入有误:")
    exit()
for i in range(2,num+1):
    for j in range(2,i):
        if i%j==0:
            break
    else:
        print(i)

一个整数可以被分解为若干素数的乘积，例如输入 24，可以分解为 24 = 222*3，输入任意整数，输出他所有的素数因子

num = int(input('请输入需要分解的正数:'))
new = []
m = num
while num > 1:
    for i in range(2,num+1):
        if num%i==0:
            num = num//i
            new.append(str(i))#P69添加列表元素
            #print(new)
            break
if len(new) == 1:
    print(m,'=','1 ×',m)
else:
    s = '×'.join(new)#字符串串联迭代s.join(可迭代) 元素分隔符是s
    print(m,'=',s)

'牛顿迭代法我们在基础实训项目中完成了基于牛顿迭代法的原理使用 while 循环来求一个数的近似平方根，那么如何使用牛顿迭代法求一个数的 n 次方根？试着解答这一问题。

/#牛顿迭代
num=int(input("请输入一个数:"))
n=int(input("请输入一个数开几次方："))
a=n#输出
x = num
x1 = ((n - 1) * x + num / (pow(x, n - 1))) / n
while abs(x - x1) >= 0.01:
    x1 = x
    x = ((n - 1) * x + num / (pow(x, n - 1))) / n
print("牛顿迭代法求得{}开{}次方根为{}:".format(num,a,x))

'''
x1=(1*x/z)+(x/(x*z))#2
//#x1=(2*x0/3)+(input/(x0*x0*3))#3
//#x1=(3*x0/4)+(input/(x0*x0*x0*4))#4
//#x1=(4*x0/5)+(input/(x0*x0*x0*x0*5))#5
while abs(x1-x)>0.000001:
    x = x1
    x1 = (1 * x / z) + (x / (x * z))#2
    # x1=(2*x0/3)+(input/(x0*x0*3))3
    # x1=(3*x0/4)+(input/(x0*x0*x0*4))4
    # x1=(4*x0/5)+(input/(x0*x0*x0*x0*5))5
print(x1)

//#牛顿二分法

num=int(input("请输入一个数:"))
n=int(input("请输入一个数开几次方："))
a=n#输出
x = num/2.0
x1 = 0
while abs(x - x1) >= 0.01:
    x1 = x
    x = ((n - 1) * x + num / (pow(x, n - 1))) / n
print("二分法求得{}开{}次方根为{}:".format(num,a,x))