基础练习题目

qq_40832034

已于 2022-03-25 17:15:37 修改

阅读量200

点赞数 1

文章标签： python 算法

于 2022-02-23 14:08:04 首次发布

本文链接：https://blog.csdn.net/qq_40832034/article/details/123085538

版权

蓝桥杯python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.1 Fibonacci数列

Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
说明：
在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

n = int(input())
Fib = [1 for i in range(n+1)]  ##生成一个包含n个1的列表
k=3
while k<=n:
    Fib[k]=(Fib[k-2]+Fib[k-1])%10007
    k=k+1
print(Fib[n])

1.2 圆的半径

题目：给定圆的半径r，求圆的面积。

import math
r=int(input())
PI= math.atan(1.0) * 4
area=PI*r*r
print('%.7f'% area)

保留小数点后面多少位
print（'%.7f'%area）

1.3序列求和

问题：求1+2+3+…+n的值。
输入：包括一个整数n。
输出：一行，包括一个整数，表示1+2+3+…+n的值。
1 <= n <= 1,000,000,000

说明：请注意这里的数据规模。
本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。
本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。

n=int(input())
s=(1+n)*n/2
print(int(s))

print('%d',s)

1.4 A+B

问题：输入的第一行包括两个整数，由空格分隔，分别表示A、B。
输入：输入的第一行包括两个整数，由空格分隔，分别表示A、B。
输出：输出一行，包括一个整数，表示A+B的值。
-10000 <= A, B <= 10000。

A,B=input().split()
A=int(A)         #①
B=int(B)
print(A+B)

input().split()用法
input() 接收多个用户输入需要与split()结合使用

A,B=input().split()

注意返回的数据类型是str，如果是整数需要转化为int才可正常使用
A,B转换为整数型的也可以用map方法
map(函数，序列)

A,B=map(int,input().split())

1.5十六进制转八进制

题目：给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由0_{9、大写字母A}F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式
　　输出n行，每行为输入对应的八进制正整数。

【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

进制转化内容：https://www.cnblogs.com/baxianhua/p/9896926.html

n=int(input())
for i in range(n):
    m=input()
    m=int(m,16)           #int('',16)    将16进制整数字符串转为十进制
    print(format(m,'o'))              #将十进制转为八进制并省略前导o

注意：
int(’ ',16) 将16进制整数字符串转为十进制
format(m,‘o’)) 将十进制m转为八进制并省略前导o
format()函数可以让进制转换后省略前导
如果是需要前导的话就不用format()函数，用进制转换的函数，
注意函数中必须是int类型
在这里就是


n=int(input())
for i in range(n):
    m=input()
    m=oct(int(m,16))
    print(m)

输出就是带0o前导的

1.6十六进制转十进制

问题描述
　　从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
　　注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。
样例输入
FFFF
样例输出
65535

n=input()
print(int(n,16))

1.7 十进制转换为十六进制

问题描述
　　十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
　　给出一个非负整数，将它表示成十六进制的形式。
　　
输入格式
　　输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
输出格式
　　输出这个整数的16进制表示
样例输入
30
样例输出
1E

n=input()
print(format(int(n),'X'))   #xs输出字母为小写，X输出字母为大写

注意format（，）中的“，”前面必须是int()类型

1.8 特殊回文数

1.9 回文数

问题描述
　　1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
　　
输出格式
　　按从小到大的顺序输出满足条件的四位十进制数。

i=1000
def is_hw(i):
    i=str(i)
    if i==i[::-1]:  ##a[i:j:k],i起始，到j-1，步长为k
        return True
    else:
        return False

while i<10000:
    f=is_hw(i)
    if f:
        print(i)
    i=i+1

（遍历）

2.0 水仙花数

在这里插入图片描述

i=100
def is_sx(ii):
    one=int(ii/100)          ##这里注意python中除法会得到小数，必须取整
    two=int(ii%100/10)
    three=(ii%100)%10
    if one**3+two**3+three**3==int(ii):
        return True
    else:
        return False

while(i<1000):
    if is_sx(i):
        print(i)
    i=i+1

2.1杨辉三角形

问题描述
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。　　
它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
下面给出了杨辉三角形的前4行：

1
1 1　　
1 2 1　　
1 3 3 1　
给出n，输出它的前n行。
输入格式
输入包含一个数n。
输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1
数据规模与约定
1 <= n <= 34。

n=int(input())
k=2
tra=[]                 ##空的杨辉三角
for i in range(n):
    tra.append([0 for j in range(i+1)])    ##赋值为零
for i in range(n):
    tra[i][0]=tra[i][-1]=1            ##每行第一个和最后一个都是1
while k<n:
    i=1
    while i<k:
        tra[k][i]=tra[k-1][i-1]+tra[k-1][i]        ##三角形中的每个数字等于它两肩上的数字相加
        i=i+1
    k=k+1
for i in range(n):
    for j in range(i+1):
        print(tra[i][j],end=' ')
    print()

2.2 查找整数

问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

输入格式
第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。

输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。

n=int(input())
ls=list(input().split())
m=int(input())
fl=False
for i in range(n):
    if int(ls[i])==m:
        print(i+1)
        fl=True
        break
if fl==False:
    print("-1")

2.3数列特征

问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。
输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5
1 3 -2 4 5
样例输出
5
-2
11
数据规模与约定
1 <= n <= 10000。

n=int(input())
ls=list(map(int,input().split()))        #如果是list(input().split())会报错，字符串
print(max(ls))
print(min(ls))
print(sum(ls))

2.4字母图形

问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式
输出n行，每个m个字符，为你的图形。

样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。

n,m=map(int,input().split())
ls=[[0 for j in range(m)] for i in range(n)]     #先插入列的
#ls=[]不对，要初始化一个二维的;;ls=[0 for i in range(n) for j in range(m)]也不对
for i in range(n):
    for j in range(m):
        if i ==j:
            ls[i][j]='A'
        if i>j:
            ls[i][j]=chr(ord('A')+i-j)
        if i<j:
            ls[i][j]=chr(ord('A')+j-i)
for i in range(n):
    for j in range(m):
        print(ls[i][j],end=' ')
    print()

2.5 字符01

问题描述
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。

输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>

for i in range(32):
    print("{:0>5b}".format(i))  #冒号前面可以加序号，是后面的位置的索引，0表示用0填充，>表示右对齐，5表示宽度，b是将十进制i转化为二进制

format

2.6闰年判断

问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：

年份是4的倍数而不是100的倍数；
年份是400的倍数。
其他的年份都不是闰年。

输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。

y=int(input())
if y%400==0 or y%4==0 and y%100!=0 :
    print("yes")
else:
    print("no")

2.7 阶乘计算

在这里插入图片描述

n=int(input())
def jie(n):
    while n>1:
        return jie(n-1)*n
    return 1
print(jie(n))

但是数据过大时用递归会超时，用循环

n=int(input())
s=1
while n>1:
    s=s*n
    n=n-1
print(s)

2.8长整数相加

在这里插入图片描述

a=input()
b=input()
def zer(a,l):
    a='0'*(l-len(a))+a
    return a

if len(a)>len(b):
    b = zer(b,len(a))

else:
    a = zer(a,len(b))


result=[0 for i in range(len(a)+1)]
k=0
for i in range(len(result)-1):
    result[len(result)-i-1]=int(a[len(a)-i-1])+int(b[len(b)-i-1])+k
    if result[len(result)-i-1]>9:
        result[len(result)-i-1]= result[len(result)-i-1]%10
        k=1
    else:
        k=0

if k!=0:
    result[0]=k
    for i in range(len(result)):
        print(result[i],end='')

elif k==0:
    for i in range(len(result)-1):
        print(result[i+1],end='')

注意这边本来是通过一个函数对长度不够的字符串进行补0的，但是在函数中，想在函数中对形参进行修改达到对传过来的实参进行修改的目的是失败的，因为村存在使用域问题，任意想修改形参的情况都会被视为定义了一个新的参数，比如下面
在这里插入图片描述
这里第三行的a是一个新定义的局部参数，没用到，灰色
形参也没有对其进行操作，灰色
输出a还是3
所以尽量少用函数

2.9哈夫曼树

在这里插入图片描述


#哈夫曼树
n=int(input())
a=list(map(int, input().split()))
z=0
while n>1:
    p=min(a)
    a.remove(p)
    q=min(a)
    a.remove(q)
    s=p+q
    z+=s
    a.append(s)
    n=n-1
print(z)

3.0 N皇后问题

pass

3.1 报时助手

在这里插入图片描述

m,n=map(int,input().split())
a=[[] for i in range(m)]
col=0
row=0
count=0
for i in range(m):
    arr=list(map(int,input().split()))
    for j in range(len(arr)):
        a[i].append(arr[j])

while count<m*n:
    while row<m and a[row][col]!=-1:
        print(a[row][col],end=' ')
        a[row][col]=-1
        row=row+1
        count=count+1
    row-=1
    col+=1
    while col<n and a[row][col]!=-1:
        print(a[row][col],end=' ')
        a[row][col] = -1
        col+=1
        count+=1
    col-=1
    row-=1
    while row>=0 and a[row][col]!=-1:
        print(a[row][col],end=' ')
        a[row][col] = -1
        row-=1
        count+=1
    row+=1
    col-=1
    while col>=0 and a[row][col]!=-1:
        print(a[row][col],end=' ')
        a[row][col] = -1
        col-=1
        count+=1
    col+=1
    row+=1

这里注意手动输入构造二维数组的方式

3.2龟兔赛跑预测

3.3芯片测试

在这里插入图片描述

n=int(input())
a=[[] for i in range(n)]
f=[True for i in range(n)]
for i in range(n):
    arr=list(map(int,input().split()))
    for j in range(n):
        a[i].append(arr[j])

for i in range(n):
    count=0
    for j in range(n):
        if a[j][i]==0:          #注意这里不是a[i][j]
            count+=1
    if count>n/2:
        f[i]=False
for i in range(n):
    if f[i]==True:
        print(i+1,end=' ')

3.4FJ字符串

在这里插入图片描述

n=int(input())
a=[0 for i in range(n)]
a[0]='A'
for i in range(n-1):
    a[i+1]=a[i]+chr(ord('A')+i+1)+a[i]
print(a[n-1])

矩阵乘法

在这里插入图片描述

n,m=map(int,input().split())
a=[[] for i in range(n)]
p=[[0 for i in range(n)] for i in range(n)] ##注意二阶矩阵的初始化
for i in range(n):
    arr=list(map(int,input().split()))
    for j in range(n):
        a[i].append(arr[j])
for i in range(n):
    for j in range(n):
        p[i][j]=a[i][j]
def c(ca):
    b=[[0 for i in range(n)] for i in range(n)]
    for i in range(n):
        for k in range(n):
            for j in range(n):
                 b[i][k]+=ca[i][j]*p[j][k]   ##注意矩阵乘法i,j,k
    return b
if m!=0:    ##0次幂是单位矩阵
    for i in range(m-1):
        a=c(a)
else:
    for i in range(n):
         for j in range(n):
            if i==j:
                  a[i][j]=1
            else:
                  a[i][j]=0
for i in range(n):
    for j in range(n):
        print(a[i][j],end=' ')
    print()

分解质因数

在这里插入图片描述

m,n=map(int,input().split())
def is_prime(p):
    for i in range(2,p):
        if p%i==0:
            return False
    return True

i =m
while i <=n:
    if is_prime(i):
        print(i,end='')
        print('=',end='')
        print(i)
    else:
        j=2
        temp=i       ##这里注意不能直接对i操作，否则i会陷入循环
        print(temp,end='')
        print('=',end='')
        while j<n:
            if temp%j==0:
                print(j,end='')
                temp=int(temp/j)
                if temp!=1:
                    print('*',end='')
            else:
                j+=1
        print()
    i+=1

字符串对比

在这里插入图片描述

string1=input()
string2=input()
if len(string1)!=len(string2):
    print('1')
else:
    if string1==string2:
        print('2')
    elif string1.lower()==string2.lower():
        print('3')
    else:
        print('4')

时间转换

在这里插入图片描述

t=int(input())
H=int(t/3600)
M=int((t%3600)/60)
S=t%3600%60
print(H,':',M,':',S,sep=' ')

提高

最长滑雪道（图搜索，递归）

在这里插入图片描述


r,c=map(int,input().split())
ma=[[] for i in range(r)]     #存放每个点高度
for i in range(r):
    arr=list(map(int,input().split()))
    for j in range(c):
        ma[i].append(arr[j])        ##输入高度
dp=[[0 for i in range(c)] for j in range(r)]
#存放每个点开始的最大长度
nex=[[0,1],[1,0],[0,-1],[-1,0]]
#用来控制上下左右
ans=0

def dfs(x,y):     #求每个点开始的最大长度函数
    l=1
    if dp[x][y]>0:
        return dp[x][y]    #递归结束，走到了重复点
    for i in range(4):
        tx=x+nex[i][0]
        ty=y+nex[i][1]
        if tx<0 or ty<0 or tx>=r or ty>=c:
            continue
        if ma[tx][ty]>=ma[x][y]:  #只能向低的方向走
            continue
        l=max(l,dfs(tx,ty)+1)
        #用来寻找哪个方向走能让长度最大
    dp[x][y]=l
    return dp[x][y]    #返回x,y开始的最大长度

for i in range(r):        #找从哪个点开始长度最大
    for j in range(c):
        ans=max(ans,dfs(i,j))
print(ans)

石子游戏（贪心）

在这里插入图片描述

n=int(input())
s=[0 for i in range(n)]
for i in range(n):   #注意输入是一行一个
    s[i]=int(input())
c=0
while len(s)>1:
    s.sort()
    c+=(s[-1]+1)*(s[-2]+1)
    m=s[-1]+s[-2]
    s.pop()
    s.pop()
    s.append(m)
print(c)

注意pop（）使用方法

幸运顾客（堆【输出第i小的元素】）

![](https://img-blog.csdnimg.cn/cabdf66e0e2e47908c3f8c99b76d5bae.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAcXFfNDA4MzIwMzQ=,size_20,color_FFFFFF,t_70,g_se,x_16

n=int(input())
s=[]
x=[]
ii=0
for i in range(n):
    data =int(input())
    if data!=-1:
        s.append(data)
    else:
        s.sort()
        x.append(s[ii])
        ii+=1
for i in range(len(x)):
    print(x[i])

qq_40832034

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基础练习题目

题目：Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。n = int(input())Fib = [1 for i in range(n+1)]k=3while k<=n: Fib[k
复制链接

扫一扫