python写着玩

demo1

摄氏温度转化为华氏温度

#摄氏温度转化为华氏温度
celsius = float(input("请输入摄氏度："))
fahrenheit=(9/5)*celsius+32
print("华氏温度是%.1f"%fahrenheit)

 计算圆柱体的体积

#计算圆柱体的体积
radius , length = map( float,input("请输入高和半径，用空格隔开").split( ))
π = 3.14
area=radius*radius*π
volume=area*length
print("圆柱体的面积是%.2f"%area)
print("圆柱体的体积是%.2f"%volume)

 输入英尺数然后将它转换为米数，并输出结果，

# 输入英尺数然后将它转换为米数，并输出结果，
male = float(input("请输入英里数："))
m = male*0.305
print("%f英里等于%.4f米"%(male,m))

  计算小费  

# 计算小费  
Money, Cash = map(float,input("请输入小费和酬金率，用空格隔开：").split())
SmallMoney = Money*Cash/100
print("小费有"+str(SmallMoney))
print("合计%.2f元"%(SmallMoney+Money))

 对一个整数中的各位数字求和

# 对一个整数中的各位数字求和
num = int(input("请输入一个0~1000的数字："))
print("他的各个数之和是："+str(int(num/100)+int(num/10%10)+int(num%10)))

 计算年数和天数

#  计算年数和天数
min = int (input("请输入分钟数："))

print("这是第%d年"%(min/60/24/365))
print("这是第%d天"%(min/60/24%365))

计算能量

# 计算能量
water = float(input("请输入需要加热的水量："))
initialTemperature=float(input("请输入加热前的水量："))
finalTemperature = float(input("请输入要加热到的最终温度："))
Q = water * (finalTemperature - initialTemperature) * 4184
print("加热到%s度需要%.1f焦耳的热量"%(finalTemperature,Q))

输入一个四位整数，并以反向顺序显示

# 输入一个四位整数，并以反向顺序显示
num = int (input("请输入一个四位数："))
print(num%10)
print(int(num/10%10))
print(int(num/100%10))
print(int(num/1000))

计算三角形的面积

# 计算三角形的面积


# 导入math类使用sqrt函数
import math


x1,y1,x2,y2,x3,y3=map(float,input("请输入三角形的顶点坐标，用空格隔开：").split())
side1 = math.sqrt((y1-y2)**2+(x1-x2)**2)
side2 = math.sqrt((x2-x3)**2+(y2-y3)**2)
side3 = math.sqrt((x1-x3)**2+(y1-y3)**2)
s=(side1+side2+side3)/2
area = math.sqrt(s*(s-side1)*(s-side2)*(s-side3))
print("面积是%.1f"%area)

 输入你所在的时区，并输出当前的时间

# 输入你所在的时区，并输出当前的时间

# 从datetime模块导入datetime类和timedelta类(表示时间间隔)
from datetime import datetime,timedelta


place = int(input("请输入时区："))
# 获取当前时间
now = datetime.now()
# 将时间格式化为字符串
time_8= now.strftime("%H:%M:%S")

if place == 8:
  print(time_8)
elif place == -5:
  # 修改时间（将小时加11）
  modified_time = now +timedelta(hours=11) 
  time_5= modified_time.strftime("%H:%M:%S")
  print(time_5)
else:
  print("输入有误重新输入")

计算三角形的三个角

# 输入三角形的三个顶点坐标，并计算该三角形的三个角分别是多少


import math


x1,y1,x2,y2,x3,y3=map(float,input("请输入顶点坐标，用空格隔开：").split())
# 计算三条边长
side1 = math.sqrt( (x1-x2)**2+(y1-y2)**2)
side2 = math.sqrt((x2-x3)**2+(y2-y3)**2)
side3 = math.sqrt((x1-x3)**2+(y1-y3)**2)
# 公式计算（弧度制）
cont1=math.acos((side1**2-side2**2-side3**2)/(-2*side2*side3))
cont2=math.acos((side2**2-side1**2-side3**2)/(-2*side1*side3))
cont3=math.acos((side3**2-side2**2-side1**2)/(-2*side1*side2))
# 将弧度制转化为角度制
angle_1=math.degrees(cont1)
angle_2=math.degrees(cont2)
angle_3=math.degrees(cont3)
print("%.2f\n%.2f\n%.2f\n"%(angle_1,angle_2,angle_3))

兑换最小数量的硬币

#题目 ： 假设硬币种类分为：一元硬币、两角五分硬币、一角硬币、五分硬币、一分硬币
#输入总金额，并将总金额兑换成若干个硬币，并保证所兑换的硬币个数最少


# 兑换最小数量的硬币
money = float(input("请输入金额："))
# 计算一元硬币
yuan = int(money)
print("有%s个一元硬币"%yuan)
# 计算剩下的钱
last = money - yuan
# 计算两角五分的硬币
money2_5 = (last)/0.25
print("有%s个两角五分的硬币"%int(money2_5))
# 更新剩下的钱
last = last - 0.25*int(money2_5)
# 计算一角硬币个数
money1 = last/0.1
print("有%s个一角硬币"%int(money1))
# 再次更新余额
last = last - int(money1)*0.1
# 计算五分硬币个数
money_5 = last/0.05
print("有%s个五分硬币"%int(money_5))
# 更新余额
last= last - int(money_5)*0.05
# 计算一分硬币
money_1 = last/0.01
print("有%s个一分硬币"%int(money_1))

正多边形的面积

#输入两个数据分别表示边的个数n和边的长度s，数据之间用空格分隔
#输出边长为s的正n多边形的面积，结果保留两位小数

import math
π = 3.14
side, lengs = map(float,input("请输入边的个数和长度用空格隔开:").split())
area = (side * lengs**2) / (4 * math.tan(π/side))
print("面积是%.2f"%area)

计算身体质量指数 

# 计算身体质量指数


weight ,high = map(int,input("输入体重和身高，数据之间用空格分隔：").split())
# 体重除以以米为单位的身高的平方
BMI = weight/(high**2)
if BMI<18.5:
  print("超轻")
elif BMI<25.0:
  print("标准")
elif BMI<30.0:
  print("超重")
elif BMI>=30.0:
  print("肥胖")
else:
  print("输入不合法，重新输入")

判定闰年

# 判定闰年
year = int (input("请输入想要知道年分："))
if year%4==0 and year%100!=0 or year%400 == 0:
  print("yes") 
else :
  print("no")

中彩票

# 中彩票


import random


input_num = int (input("输入："))
input_str =  str(input_num)
random_num = random.randint(10,99)
random_str = str(random_num)
print(random_num)
if input_num ==random_num:
  print("10000")
elif random_str[0] ==  input_str[1] and random_str[1] == input_str[0]:
  print("3000")
elif (random_str[0] == input_str[0] or random_str[0] == input_str[1])or(random_str[1] == input_str[0] or random_str[1] == input_str[1]) :
  print("1000")
else:
  print("0")

 解一元二次方程 

# 解一元二次方程
# ax^2+bx+c=0 


import math


a,b,c =  map(float,input("输入：").split())
if a==0:
  print("输入不合法")
elif b**2-4*a*c>0:
#  round(number[, ndigits])----四舍五入保留ndigits位小数
 print( round((-b+math.sqrt(b**2-4*a*c))/(2*a),2))
 print( round((-b-math.sqrt(b**2-4*a*c))/(2*a),2))
  


elif b**2-4*a*c==0:
  print(round((-b)/(2*a),2))

  
elif b**2-4*a*c<0:
  print("无实数解")

解2×2线程方程

# 解2×2线程方程


a,b,c,d,e,f = map(float,input("输入：").split())
# 前提：(ad - bc)不等于0
# x = (ed - bf) / (ad - bc)
# y = (af - ec) / (ad - bc)
if (a*d - b*c) ==0:
  print("无解")
else:
  x = (e*d - b*f) / (a*d - b*c)
  y = (a*f - e*c) / (a*d - b*c)
  print(x,y)

未来是周几

# 未来是周几


week ,future_day = map(int ,input("输入：").split())
day = (week+future_day)%7
if day == 0:
  print("星期天") 
if day == 1:
  print("星期一") 
if day == 2:
  print("星期二") 
if day == 3:
  print("星期三") 
if day == 4:
  print("星期四") 
if day == 5:
  print("星期五") 
if day == 6:
  print("星期六") 

本年中的第几天

year,month,day = map(int,input("输入").split())
# 定义每月的天数表
month_day =[0,31,28,31,30,31,30,31,31,30,31,30,31]
# 判断闰年，并对二月进行加一操作
if (year %4 ==0 and year%100 ==0) or year%400 == 0:
  month_day[2] += 1 
  
for i in range(0 , month):
  day += month_day[i]

print(day)

剪刀石头布

import random


use_num =int( input("输入："))
com_num = random.randint(0,2)
# 定义一个方法：将数字和字符转换，
def vo(num):
  if num ==0:
    return " 剪刀"
  elif num == 1:
    return " 石头"
  elif num ==2:
    return " 布"
  else :
    return 0
    
# 对用户输入数据进行判断
if vo(use_num)==0:
  print("输入不合法")
  
else:
  print("计算机输出"+vo(com_num))
  print("用户出的"+vo(use_num))

  if com_num==use_num:
    print("平手")
  elif (com_num==1 and use_num==0) or(com_num==0 and use_num==2) or (com_num == 2 and use_num == 1):
    print("计算机赢")
  else:
    print("用户赢")

计算三角形的周长

# 输入三角形三边的长度，如果输入合法则计算周长并输出结果；否则输出非法
# 如果任意两边之和大于第三边则输入都是合法的

# 输入三个数据表示三边，数据之间用空格分隔
# 输出三角形的周长，如果非法则输出非法


side1,side2,side3 = map(int,input("输入：").split())
if side1+side2>side3 and side1+side3>side2 and side2+side3>side1:
  print(side1+side2+side3)
else:
  print("非法")

判断一年中某天是星期几

# 判断一年中某天是星期几

# 输入年、月、日三个数据，数据之间用空格分隔
# 输出该日是周几

year,month,day = map(int,input("输入：").split())

# 一月和二月都是按照前一年的13月和14月来计数的，所以还得把年份改为前一年
if month ==1 or month  == 2:
  year-=1
  month+=12
h =int((day+26*(month+1)//10+year%100+year%100//4+year/100//4+5*year/100)%7)
if h == 0:
  print("星期六")
elif h == 1:
  print("星期天")
elif h == 2:
  print("星期一")
elif h == 3:
  print("星期二")
elif h == 4:
  print("星期三")  
elif h == 5:
  print("星期四")
elif h == 6:
  print("星期五")

回文数

# 回文数

# 输入一个三位整数，然后判断其是否为一个回文数
# 如果一个数从左向右和从右向左读取时是一样的，那么这个数就是回文数


# 用户需要判断的数字
num = int (input("输入："))
# num会在后续的操作中改值，所以需要定义一个变量存储num的值
tem =num
# 定义一个变量用于存储反转后的数字
change_num =0
while num >0:
 change_num *= 10
 change_num += num%10
 num //= 10 

if tem == change_num:
  print("yes")
else:
  print("no")

判断两个矩形之间的位置关系

# 判断两个矩形之间的位置关系

# 输入两行，每行四个数据，分别是矩形的中心坐标x、y和矩形的宽、高
# 输出两者的关系


x1,y1,winth1,high1 = map(float ,input("输入").split())
x2,y2,winth2,high2 = map(float ,input("输入").split())
#   包含：如果两个矩形的中心点之间的水平距离小于两个矩形宽度之和的一半，并且垂直距离小于两个矩形高度之和的一半，则两个矩形相交。

# 重叠： 如果一个矩形的中心点到另一个矩形的中心点的水平距离小于两个矩形宽度之差的一半，并且垂直距离小于两个矩形高度之差的一半

# 定义两个函数用于存储中心点的水平距离和垂直距离
level =abs(x1-x2) 
vertical = abs(y1-y2)
# 判断：
if level < (winth1+winth2)/2 and vertical<(high1+high2)/2:
  print("包含")
elif level

demo2

打印数字I

# 利用循环，寻找规律，打印如下数字模式：
#             1
#           2 1 2
#         3 2 1 2 3
#       4 3 2 1 2 3 4
#     5 4 3 2 1 2 3 4 5
#   6 5 4 3 2 1 2 3 4 5 6
# 7 6 5 4 3 2 1 2 3 4 5 6 7

# 用户输入打印的行数
rows = int(input("输入"))


def print_num (row):
  for i in range(1,rows+1):
    print(" "*(row*2-2*i),end="")
    for j in range(i,0,-1):
      print(str(j)+" ",end="")
    for j in range(2,i+1):
      print(str(j)+" ",end="")
    print()  


print_num(rows)

打印数字II

# 利用循环，寻找规律，打印如下数字模式：
      #         1 
      #       1 2 1
      #     1 2 4 2 1
      #   1 2 4 8 4 2 1
      # 1 2 4 8 16 8 4 2 1


# 用户输入需要的层数
row = int(input("输入"))


def print_row (row):
  
  for i in range(1,row+1):
    print(" "*(row*2-2*i),end="")
    num = 1
    for j in range(1,i*2):
 
      if j

打印菱形I

# 输出一个高度为9的菱形

#     *
#    * *
#   * * *
#  * * * *
# * * * * *
#  * * * *
#   * * *
#    * *
#     *


# 用户输入想要打印的层数
row = int (input("输入"))


def print_pic(row):
  for i in range(1,row+1):
    if i

打印菱形II

# 打印空心菱形
#     *    
#    * *   
#   *   *  
#  *     * 
# *       *
#  *     * 
#   *   *  
#    * *   
#     *    

# 用户输入打印的行数
row = int(input("输入"))


def print_pic(row):
  for i in range(0,row):
    if i

打印菱形III

# 打印如下菱形
#     *
#    ***
#   *****
#  *******
# *********
#  *******
#   *****
#    ***
#     *


row = int (input("输入"))


def print_pic(row):
  for i in range(1,row+1):
    if i

 猜数字

# 猜数字

# 计算机随机生成一个[0,100]之间的整数，程序提示用户连续地输入数字直到它与那个随机生成的数字相同
# 对于用户输入的数字，程序会提示它是过高还是过低


import random


computer_random = random.randint(0,101)
person_input = int(input("输入"))
while computer_random != person_input:
  if computer_random>person_input:
    print("低了")
  else:
    print("高了")
  person_input = int(input("输入"))
print(f"猜中了答案就是{person_input}")

最大公约数**辗转相除法**

# 输入两个正整数，计算其最大公约数，例如4和2的最大公约数是2，16和24的最大公约数是8

# 两个正整数a和b(a>b)的最大公约数等于a除以b的余数r和b之间的最大公约数————例如：要找到48和18的最大公约数，可以按照以下步骤进行计算：
# 48 ÷ 18 = 2 余 12
# 18 ÷ 12 = 1 余 6
# 12 ÷ 6 = 2 余 0

num1,num2 =map(int,input("输入").split())


def gcd(num1, num2):
    if num2 == 0:
        return num1
    else:
        return gcd(num2, num1 % num2)
    

print(gcd(num1,num2))

判断素数**试除法**

# 判断素数


import math


num = int(input("输入"))


# 方法一
def prime_1 (num):
  if num<2:
    return False
  else:
    for i in range(2,int(math.sqrt(num)+1)):
      if num % i == 0:  
        return False
    return True
  

#-------------------------------------------------------------------------------------


# 方法二（试除法，速度更快）：
def prime_2(num):
  if num < 2:
    return False 
  elif num == 2 or num == 3:
    return True
  elif num % 2 == 0 or num %3 == 0:
      return False
    
  sqrt_num =int( math.sqrt(num))
  k = 1
  while 6 * k - 1 <= sqrt_num:   
    if num % (k * 6 -1) == 0 or num %( k * 6 + 1) == 0: 
      return False
    k += 1
  return True


flag = prime_1(num)
if flag:
  print("yes")
else:
  print("no")  

最小公倍数

# 输入两个正整数，计算其最小公倍数，例如4和2的最小公倍数是4，3和5的最小公倍数是15

# 两个数的乘积等于这两个数的最大公约数和最小公倍数的乘积

num1 ,num2 = map(int,input("输入").split())


def gcd(num1,num2):
  """
  求最小公倍数的函数
  """
  while num1:
    return gcd(num2%num1,num1)
  else:
    return num2


def lcm(num1,num2):
  """
  求最大公约数
  """
  return num1*num2//gcd(num1,num2)


print(lcm(num1,num2))

整数的素因子

# 输入一个正整数，然后找出它所有的最小因子，也称之为素因子


num = int(input("输入"))


def prime(num):
  """
  求素因子
  """
  arr=[]
  i = 2
  while i * i <= num :
    if num % i == 0:
      arr.append(i)
    else:
      i += 1
  if num > 1 :
    arr.append(num)
  return arr


print(prime(num))

完全数

# 如果一个正整数等于除了它本身之外所有正因子的和，那么这个数称为完全数


num = int(input("输入"))


def perfect_num (num):
  sum = 1
  for i in range (2,num//2+1):
    if num % i == 0:
      sum += i
  if num == sum:
    return True
  else:
    return False


if perfect_num(num):
  print("yes")
else:
  print("no")

前50个素数

# 打印前50个素数，每打印10个素数换行
import math


arr = []


def prime_num (num):
  if num<2:
    return False
  elif num == 2 or num == 3:
    return True
  elif num %2 == 0 or num%3 == 0:
    return False
  
  sqrt_num = int(math.sqrt(num))
  i = 1
  while 6* i -1 <=sqrt_num:
    if num%(6* i -1 )==  0 or num %(6*i +1) == 0:
      return False
    i+=1
  return True


num = 2
i = 1
while i <51:
  if prime_num(num):
    arr.append(num)
    i+=1
  num+=1

i = 1
while i <= 50:
  
  print(str(arr[i-1])+" ",end="")
  if  i % 10 == 0:
    print()
  i+=1

计算π

# 计算π

i = int (input("输入"))


def get_π(i):
  num = 0
  for i in range(1,i+1):
   num +=  (-1)**(i+1)/(2*i-1)
  num *= 4
  return num


print(get_π(i))

修改猜拳游戏

# 延伸【Demo21剪刀石头布I】的问题，利用循环将程序改为，计算机和电脑谁先赢三次，谁就是终极胜利者


import random

count_use = 0
count_com = 0
while True:
  use_num =int( input("输入："))
  com_num = random.randint(0,2)
  # 定义一个方法：将数字和字符转换，
  def vo(num):
    if num ==0:
      return " 剪刀"
    elif num == 1:
      return " 石头"
    elif num ==2:
      return " 布"
    else :
      return 0
      
  # 对用户输入数据进行判断
  if vo(use_num)==0 :
    print("输入不合法")
    continue
    
  else:
    print("计算机输出"+vo(com_num))
    print("用户出的"+vo(use_num))
  
    if com_num==use_num:
        print("平手")
    elif (com_num==1 and use_num==0) or(com_num==0 and use_num==2) or (com_num == 2 and use_num == 1):
        count_com += 1
        print("计算机赢"+str(count_com)+"回")
      
    else:
        count_use +=1
        print("用户赢了"+str(count_use)+"回")
      
    if count_use ==3:
        print("用户获得了胜利")
        break
    elif count_com == 3:
        print("电脑获得了胜利")
        break

数字组合问题

# 组合问题

# 在数字范围[1,7]之间，任意选择两个不相同的数作为一个组合
#，输出每一组组合，并统计所有组合的个数
# 注：组合（a，b）与组合（b，a）算同一种组合，只记录一次

arr = [1,2,3,4,5,6,7]
count = 0
for i in range(1,7):
  for j in range(2,8):
    if i != j:
      print(f"[{i} {j}]",end="")
      count +=1
print(f"共有{count}个组合")

# 组合问题II

# 组合问题II

arr =[1,2,3,4]

count = 0
for i in range(1,len(arr)-1):
  for j in range(2,len(arr)):
    for p in range(3,len(arr)+1):
      if i!=j and j != p:
        print(f"[{i} {j} {p}]",end="")
        count += 1
print("\n"+str(count))

水仙花数

# 水仙花数，是一个三位数，且这个数的个位、十位和百位的立方和等于该数字本身


def get_num(num):
  if (num%10)**3+(num//100)**3+(num//10%10)**3 == num:
    return True
  else:
    return False


for i in range(100,1000):
  if get_num(i):
    print(i)
  

青蛙跳台阶

# 一只青蛙，一次可以跳一个台阶或者两个台阶，现有n个台阶，问该青蛙有多少种不同的跳法？


step = int (input("输入"))


def get_way (step):
  if step %2 != 0:
    step -= 1
  most_step = step
  less_step = step//2
  count = 0
  count = most_step - less_step + 1
  return count


print(get_way(step))

堆叠相加

# 现有堆叠相加模式 a+aa+aaa+aaaa+aaaaa+......

# 输入两个数据分别为数字a和组数n
# 输出按照堆叠相加模式算出的和


num , group = map(int ,input("输入").split())


def get_num(num,group):
  sum = 0
  for i in range(1,group+1): 
    sum += int(str(num)*i)
  return sum
  

print(get_num(num,group))

十进制转二进制

# 输入一个十进制正整数，输出其二进制形式


num = int (input("输入"))


def change_num(num):
  str_num = ''
  num_changed = 0
  while num > 0:
    ge = num % 2
    num //= 2
    str_num += str(ge)
  for i in range(len(str_num)-1,-1,-1):
    num_changed *= 10
    num_changed += int(str_num[i])
  return num_changed


print(change_num(num))

二进制转十进制

# 二进制转十进制


num = int(input("输入"))


def change_num (num):
  all = 0
  str_num = str(num)
  for i in range(0,len(str_num)):
    all += int(str_num[i])
    if i == len(str_num)-1: 
      return all
    all *= 2 



print(change_num(num))

十进制转十六进制

# 十进制转十六进制


num = int(input("输入："))


def change_num(num):
  ox_num = "0123456789ABCDEF"
  fin_num = ""
  while num > 0:
    get_num = num % 16
    num //= 16
    fin_num = ox_num[get_num] + fin_num  
  return fin_num


print(change_num(num))
      
    

十六进制转十进制 

# 十六进制转十进制


num = str(input("输入："))


def change_num(num):
  ox_num = "0123456789abcdef"
  all = 0
  len_num = len(num)
  for j in num:
    for i in ox_num:
      if i == j:
        all += ox_num.index(i)* 16 ** (len_num-1)
        len_num -= 1
  return all
  

print(change_num(num))
        

最长公共前缀**zip**

# 给定两个字符串 s1 和 s2 ，求两个字符串最长的公共前缀串，字符区分大小写


str1 = str(input("输入"))
str2 = str(input())



def judge_str (str1,str2):
  new_str = ""
  
  for i,j in zip(str1,str2):
# zip() 函数来同时遍历两个字符串。
# 如果两个字符串的长度不相等，zip() 函数将会以较短的字符串为准，忽略超过其长度的部分。
    if i == j :
      new_str += i
    else:
      break
  return new_str


print(judge_str(str1,str2))

子串出现的次数

# 给定两个字符串 s1 和 s2 ，求 s2 在 s1 中出现的次数，
#字符区分大小写，已匹配的字符不计入下一次匹配


str1 = str(input("输入"))
str2 = str(input("输入"))


def judge_str(str1,str2):
  count = 0
  index_str1 = 0
  while index_str1 <= len(str1)-len(str2) :
      flog = True
      tem = index_str1
      for i in str2:
        if str1[tem] == i:
          tem += 1
        else:
            index_str1 += 1
            flog = False
            break
      if flog:
        count += 1
        index_str1 += len(str2)
      
  return count

      
print(judge_str(str1,str2))

 最长公共子串**todo**

Todo

检测密码

# 一些网站会给密码强加一些规则：
# （1）密码必须至少有8个字符
# （2）密码只能包含英文字母和数字
# （3）密码应该至少包含两个数字
# （4）密码应该至少包含两个大写字母
# 如果密码符合规则，输出Yes；否则输出No


s1 = str(input("输入"))


def string_pass(s1):
  get_num = 0
  get_capital = 0
  if len(s1)<8:
    return "no"
  for i in s1:
    if ord(i)<48 or 57122:
      return "no"
    if 47

回文素数

# 回文素数是指一个数既是素数又是回文数，例如131既是素数也是回文数
# 输出显示前100个回文素数，每行显示10个


import math


# 找素数的函数
def find_prime(num):
  if num < 2 :
    return False
  if num == 2 or num == 3:
    return True
  elif num % 2 == 0:
    return False
  elif num % 3 == 0:
    return False
  
  sqrt = int(math.sqrt(num))
  i = 1
  while (6*i-1) < sqrt :
    if num % (6*i-1) == 0 or num % (6*i+1) == 0:
      return False
    i += 1
  else:
      return True
  

# 找回文数
def find_palindromic(num):
  str_num = str(num)
  i = 0
  j = len(str_num)-1
  while i < j:
    if str_num[i] != str_num[j]:
      return False
    i += 1
    j -= 1
  return True  

i = 100
count = 0
while count < 100:
  if find_prime(i) and find_palindromic(i):
    print(str(i) +" ",end="")
    count += 1
    if count % 10 == 0:
      print()
  i += 1

反素数**切片：slice**

# 反素数是指一个将其逆向拼写后也是一个素数的非回文数，例如17和71都是素数但不是回文数，且反转后依旧是素数
# 输出显示前100个反素数，每行显示10个


import math


# 质数
def is_prime(num):
  if num<2:
    return False
  if num == 2 or num ==3:
    return True
  if num % 2 == 0 or num % 3 == 0:
    return False
  
  sqrt_num =int(math.sqrt(num))
  k = 1
  while (6*k-1)

双素数

# 双素数是指一对差值为2的素数，例如3和5就是一对双素数，5和7也是一对双素数
# 输出显示小于1000的双素数


import math


# 质数
def is_prime(num):
  if num<2:
    return False
  if num == 2 or num ==3:
    return True
  if num % 2 == 0 or num % 3 == 0:
    return False
  
  sqrt_num =int(math.sqrt(num))
  k = 1
  while (6*k-1)

梅森素数

# 如果一个素数可以写成2**p-1的形式，其中p是某个正整数，那么这个素数就称作梅森素数
# 输出p≤31的所有梅森素数


import math


# 质数
def is_prime(num):
  if num<2:
    return False
  if num == 2 or num ==3:
    return True
  if num % 2 == 0 or num % 3 == 0:
    return False
  
  sqrt_num =int(math.sqrt(num))
  k = 1
  while (6*k-1)

平方根的近似求法

# 平方根的近似求法
#方法：nextGuess=(lastGuess+n/lasetGuess)/2
#当nextGuess和lastGuess几乎相同时，nextGuess就是平方根的近似值
#lastGuess初始值为1，如果nextGuess和lastGuess的差值小于一个很小的数，比如0.0001，就可以认为#nextGuess是n的平方根的近似值；否则，nextGuess成为下一次计算的lastGuess，近似过程继续执行


n = eval(input("输入"))


def get_num(n,last_guess):

  nextguess = (last_guess+n/last_guess)/2
  if abs(nextguess - last_guess) <0.0001:
    return (nextguess)
  else: 
    return get_num (n,nextguess)
  

print(get_num(n,1))