python基础3

最新推荐文章于 2022-11-23 10:55:22 发布

chentao326

最新推荐文章于 2022-11-23 10:55:22 发布

阅读量798

点赞数

分类专栏： python 大数据文章标签： Python 大数据算法

本文链接：https://blog.csdn.net/chentao326/article/details/102947536

版权

python 同时被 2 个专栏收录

7 篇文章 2 订阅

订阅专栏

大数据

4 篇文章 0 订阅

订阅专栏

基础题

1、 问题描述：如果某个数的平方的末尾数等于这个数，就称这个数为自守数。请编写程序求1~10000以内的自守数,例如，5和6是一位自守数(5 x 5 = 25, 6x6 = 36);因为25x25=625,76x76=5776,所以25和76是两位的自守数。

算法分析：自守数是指一个数的平方的尾数等于该数自身的自然数。所以只要判断乘积的末尾是否等于它的根即可

具体实现：

for i in range(1,10001):
    num = i*i
    #print(i,num%100)
    if num%10 ==i:
        print('{}是自守数'.format(i))
    elif num%100 ==i:
        print('{}是自守数'.format(i))
    elif num%1000==i:
        print('{}是自守数'.format(i))
    elif num%10000==i:
        print('{}是自守数'.format(i))

结果展示：

1是自守数
5是自守数
6是自守数
25是自守数
76是自守数
376是自守数
625是自守数
9376是自守数

2、 问题描述：某古寺的-块石碑上依稀刻有一些神秘的自然数。专家研究发现:这些数是由1.3.5.7. 9这5个奇数排列组成的5个素数，同时去掉最高位与最低位数字后的3位数还是素数,同时去掉高二位和低位数字后的1位数还是素数。因此人们把这些神秘的素数称为金蝉素数，萬意金蝉脱壳之后仍为美丽的金蝉。请编写程序求出石碑上的金蝉素数。注:必须包含使用高阶函数的reduce.

算法分析：先定义函数判断是否是素数，在1，3，5，7，9中进行排列，利用reduce把排列完的数字组合起来，判断是否是素数，如果是转换成字符，用切片选择，同样的重复几次

具体实现：

import itertools
from functools import reduce

def ifprime(num):  
    # 质数大于 1
    if num > 1:
   # 查看因子
        for i in range(2,num):
           if (num % i) == 0:
                return False
                break
        else:
            return True
    # 如果输入的数字小于或等于 1，不是质数
    else:
        return False
num5=[]
for i in itertools.permutations([1,3,5,7,9],5):#13579进行排列
    n=reduce(power,i)
   # print(n)
    if ifprime(n):
        n3=int(str(n)[1:4])
        if ifprime(n3):
            n1=int(str(n)[2])
            if ifprime(n1):
                print(n)

结果展示：

3、 问题描述：编写程序找出 1~900的所有可逆素数,所谓可逆素数是指一个素数的各位数值顺序颠

倒后得到的数仍为素数。例如: 113, 311.

算法分析：将数字拆开，按题目要求重新组合，再判断是否是素数

具体实现：

def ifprime(num):  
    # 质数大于 1
    if num > 1:
   # 查看因子
        for i in range(2,num):
           if (num % i) == 0:
                return False
                break
        else:
            return True
    # 如果输入的数字小于或等于 1，不是质数
    else:
        return False


s=[]
for i in  range(1,901):
    if ifprime(i):
        if i <10:
            s.append(i)      
        elif i>=10 and i<100:
            a=i//10#十位
            b=i%10#个位
            num=b*10+a
            if ifprime(num):
                s.append(i)
        elif i>=100 and i<901:
            a=i//100
            b=i//10%10
            c=i%10
            num=c*100+b*10+a
            if ifprime(num) and num<900:
                s.append(i)
print(s)

结果展示：

[2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97, 101, 107, 113, 131, 151, 157, 167, 181, 191, 311, 313, 337, 347, 353, 373, 383, 701, 727, 733, 743, 751, 757, 761, 787, 797]

4、 问题描述：分子是1 的分數，叫单位分数。古代埃及人在进行分数运算时，只使用分子是1的分数,因此这种分数也叫作埃及分数式，或者叫单分子分数.请编写程序实现，要求输入4和7,将该分数分解为埃及分数式，例如: 3/7=1/3+1/11+1/231.

算法分析：首先获取到分子，分母。接着要获取到分数的最大分解式，ceil（）取上，用倒数的方法获取最大分解式的分母，重复几次，直到最大分解式的分母<=0

具体实现：

import math
a=int(input('输入分子:'))
b=int(input('输入分母:'))
n=a/b
s='%d/%d='%(a,b)
while n > 0:
    c=math.ceil(round(1/n,9))
    s+='1/%d+'%(c)
    n=n-1/c
s=s[:-1]
print(s)

结果展示：

输入分子:4
输入分母:7
4/7=1/2+1/14

5、 问题描述：请编写程序对 123124324324134334这个正整数分解质因数.例如输入: 90,输出:90=233*5.

算法分析：首先获取到要进行分解质因数的数i，接着定义一个函数，在（2，i）之间循环，如果能被整除就打印，然后重复调用这个函数，递归输出完成

具体实现：

i=int(input("请输入一个正整数："))
print("%d="%i,end="")
def index(i):   
    for k in range(2,i):
        if i%k==0:
            print(k,end="*")
            return(index(i//k))
    print('{}'.format(i))

index(i)

结果展示：

请输入一个正整数：123124324324134334
123124324324134334=2*293*313*362107*1853809

6、 问题描述：在观赏鱼购买市场有一 -鱼商将养的一缸灯笼鱼分5次出售，第- -次卖出全部的-半加1/2条;第二次卖出余下的三分之-加1/3条;第三次卖出余下的四分之- -加 1/4条; 第四次卖出余下的五分之-加1/5条;最后卖出余下的11条。求编写程序求出鱼缸中共有多少条灯笼鱼以及前四次卖出了多少条和剩余多少条。

算法分析：根据题意列出关系式：设每次卖出的数量分别为x1，x2，x3，x4，x5，和原来有x1

x2=x1-1/2x1-1/2
x3=x2-1/3x2-1/3
x4=x3-1/4x3-1/4
…
表达式是：
$xi={x}_{i-1}-\frac{1}{i}x_{i-1}-\frac{1}{i}（i是次数）$

具体实现：

x5=11
x4=(5*x5+1)/4
x3=(4*x4+1)/3
x2=(3*x3+1)/2
x1=(2*x2+1)/1
n1=x1-x2
n2=x2-x3
n3=x3-x4
n4=x4-x5
print('原来有%d条鱼，第一次卖了%d条，剩余%d条，第二次卖了%d条，剩余%d条，第三次卖了%d条，剩余%d条，第四次卖了%d条，剩余%d条'%(x1,n1,x2,n2,x3,n3,x4,n4,x5))

结果展示：

原来有59条鱼，第一次卖了30条，剩余29条，第二次卖了10条，剩余19条，第三次卖了5条，剩余14条，第四次卖了3条，剩余11条

7、 问题描述：有紫，青橙3种颜色的球，其中紫球3个、青球3个、橙球6个.现将这12个球混

放在一一个盒子中,从中任意摸出8个球。请使用编程计算摸出的球的各种颜色配搭对应的数量

算法分析：把球按颜色编号放入列表，用sample随机选出8个，遍历这个新的列表，匹配颜色，并计数

具体实现：

from random import sample
ball=['p1','p2','p3','c1','c2','c3','o1','o2','o3','o4','o5','o6']
i=sample(ball,8)
countp=0
countc=0
counto=0
print(i)
for j in i:
    if j[0]=='p':
        countp+=1
    elif j[0]=='c':
        countc+=1
    elif j[0]=='o':
        counto+=1
print('紫色：',countp,'青色：',countc,'橙色：',counto)

结果展示：

['o6', 'p2', 'c2', 'p3', 'p1', 'o3', 'o5', 'o1']
紫色： 3 青色： 1 橙色： 4

1、 问题描述：凯撒密码是一种代换密码机制，据说凯撒是率先使用加密函的古代将领之一, 因此这种加密方法被称为凯撒密码。凯撒密码作为-一种最为古老的对称加密机制，在古罗马的时候就已经很流行，基本思想是:通过把字母移动-定的位数来实现加密和解密。明文中的所有字母都在字母表中向后(或向前)按照固定数目进行偏移后,被替换为密文。例如，当偏移量是3的时候，所有的字母A将被替换为D, B变成E,依次类推，X将变成A, Y变成B、Z变成C.由此可见，位数就是凯撒密码加密和解密的密钥。请编写程序对明文: I LOVE YOU进行加密，然后进行解密查看结果。密钥值为12。

算法分析：利用ascll码的数值加减进行加解密的工作。获取到原文和秘钥，转换成ascll码，判断空格的出现，出现就保留，在N前的只要加12，O-Z的减去14，解密只要反过来就行了

具体实现：

import itertools
from functools import reduce
s=input('输入原文')
key=eval(input('输入密钥'))
n=[]
for i in s:
    i=ord(i)
    if i==32:
        n.append(chr(i))
    if i>=65 and i<=76:
        i+=key
        n.append(chr(i))
    elif i>76 and i<=90:
        i-=(26-key)
        n.append(chr(i))
m=reduce(lambda x, y: x+y,n)
m

结果展示：

输入原文I LOVE YOU
输入密钥12
'U XAHQ KAG'

具体实现：

import itertools
from functools import reduce
q=input('输入密文')
key2=eval(input('输入密钥'))
nr=[]
for i in q:
    i=ord(i)
    if i==32:
        nr.append(chr(i))
    if i>=77 and i<=90:
        i-=key2
        nr.append(chr(i))
    elif i>=65 and i<=76:
        i+=(26-key2)
        nr.append(chr(i))
h=reduce(lambda x, y: x+y,nr)
h

结果展示：

输入密文U XAHQ KAG
输入密钥12
'I LOVE YOU'

2、 问题描述：有一个迷宫，入口已知在第2行左边位置.问是否有路径从入口到出口，若有，则输出一条这样的路径。注意移动可以从上、左、右、下上左、上右、下左、下右八个方向进行。0表示可走，1表示墙，能通的位置使用2替换掉0表示路通。请编写程序用解的可视化复原迷宫路径。以下是迷宫的数据:

[
[1,1,1,1,1,1,1,1,1,1],
[0,0,1,0,1,1,1,1,0,1],
[1,1,0,1,0,1,1,0,1,1],
[1,0,1,1,1,0,0,1,1,1],
[1,1,1,0,0,1,1,0,1,1],
[1,1,0,1,1,1,1,1,0,1],
[1,0,1,0,0,1,1,1,1,0],
[1,1,1,1,1,0,1,1,1,1]  
]

算法分析：定义检测函数，检测，x,y的坐标，定义出口坐标，当到出口是结束循环，定义路线的函数，按顺序检测周围八个方向是否有可走的地方，有则放入栈里，然后检测是否符合条件，符合的改变数值变成2，然后，在掉用函数看下一个值在哪，做完在判断是否到出口，到了就停止循环，没到会就回溯继续，并出栈。

具体实现：

s = [[1,1,1,1,1,1,1,1,1,1],
    [0,0,1,0,1,1,1,1,0,1],
    [1,1,0,1,0,1,1,0,1,1],
    [1,0,1,1,1,0,0,1,1,1],
    [1,1,1,0,0,1,1,0,1,1],
    [1,1,0,1,1,1,1,1,0,1],
    [1,0,1,0,0,1,1,1,1,0],
    [1,1,1,1,1,0,1,1,1,1]]

directions=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
way=[]
print('输入起点：')
a=eval(input())
b=eval(input())
print('输入终点：')
zx=eval(input())
zy=eval(input())
s[a][b]=2
#x,y
def conflict(x,y):
    if 0 <= x and x< 8 and 0 <= y and y<10 and s[x][y]==0:
        return True
    return False
#定义检测函数，检测，x,y的坐标

def isexit(i,j):
    global zx,zy
    if  s[zx][zy]==2 :
        return True
    return False
 #检测出口   
def path(m,n):
    global way
    for d in directions:#遍历方向列表，按序审核检测
        nx,ny=m+d[0],n+d[1]#表示方位的坐标
        way.append((nx,ny))
        if conflict(nx,ny):#检测坐标是否合适
            s[nx][ny]=2
            path(nx,ny)
            if isexit(nx,ny):
                break
            s[nx][ny]=0
        way.pop()
path(a,b)
s

结果展示：

输入起点：
1
0
输入终点：
7
5
[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [2, 2, 1, 2, 1, 1, 1, 1, 0, 1],
 [1, 1, 2, 1, 2, 1, 1, 0, 1, 1],
 [1, 0, 1, 1, 1, 2, 0, 1, 1, 1],
 [1, 1, 1, 2, 2, 1, 1, 0, 1, 1],
 [1, 1, 2, 1, 1, 1, 1, 1, 0, 1],
 [1, 0, 1, 2, 2, 1, 1, 1, 1, 0],
 [1, 1, 1, 1, 1, 2, 1, 1, 1, 1]]

chentao326

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
python基础3

基础题1、问题描述：如果某个数的平方的末尾数等于这个数，就称这个数为自守数。请编写程序求1~10000以内的自守数,例如，5和6是一位自守数(5 x 5 = 25, 6x6 = 36);因为25x25=625,76x76=5776,所以25和76是两位的自守数。算法分析：自守数是指一个数的平方的尾数等于该数自身的自然数。所以只要判断乘积的末尾是否等于它的根即可具体实现：f...
复制链接

扫一扫