Demo30 打印菱形 I
题目描述
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述输入高度n，n为奇数输出该高度的菱形
n = eval(input())
for i in range(1 , n + 1):
for k in range(abs(n // 2 + 1 - i)):
print(" " , end = "")
for j in range(1 , i + 1):
if j <= i and i + j <= n + 1:
print("*", end = " ")
print()
Demo31 打印菱形 II
题目描述
如下所示，是一个高度为9的菱形
*
* *
* *
* *
* *
* *
* *
* *
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
*
* *
* *
* *
*
n = eval(input())
for i in range(1 , n + 1):
for k in range(abs(n // 2 + 1 - i)):
print(" ", end = "")
for j in range(1 , i + 1):
if j <= i and i + j <= n + 1:
if j ==1 or j == i or j + i == n + 1:
print("*", end = " ")
else:
print(" ", end = " ")
print()
Demo32 打印菱形 III
题目描述
如下所示，是一个高度为9的菱形
*
***
*****
*******
*********
*******
*****
***
*
用户输入菱形高度n，并打印出该高度下的菱形
输入输出描述
输入高度n，n为奇数
输出该高度的菱形
示例
输入：
5
输出：
*
***
*****
***
*
# 打印菱形lll
# 输入菱形高度n
n = eval(input("请输入菱形高度："))
# m为中间变量
m = (n + 1) // 2
# 外层循环 控制行数
for i in range(1,n + 1) :
# 打印每行开头的空格 每行打印的空格数为abs(m - i)
for j in range(abs(m - i)) :
print(" ", end = "")
# 打印每行的星星 每行打印的星星个数为(m - abs(m - i)) * 2 - 1
for k in range((m - abs(m - i)) * 2 - 1) :
print("*",end = "")
# 内循环结束 换行
print()
Demo33 猜数字
题目描述
计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同
对于用户输入的数字，程序会提示它是过高还是过低
输入输出描述
每次输入一个整数
每次输出该数字是过高还是过低，如果猜中则输出猜中的数字并结束
示例
输入：50
输出：高了
输入：25
输出：低了
输入：42
输出：高了
输入：39
输出：猜中了！答案就是39
import random
randNum = random.randint(0,100)
while True:
userNum = eval(input())
if userNum > randNum:
print("大了")
elif userNum < randNum:
print("小了")
else:
print("猜对了！！！")
break
Demo34 最大公约数I
题目描述
输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8
输入输出描述
输入两个数字
输出最大公约数
示例1
输入：
16 24
输出：
8
示例2
输入：
7 3
输出：
1
# 最大公约数l
# 输入两个正整数num1，num2
num1, num2 = eval(input("请输入两个正整数："))
# 取小的那个数字 公约数最大时为小的那个数字
minNum = min(num1,num2)
# for循环 从小的那个数字开始 一直到1
# 第一次出现两数对i取余为0时 i即为最大的公约数
for i in range(minNum,0,-1) :
if num1 % i == 0 and num2 % i == 0 :
# 输出最大公约数 并结束循环
print(i)
break
Demo35 判断素数
题目描述
一个大于1的整数如果只能被正整数1和它本身整除，则它就是素数，例如2、3、5和7都是素数，而4、6、8、9则不是
输入输出描述
输入一个大于1的正整数
输出Yes表示该数字是素数，否则输出No
示例1
输入：
9
输出：
No
示例2
输入：
11
输出：
Yes
# 判断素数
# 输入一个大于1的正整数 num
num = eval(input("请输入一个大于1的正整数:"))
# 标志 flag 默认为true
flag = True
# for循环遍历
for i in range(2,num // 2 + 1) :
# 如果num对i取余为0 则num不是素数
if num % i == 0 :
# 标志变为false
flag = False
# 退出循环
break
# flag为真 则表明num为素数 为假则不是素数
if flag :
print("Yes")
else :
print("No")
Demo36 最小公倍数
题目描述
输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15
输入输出描述
输入两个正整数
输出最小公倍数
示例1
输入：
3 9
输出：
9
示例2
输入：
4 6
输出：
12
# 最小公倍数
# 输入两个正整数
num1, num2 = eval(input("请输入两个正整数："))
# 大的数字为maxNum 最小公倍数最小时为maxnum
maxNum = max(num1,num2)
while True :
# 若一个数对num1和num2取余都为0 则此数为num1num2的公倍数
# 此数由小到大每次加1 因此首次符合条件的即为最小公倍数
if maxNum % num1 == 0 and maxNum % num2 == 0 :
# 输出最小公倍数 并退出循环
print(maxNum)
break
# 迭代条件 每次循环加一
maxNum += 1
Demo37 整数的素因子
题目描述
输入一个正整数，然后找出它所有的最小因子，也称之为素因子
输入输出描述
输入一个正整数
输出多行，每行输出一个素因子
示例1
输入：
120
输出：
2 2 2 3 5
解释：
2 * 2 * 2 *3 * 5 = 120
示例2
输入：
100
输出：
2 2 5 5
# 整数的素因子
# 输入正整数n
n = int(input())
# 遍历从2到n的所有整数，找出n的素因子
for i in range(2, n + 1):
# 如果i能整除n，说明i是n的一个素因子
while n % i == 0:
# 输出素因子
print(i, end=' ')
# 用i去除n的因数，更新n的值
n //= i
# 若n大于1，说明输入的正整数本身就是素数，此时直接输出即可
if n > 1:
print(n)
Demo38 完全数
题目描述
如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数
例如 6 = 3 + 2 + 1，28 = 14 + 7 + 4 + 2 + 1
输入输出描述
输入一个正整数
输出该数是否为完全数
示例1
输入：
6
输出：
Yes
示例2
输入：
9
输出：
No
# 完全数
# 输入一个正整数mun
num = eval(input("请输入一个正整数:"))
# 用sum来保存正因子之和 初始值为0
sum = 0
# 循环遍历1到num//2 判断是否为num的正因子
for i in range(1,num // 2 + 1) :
if num % i == 0 :
# 将正因子累加到sum
sum += i
# 如果sum等于num 则num为完全数
if sum == num :
print("Yes")
else :
print("No")
Demo39 前50个素数
题目描述
打印前50个素数，每打印10个素数换行
# 前50个素数
# num为第一个素数 count用来记录素数的个数
num = 2
count = 0
# 在找到50个素数之前 继续循环
while count != 50 :
# 标志 fg 初始化为true
fg = True
# 循环遍历
for i in range(2,num // 2 + 1 ) :
# 若num对i取余为0 则num不是素数
if num % i == 0 :
# 标志变为false
fg = False
# 若num为素数 count加一 输出num
if fg :
count += 1
print(num,end = "\t")
# 每输出十个素数 进行换行
if count % 10 == 0 :
print()
# 迭代条件 每次while循环 num加一
num += 1
Demo40 计算π
题目描述
你可以使用下面的数列近似计算π
当i越大时，计算结果越近似于π
# 计算π
# 初始化sum为0
sum = 0
for i in range(1,1000000) :
# i为奇数时 +
if i % 2 != 0:
sum = sum + 1 / (2 * i - 1)
# i为偶数时 -
else :
sum = sum - 1 / (2 * i - 1)
pai =4 * sum
# 输出π的近似值
print(pai)
Demo41 计算e
题目描述
你可以使用下面的数列近似计算e
当i越大时，计算结果越近似于e
# 计算e
# 初始化为1 用于累加计算e的近似值
e = 1
for i in range(1, 1000) :
# 初始化为1 用来计算阶乘
jiecheng = 1
for j in range(1, i + 1):
jiecheng *= j
# 计算e的近似值
e += 1 / jiecheng
# 输出e的近似值
print(e)
Demo42 剪刀石头布II
题目描述
延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者
# 剪刀石头步ll
import random
# jsjcount usercount 分别记录计算机和用户赢得次数 初始化都为0
jsjcount = 0
usercount = 0
# 当计算机和用户赢的次数都小于三时，没有最终胜利者 一直执行游戏
while jsjcount < 3 and usercount < 3 :
# 用户输入user
user = eval(input("请输入数字0,1,2,分别表示剪刀,石头,布:"))
# 计算机随机生成jsj
jsj = random.randint(0,2)
# print(jsj)
# 创建一个包含剪刀，石头，布的列表
game = ['剪刀','石头','布']
# 输出计算机和用户所输入数值对应的数据
print(f'计算机出的 {game[jsj]}')
print(f'用户出的 {game[user]}')
# 条件判断
# 1.平局情况
if jsj == user :
print("平局")
# 2.用户赢的情况
elif (jsj == 0 and user == 1) or (jsj == 1 and user == 2) or (jsj == 2 and user ==0) :
print("用户赢")
# 用户赢得次数加一
usercount += 1
# 其他情况，即计算机赢的情况
else :
print("计算机赢")
# 计算机赢的次数加一
jsjcount += 1
# 谁赢的次数为三 则为最终胜利者
if jsjcount == 3 :
print("计算机是最终胜利者")
if usercount == 3 :
print("用户是最终胜利者")
Demo43 组合问题I
题目描述
在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合，输出每一组组合，并统计所有组合的个数
注：组合（a，b）与组合（b，a）算同一种组合，只记录一次
# 组合问题l
# count 记录组合的个数
count = 0
# 起始值
start = 1
# 结束值
end = 7
for i in range(start, end):
# 从i+1开始以避免重复组合（a，b）与（b，a）
for j in range(i + 1, end + 1):
# 输出组合 计数器加一
print(f"({i}, {j})")
count += 1
# 输出组合数
print("组合总个数:", count)
Demo44 组合问题II
题目描述
有1、2、3、4这个四个数字，能组成多少个互不相同且无重复数字的三位数？分别又是多少？
# 组合问题ll
# count 记录组合的个数
count = 0
# 创建一个数字列表
lists = [1, 2, 3, 4]
# i，j，k均来自lists
for i in lists:
for j in lists:
for k in lists:
# 确保无重复数字
if i != j and i != k and j != k:
count += 1
print(f"{i}{j}{k}")
print("互不相同且无重复数字的三位数总个数:", count)
Demo45 水仙花数
题目描述
水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身，例如$153=1^3+5^3+3^3$
编写程序，输出所有的水仙花数
# 水仙花数
# for循环遍历范围为全体三位数
for i in range(100,1000) :
# 取得i的个位十位百位
ge = i % 10
shi = i // 10 % 10
bai = i // 10 // 10 % 10
# 如果i符合水仙花数的定义 则输出
if ge ** 3 + shi ** 3 + bai ** 3 == i :
print(i)
Demo46 青蛙跳台阶
题目描述
一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？
例如：两个台阶，有两种跳法（1+1，2）；四个台阶，有五种跳法（1+1+1+1，2+1+1，1+2+1，1+1+2，2+2）
# 青蛙跳台阶
# 输入台阶数n
n = eval(input("请输入台阶数:"))
# n=1或者n=2时
if n == 1 or n == 2 :
print(n)
# n>=3时
else :
a = 1
b = 2
# 跳法数 = 前两次之和
for i in range(3,n+1) :
c = a + b
a = b
b = c
print(c)
Demo47 堆叠相加
题目描述
现有堆叠相加模式$a+aa+aaa+aaaa+aaaaa+......$
例如：$2+22+222+2222+22222$，其中a为2，且有5组数字
输入输出描述
输入两个数据分别为数字a和组数n
输出按照堆叠相加模式算出的和
示例
输入：
3 4
输出：
3702
解释：
3 + 33 + 333 + 3333 = 3702
# 堆叠相加
# 输入数字a和组合数n
a, n = eval(input("请输入数字和组合数:"))
# sum 记录累加和 初始化为0
sum = 0
# num为每一项的值 初始化为0
num = 0
for i in range(n) :
num = num * 10 + a
sum += num
# 输出堆叠之和
print(sum)
Demo48 十进制转二进制
题目描述
输入一个十进制正整数，输出其二进制形式
输入输出描述
输入一个十进制正整数
输出二进制字符串
示例
输入：
9
输出：
1001
# 十进制转二进制
# 输入十进制整数num
num = eval(input("请输入一个十进制整数:"))
# 空字符串 用来存储二进制
string = ""
while num != 0 :
# 除二取余得y
y = num % 2
# 将二进制位y添加在字符串左侧
string = str(y) + string
# 更新num的值
num = num // 2
# 输出二进制字符串
print(string)
Demo49 二进制转十进制
题目描述
输入一个二进制字符串，输出其对应的十进制数字
输入输出描述
输入一个二进制字符串
输出十进制数字
示例
输入：
1001
输出：
9
# 二进制转十进制
# 输入一个二进制的字符串
numB = input("请输入一个二进制字符串:")
# count记录字符串的字符个数 sum 记录和
count = 0
sum = 0
# 遍历字符串 得到该字符串的位数
for j in numB :
count += 1
# 再次遍历字符串
for i in numB :
# 将字符i转换为数字i
i = int(i)
num = i * 2 ** (count-1)
# 每位二进制的十进制值累加
sum += num
# 循环一次 对应字符乘2的count次方减一
count -= 1
# print(count)
# 输出最终的十进制值
print(sum)
Demo50 十进制转十六进制
题目描述
输入一个十进制正整数，输出其十六进制形式
输入输出描述
输入一个十进制正整数
输出十六进制字符串
示例
输入：
123321
输出：
1e1b9
num = eval(input())
s = ""
while num !=0:
y = num %16
if y >= 10:
y = chr(ord('A') + y -10)
s = str(y) + s
num = num // 16
print(s)
Demo51 十六进制转十进制
题目描述
输入一个十六进制字符串，输出其对应的十进制数字
输入输出描述
输入一个十六进制字符串
输出十进制数字
示例
输入：
1e1b9
输出：
123321
num = input()
result = 0
lenth = len(num) - 1
for i in num:
if '0' <= i <= '9':
result = result + int(i) * (16 ** lenth)
else:
result = result + (ord(i.upper()) - ord('A') + 10) * (16 ** lenth)
lenth = lenth - 1
print(result)
Demo52 最长公共前缀
题目描述
给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写
输入输出描述
输入两行，分别表示s1和s2
输出前缀串
示例
输入：
abcdefg
abcdhko
输出：
abcd
# 最长公共前缀
s1 = input() # 输入字符串s1
s2 = input() # 输入字符串s2
max_length = min(len(s1), len(s2)) # 最长可能的公共前缀长度
# 遍历两个字符串的对应字符，直到遇到不相同的字符或遍历完所有可能的字符
for i in range(max_length):
if s1[i] != s2[i] :
break # 遇到不相同的字符，跳出循环
# 提取最长公共前缀串
qianZhui = s1[:i] #从字符串 s1 的起始位置截取到索引 i 之前的子字符串(不包括索引 i 对应的字符）
print(qianZhui) # 输出最长公共前缀串
Demo53 子串出现的次数
题目描述
给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，字符区分大小写，已匹配的字符不计入下一次匹配
输入输出描述
输入两行字符串，分别为s1和s2，s2的长度小于等于s1
输出s2在s1中出现的次数
示例1
输入：
ABCsdABsadABCasdhjabcsaABCasd
ABC
输出：
3
示例2
输入：
AAAAAAAA
AAA
输出：
2
# 子串出现的次数
s1 = input() # 输入字符串 s1
s2 = input() # 输入字符串 s2
# 计数器count 记录出现的次数
count = 0
# 索引变量 i 初始化为0，用于遍历字符串 s1
i = 0
while i < len(s1) - len(s2) + 1: # 确保有足够的字符供匹配
if s1[i:i+len(s2)] == s2: # 判断 s1 中从索引 i 开始的子串是否与 s2 相等
count += 1
i += len(s2) # 移动索引 i 到下一个可能的起始位置
else:
i += 1 # 若不相等，仅移动索引 i 一位
print(count) # 输出 s2 在 s1 中出现的次数
Demo54 最长公共子串
题目描述
给定两个字符串 s1 和 s2 ，求 s1 与 s2 之间的最长公共子串，字符区分大小写
输入输出描述
输入两行字符串，分别为s1和s2
输出最长公共子串
示例
输入：
123ABCDEFG83hsad
iughABCDEFG23uy
输出：
ABCDEFG
# 最长公共子串
s1 = input() # 输入字符串s1
s2 = input() # 输入字符串s2
max_len = 0 # 最长公共子串长度
max_string = '' # 最长公共子串
for i in range(len(s1)):
for j in range(i + 1, len(s1) + 1):
sub_str = s1[i:j] # 提取s1的子串 [i:j] 是切片操作符，表示从索引i开始，到索引j（不含）结束的部分。
if sub_str in s2 and len(sub_str) > max_len: # 子串存在于s2且更长
max_len = len(sub_str)
max_string = sub_str # 更新最长公共子串
print(max_string) # 输出最长公共子串
Demo55 检测密码
题目描述
一些网站会给密码强加一些规则：
（1）密码必须至少有8个字符
（2）密码只能包含英文字母和数字
（3）密码应该至少包含两个数字
（4）密码应该至少包含两个大写字母
如果密码符合规则，输出Yes；否则输出No
输入输出描述
输入一串密码
输出该密码是否符合规则
示例1
输入：
123456ab
输出：
No
示例2
输入：
123abcABC
输出：
Yes
# 检测密码
# 输入密码password
password = input("请输入您的密码:")
# count记录密码的字符个数 countNum记录密码中的数字个数 countA记录密码中大写字母的个数
count = 0
countNum = 0
countA = 0
# 标志flag初始化为ture 如不满足题目四个条件任意一个时，标志为flase
flag = True
# 循环遍历密码
for j in password :
# 获取密码中每个字符的ASCII码值
asc = ord(j)
# 如果是非数字、非字母的字符时，标志变为flase
if asc < 48 or (asc > 57 and asc < 65) or (asc > 90 and asc < 97) or asc > 122 :
# print("有其他字符")
flag = False
# 已判断密码不合规则 退出循环
break
# 如果字符j是数字 则countNum加一
if asc >= 48 and asc <= 57 :
countNum += 1
# 如果字符j是大写字母 则countA加一
if asc >= 65 and asc <= 90 :
countA += 1
# 每次循环count加一
count += 1
# 如果密码的字符数小于8 不符规则 标志为假
if count < 8 :
# print("密码小于八位")
flag = False
# 如果密码的数字字符小于两个 不符规则 标志为假
if countNum < 2 :
# print("少于两个数字")
flag = False
# 如果密码的大写字母字符小于两个 不符规则 标志为假
if countA < 2 :
# print("少于两个大写字母")
flag = False
# 最后对标志进行判断
if flag :
print("Yes")
else :
print("N0")
Demo56 回文素数
题目描述
回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
输出显示前100个回文素数，每行显示10个
# 回文素数
# count 用来记录回文素数的个数
count = 0
# 起始数值为2
n = 2
# while循环找回文素数 找到100个为止
while count < 100 :
# 标志 flag 默认为true
flag = True
for i in range(2,n // 2 + 1) :
if n % i == 0 :
flag = False
break
if flag :
# n转换为字符串n_str
n_str = str(n)
if n_str == n_str[::-1]: # 判断是否为回文数
# 若为回文数 则输出 计数器加一
print(n,end ="\t")
count += 1
# 每输出是个回文素数换行
if count % 10 == 0 :
print()
# 迭代条件 每次循环n加一
n += 1
Demo57 反素数
题目描述
反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
输出显示前100个反素数，每行显示10个
# 反素数
#记录反素数的个数
count = 0
# 起始数值为2
n = 2
# while循环找反素数 找到100为止
while count < 100 :
# 标志 flag 默认为true
flag = True
for i in range(2,n // 2 + 1) :
if n % i == 0 :
flag = False
break
if flag :
# n转换为字符串n_str
n_str = str(n)
if n_str != n_str[::-1]: # 判断是否为回文数
# 逆向拼写
n_f = int(n_str[::-1])
flag_1 = True
for j in range(2,n_f // 2 + 1) :
if n_f % j == 0 :
flag_1 = False
break
# 若为素数 则输出 计数器加一
if flag_1 :
print(n,end ="\t")
count += 1
# 每输出十个反素数换行
if count % 10 == 0 :
print()
# 迭代条件 每次循环n加一
n += 1
Demo58 双素数
题目描述
双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
输出显示小于1000的双素数
# 双素数
# 第一个素数为2
qian = 2
# 从3开始循环判断是否为素数
for n in range(3, 1001) :
# 标志 flag 默认为true
flag = True
for i in range(2,n // 2 + 1) :
# 如果n对i取余为0 则n不是素数
if n % i == 0 :
# 标志变为false
flag = False
# 退出循环
break
# flag为真 则表明n为素数 为假则不是素数
if flag :
# n为素数时
hou = n
# 判断前后两素数的差是否为2
if hou - qian == 2 :
print(qian,hou)
qian = hou
Demo59 梅森素数
如果一个素数可以写成的形式，其中p是某个正整数，那么这个素数就称作梅森素数
输出p≤31的所有梅森素数
# 梅森素数
# p的范围[2,31] 1不可以
for p in range(2,32) :
# 标志flag 用来判断2 ** p - 1是否为素数 每次初始化为true
flag = True
# 判断2 ** p - 1是否为素数
for i in range(2,(2 ** p - 1) // 2 + 1) :
if (2 ** p -1) % i == 0 :
flag = False
break
# 如果2 ** p - 1是素数则输出
if flag :
print(2 ** p - 1)
Demo60 平方根的近似求法
有几种实现开平方的技术，其中一个称为巴比伦法
它通过使用下面公式的反复计算近似地得到：
当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行
编写代码，求解n的平方根的近似值
# 平方根的近似求法
# 输入n 求n的平方根的近似值
n = eval(input("请输入:"))
# lastGuess 的初始值为1
lastGuess = 1
while True :
# 执行巴比伦法
nextGuess = (lastGuess + n / lastGuess) / 2
# 判断nextGuess与lastGuess的差值 如果很小则退出循环
if abs(nextGuess - lastGuess) <= 0.0001 :
break
# 差值较大则nextGuess成为下一次计算的lastGuess 继续执行巴比伦法
lastGuess = nextGuess
# 输出近似值
print(nextGuess)
扫一扫
175
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
