python常见计算题型

2021/9/29 17:40:47

本文主要是介绍python常见计算题型,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

HJ7 取近似值

描述

写出一个程序,接受一个正浮点数值,输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整;小于5,则向下取整。

输入描述:

输入一个正浮点数值

输出描述:

输出该数值的近似整数值

from math import *
n=float(input())
def ceilNumber(n):
  a=(ceil(n)-n)
  if (a <=0.5) :
     print(ceil(n))
  else:
     print(floor(n))

ceilNumber(n)

输入整型数组和排序标识,对其元素按照升序或降序进行排序

描述

输入整型数组和排序标识,对其元素按照升序或降序进行排序

输入描述:

第一行输入数组元素个数
第二行输入待排序的数组,每个数用空格隔开
第三行输入一个整数0或1。0代表升序排序,1代表降序排序

输出描述:

输出排好序的数字

while True:
    try:
        a,b,c=input(),map(int,input().split()),input()
        print(" ".join(map(str,sorted(b))) if c=="0" else " ".join(map(str,sorted(b,reverse=True))))
    except:break

问题:map是怎么给变量赋值的,map返回的是啥,怎么让不同类型快速转化

HJ37 统计每个月兔子的总数 (这是斐波那契数列,不能用递归方式,因为会内存溢出)

有一只兔子,从出生后第3个月起每个月都生一只兔子,小兔子长到第三个月后每个月又生一只兔子,假如兔子都不死,问每个月的兔子总数为多少?

输入描述:

输入int型表示month

输出描述:

输出兔子总数int型

示例1

输入:

9

输出:

34
'''
这题如果采用递归,那当n比较大的时候,内存会溢出,所以采用循环列表方式做
'''
while True:
    try:
        month=int(input())
        list=[]
        for i in range(month):
            if i < 2:   #当小于2个月时,只有一只兔子
                cont=1
                list.append(cont) #所以,列表为[1,1]
            else:
                cont=list[i-1]+list[i-2]  #当大于2时,后面的数是前面的两个数之和
                list.append(cont)  #追加入列表中假设i=2,这时候列表为[1,1,2]
        print(list[-1]) #最后采用逆向下标得出列表上最后一个元素L[-1]的值
    except:
        break

HJ38 求小球落地5次后所经历的路程和第5次反弹的高度

描述

假设一个球从任意高度自由落下,每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时,共经历多少米?第5次反弹多高?

最后的误差判断是小数点6位

输入描述:

输入起始高度,int型

输出描述:

分别输出第5次落地时,共经过多少米第5次反弹多高

示例1

输入:

1

输出:

2.875
0.03125
import sys
while True:
    try:
        h=float(input())
        s=h
        for i in range(4):
            s=s+h
            h=h/2
        s="%0.6f"%s
        h="%0.6f"%(h/2)
        print(s.rstrip('0'))
        print(h.rstrip('0'))
    except:
            #print(sys.exc_info())
            break
        

HJ50 四则运算

描述

输入一个表达式(用字符串表示),求这个表达式的值。

保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’, ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

输入描述:

输入一个算术表达式

输出描述:

得到计算结果

示例1

输入:

3+2*{1+2*[-4/(8-6)+7]}

输出:

25
while True:
    try:
        s = input().replace('{', '(').replace('}', ')').replace('[', '(').replace(']', ')')
        res = eval(s)
        print(int(res) if res == int(res) else res)
    except:
        break

完全数计算

描述

完全数(Perfect number),又称完美数或完备数,是一些特殊的自然数。

它所有的真因子(即除了自身以外的约数)的和(即因子函数),恰好等于它本身。

例如:28,它有约数1、2、4、7、14、28,除去它本身28外,其余5个数相加,1+2+4+7+14=28。s

输入n,请输出n以内(含n)完全数的个数。计算范围, 0 < n <= 500000

本题输入含有多组样例。

输入描述:

输入一个数字n

输出描述:

输出不超过n的完全数的个数

示例1

输入:

1000
7
100

输出:

3
1
2
while True:
    try:
         n=int(input())
         L=[]
         for i in range(1,n):
             p=0
             for y in range(1,i):
                 if i%y==0:
                     p=p+y
             if i==p:
                 L.append(p)
         print(len(L))
    except:
        break 

配置文件恢复

描述

有6条配置命令,它们执行的结果分别是:

命 令 执 行
reset reset what
reset board board fault
board add where to add
board delete no board at all
reboot backplane impossible
backplane abort install first
he he unknown command

注意:he he不是命令。

为了简化输入,方便用户,以“最短唯一匹配原则”匹配:
1、若只输入一字串,则只匹配一个关键字的命令行。例如输入:r,根据该规则,匹配命令reset,执行结果为:reset what;输入:res,根据该规则,匹配命令reset,执行结果为:reset what;
2、若只输入一字串,但本条命令有两个关键字,则匹配失败。例如输入:reb,可以找到命令reboot backpalne,但是该命令有两个关键词,所有匹配失败,执行结果为:unknown command
3、若输入两字串,则先匹配第一关键字,如果有匹配但不唯一,继续匹配第二关键字,如果仍不唯一,匹配失败。例如输入:r b,找到匹配命令reset board 和 reboot backplane,执行结果为:unknown command。

4、若输入两字串,则先匹配第一关键字,如果有匹配但不唯一,继续匹配第二关键字,如果唯一,匹配成功。例如输入:b a,无法确定是命令board add还是backplane abort,匹配失败。
5、若输入两字串,第一关键字匹配成功,则匹配第二关键字,若无匹配,失败。例如输入:bo a,确定是命令board add,匹配成功。
6、若匹配失败,打印“unknown command”

输入描述:

多行字符串,每行字符串一条命令

输出描述:

执行结果,每条命令输出一行

示例1

输入:

reset
reset board
board add
board delet
reboot backplane
backplane abort
 

输出:

reset what
board fault
where to add
no board at all
impossible
install first
while True:
    try:
        m=input().strip().split()
        key=["reset","reset board","board add","board delete","reboot backplane","backplane abort"]
        value=["reset what","board fault","where to add","no board at all","impossible","install first"]
        #key[2][:3] 'boa'
        #不建字典,是因为字典可能无序(3版又改动了),不方便确认是否唯一
        if len(m)<1 or len(m)>2:
            print("unknown command")
        elif len(m)==1:
            if m[0]==key[0][:len(m[0])]:
                print(value[0])
            else:
                print("unknown command")
        else:
            index=[]
            for i in range(1,len(key)):
                a=key[i].split()
                #print(a[0][:3])
                if m[0]==a[0][:len(m[0])] and m[1]==a[1][:len(m[1])]:
                    index.append(i)
            if len(index)!=1:
                print("unknown command")
            else:
                print(value[index[0]])
    except:
        break

HJ73 计算日期到天数转换

描述

根据输入的日期,计算是这一年的第几天。

输入描述:

输入一行,每行空格分割,分别是年,月,日

输出描述:

输出是这一年的第几天

示例1

输入:

2012 12 31

输出:

366
while True:
    try:
        import time
        year,month,day=map(int,input().split())
        if year <= 0 or month <=0 or day <=0 or month > 12 or day > 31:
            print(-1)
        else:
            m=[31,29,31,30,31,30,31,31,30,31,30,31]
            #判断是否是闰年,闰年的2月有29天,不是闰年2月就是28天,闰年判断标准就是四年一闰,百年不闰,四百年再闰
            if (year % 100 ==0 and year % 400 ==0 ) or (year %100 !=0 and year % 4 == 0):
                print(sum(m[:(month-1)])+day)
            else:
                m[1]=28
                print(sum(m[:(month-1)])+day)
    except:
        break

参数解析

描述

在命令行输入如下命令:

xcopy /s c:\ d:\,

各个参数如下:

参数1:命令字xcopy

参数2:字符串/s

参数3:字符串c:\

参数4: 字符串d:\

请编写一个参数解析程序,实现将命令行各个参数解析出来。

解析规则:

1.参数分隔符为空格
2.对于用""包含起来的参数,如果中间有空格,不能解析为多个参数。比如在命令行输入xcopy /s "C:\program files" "d:"时,参数仍然是4个,第3个参数应该是字符串C:\program files,而不是C:\program,注意输出参数时,需要将""去掉,引号不存在嵌套情况。
3.参数不定长
4.输入由用例保证,不会出现不符合要求的输入

输入描述:

输入一行字符串,可以有空格

输出描述:

输出参数个数,分解后的参数,每个参数都独占一行

示例1

输入:

xcopy /s c:\\ d:\\

输出:

4
xcopy
/s
c:\\
d:\\
# 分情况处理即可

# 测试:xcopy /s "C:\program files" "d:\"
s = input().split() # 输入一串字符,以空格分隔
res = [] # 解析结果列表
i = 0
while i in range(len(s)): # 遍历列表s中的元素
    if s[i].count('"')==2: # 如果当前元素有两个引号,说明该元素为一个完整的解析参数,直接添加即可
        res.append(s[i].replace('"', ''))
        i += 1
    elif s[i].count('"')==1: # 如果当前元素有一个引号,那么就要遍历找到第二个引号才能添加该解析参数
        temp = s[i].replace('"', '') # 临时变量
        for j in range(i+1, len(s)):
            if s[j].count('"')==1:
                temp = temp + ' ' + s[j].replace('"', '')
                break
            else:
                temp = temp + ' ' + s[j]
        res.append(temp)
        i = j+1
    else: #对于普通参数,无引号
        res.append(s[i])
        i += 1
print(len(res))
for i in res:
    print(i)

公共最大子串计算

描述

给定两个只包含小写字母的字符串,计算两个字符串的最大公共子串的长度。

注:子串的定义指一个字符串删掉其部分前缀和后缀(也可以不删)后形成的字符串。

输入描述:

输入两个只包含小写字母的字符串

输出描述:

输出一个整数,代表最大公共子串的长度

示例1

输入:

asdfas
werasdfaswer

输出:

6
while True:
    try:
        str_1=input()
        str_2=input()
        p=0  #定义一个起始位置
        for i in range(len(str_1)):
            if str_1[i-p:i+1] in str_2: #p从0开始,如果匹配就加一,这样最后看p.也就是说先一步一步移位找到第一个匹配的字符
                p+=1                
        print(p)
    except:
        break

尼克切斯定理

描述

验证尼科彻斯定理,即:任何一个整数m的立方都可以写成m个连续奇数之和。

例如:

1^3=1

2^3=3+5

3^3=7+9+11

4^3=13+15+17+19

输入一个正整数m(m≤100),将m的立方写成m个连续奇数之和的形式输出。

本题含有多组输入数据。

输入描述:

输入一个int整数

输出描述:

输出分解后的string

示例1

输入:

6

输出:

31+33+35+37+39+41
while True:
    try:
        m=int(input())
        L=[]
        for i in range(1,m**3):
            if i%2 !=0:
                L.append(i)
                if m ** 3 == sum(L[-m:]):   #注意题目说的是m个连续奇数之和,也就是说他们是挨在一起的
                    L=L[-m:]
                    break
        result=str(L[0]) #定位第一个数
        for X in range(1,m):
            result += '+'+str(L[X])
        print(result)
    except:
        break

HJ83 二维数组操作

描述

有一个img大小的数据表,你会依次进行以下5种操作:

1.输入imgimg,初始化img大小的表格。

2.输入x_1x1、y_1y1、x_2x2、y_2y2,交换坐标在(x_1,y_1)(x1,y1)和(x_2,y_2)(x2,y2)的两个数。

3.输入img,在第img行上方添加一行。

4.输入img,在第img列左边添加一列。

5.输入imgimg,查找坐标为img的单元格的值。

请编写程序,判断对表格的各种操作是否合法。

详细要求:

1.数据表的最大规格为9行*9列,对表格进行操作时遇到超出规格应该返回错误。

2.对于插入操作,如果插入后行数或列数超过9了则应返回错误。如果插入成功了则将数据表恢复至初始化的img大小,多出的数据则应舍弃。

3.所有输入坐标操作,对img大小的表格,行号坐标只允许0m-1,列号坐标只允许0n-1。超出范围应该返回错误。

本题含有多组样例输入!

输入描述:

输入数据按下列顺序输入:
1 表格的行列值
2 要交换的两个单元格的行列值
3 输入要插入的行的数值
4 输入要插入的列的数值
5 输入要查询的单元格的坐标

输出描述:

输出按下列顺序输出:
1 初始化表格是否成功,若成功则返回0, 否则返回-1
2 输出交换单元格是否成功
3 输出插入行是否成功
4 输出插入列是否成功
5 输出查询单元格数据是否成功

示例1

输入:

4 9
5 1 2 6
0
8
2 3
4 7
4 2 3 2
3
3
4 7

输出:

0
-1
0
-1
0
0
-1
0
0
-1

说明:

本组样例共有2组样例输入。
第一组样例:
1.初始化数据表为4行9列,成功
2.交换第5行1列和第2行6列的数据,失败。因为行的范围应该是(0,3),不存在第5行。
3.在第0行上方添加一行,成功。
4.在第8列左边添加一列,失败。因为列的总数已经达到了9的上限。
5.查询第2行第3列的值,成功。
第二组样例:
1.初始化数据表为4行7列,成功
2.交换第4行2列和第3行2列的数据,失败。因为行的范围应该是(0,3),不存在第4行。
3.在第3行上方添加一行,成功。
4.在第3列左边添加一列,成功。
5.查询第4行7列的值,失败。因为虽然添加了一行一列,但数据表会在添加后恢复成4行7列的形态,所以行的区间仍然在[0,3],列的区间仍然在[0,6],无法查询到(4,7)坐标。   
while True:
    try:
        m, n = map(int, input().split())
        x1, y1, x2, y2=map(int,input().split())
        insert_x=int(input())
        insert_y=int(input())
        x,y=map(int,input().split())
        if (0 <= m <= 9) and (0 <= n <= 9):
            print('0')
        else:
            print('-1')
        if (0 <= x1 < m) and (0 <= y1 < n) and (0 <= x2 <= m)and (0 <= y2 < n):
            print('0')
        else:
            print('-1')
        if (0 <= insert_x < m) and (m < 9):
            print('0')
        else:
            print('-1')
        if (0 <= insert_y < n) and (n < 9):
            print('0')
        else:
            print('-1')
        if(0 <= x < m)and (0 <= y < n):
            print('0')
        else:
            print('-1')
    except:
        break

HJ85 最长回文子串

描述

给定一个仅包含小写字母的字符串,求它的最长回文子串的长度。

所谓回文串,指左右对称的字符串。

所谓子串,指一个字符串删掉其部分前缀和后缀(也可以不删)的字符串

(注意:记得加上while处理多个测试用例)

输入描述:

输入一个仅包含小写字母的字符串

输出描述:

返回最长回文子串的长度

示例1

输入:

cdabbacc

输出:

4

说明:

abba为最长的回文子串
while True:
    try:
        s = input()
        m = 0
        for i in range(len(s)):
            if i - m >= 1 and s[i-m-1:i+1] == s[i-m-1:i+1][::-1]:
                m += 2
            elif i - m >= 0 and s[i-m:i+1] == s[i-m:i+1][::-1]:
                m += 1
        if m != 0:
            print(m)
    except:
        break

HJ87 密码强度等级

描述

密码按如下规则进行计分,并根据不同的得分为密码进行安全等级划分。

一、密码长度:

5 分: 小于等于4 个字符

10 分: 5 到7 字符

25 分: 大于等于8 个字符

二、字母:

0 分: 没有字母

10 分: 全都是小(大)写字母

20 分: 大小写混合字母

三、数字:

0 分: 没有数字

10 分: 1 个数字

20 分: 大于1 个数字

四、符号:

0 分: 没有符号

10 分: 1 个符号

25 分: 大于1 个符号

五、奖励:

2 分: 字母和数字

3 分: 字母、数字和符号

5 分: 大小写字母、数字和符号

最后的评分标准:

>= 90: 非常安全

>= 80: 安全(Secure)

>= 70: 非常强

>= 60: 强(Strong)

>= 50: 一般(Average)

>= 25: 弱(Weak)

>= 0: 非常弱

对应输出为:

VERY_SECURE

SECURE

VERY_STRONG

STRONG

AVERAGE

WEAK

VERY_WEAK

请根据输入的密码字符串,进行安全评定。

注:

字母:a-z, A-Z

数字:0-9

符号包含如下: (ASCII码表可以在UltraEdit的菜单view->ASCII Table查看)

!"#$%&'()*+,-./ (ASCII码:0x21~0x2F)

:;<=>?@ (ASCII码:0x3A~0x40)

[]^_` (ASCII码:0x5B~0x60)

{|}~ (ASCII码:0x7B~0x7E)

提示:

1 <= 字符串的长度<= 300

输入描述:

本题含有多组输入样例。
每组样例输入一个string的密码

输出描述:

每组样例输出密码等级

示例1

输入:

38$@NoNoNo
123

输出:

VERY_SECURE
WEAK

说明:

第一组样例密码强度为95分。
第二组样例密码强度为25分。    
while True:
    try:
        str_data = input().strip()
        num, up_char, low_char, other, score = 0, 0, 0, 0, 0

        for data in str_data:
            if data.isdigit():
                num += 1
            elif data.isalpha():
                if data.lower() == data:
                    low_char += 1
                else:
                    up_char += 1
            else:
                other += 1
        if len(str_data) < 5:
            score += 5
        elif len(str_data) < 8:
            score += 10
        else:
            score += 25
        if up_char==0 and low_char==0:
            pass
        elif (up_char==0 and low_char!=0) or (up_char!=0 and low_char==0):
            score += 10
        else:
            score += 20
        if num == 0:
            pass
        elif num == 1:
            score += 10
        else:
            score += 20
        if other == 0:
            pass
        elif other == 1:
            score += 10
        else:
            score += 25
        if num != 0 and (up_char+low_char) != 0 and other==0:
            score += 2
        elif num != 0 and up_char != 0 and low_char != 0 and other!=0:
            score += 5
        elif num != 0 and (up_char+low_char) != 0 and other!=0:
            score += 3
        if score >=90:
            print('VERY_SECURE')
        elif score >=80:
            print('SECURE')
        elif score >= 70:
            print('VERY_STRONG')
        elif score >= 60:
            print('STRONG')
        elif score >= 50:
            print('AVERAGE')
        elif  score>=25:
            print('WEAK')
        else:
            print('VERY_WEAK')
    except:
        break

走方格的方案数

描述

请计算n*m的棋盘格子(n为横向的格子数,m为竖向的格子数)沿着各自边缘线从左上角走到右下角,总共有多少种走法,要求不能走回头路,即:只能往右和往下走,不能往左和往上走。

本题含有多组样例输入。

输入描述:

每组样例输入两个正整数n和m,用空格隔开。(1≤n,m≤8)

输出描述:

每组样例输出一行结果

示例1

输入:

2 2
1 2

输出:

6
3
while True:
    try:
        m,n = map(int,input().split())  # m为行数,n为列数
        c = [[1 for i in range(n+1)] for j in range(m+1)]  # 隐含了边界条件初始化
        for i in range(1,m+1):  # 转换为求解从右下角走到左上角的路径数
            for j in range(1,n+1):
                c[i][j] = c[i-1][j] + c[i][j-1]
        print(c[m][n])
    except:
        break

记负均正

描述

首先输入要输入的整数个数n,然后输入n个整数。输出为n个整数中负数的个数,和所有正整数的平均值,结果保留一位小数。

0即不是正整数,也不是负数,不计入计算

输入描述:

本题有多组输入用例。

首先输入一个正整数n,
然后输入n个整数。

输出描述:

输出负数的个数,和所有正整数的平均值。

示例1

输入:

5
1 2 3 4 5
10 
1 2 3 4 5 6 7 8 9 0

输出:

0 3.0
0 5.0
while True:
    try:
        num = int(input())
        li = list(map(lambda x:int(x), input().split()))
    except EOFError:
        break
    print(len(list(filter(lambda x:x<0, li))), end=" ")
    postives = list(filter(lambda x:x>0, li))
    print(round(sum(postives)/len(postives),1) if postives else 0.0)

HJ108 求最小公倍数

描述

正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值,设计一个算法,求输入A和B的最小公倍数。

输入描述:

输入两个正整数A和B。

输出描述:

输出A和B的最小公倍数。

示例1

输入:

5 7

输出:

35
a, b = map(int, input().split())
def gy(a, b):
    while (b != 0):
        c = a % b
        a = b
        b = c

    return a
print(int((a * b) / gy(a, b)))

这是常规扩大倍数求交际方法

while True:
    try:
        a,b=map(int,input().split())
        C=[]
        D=[]
        E=[]
        for i in range(1,100000):
            c=a*i
            C.append(c)
            d=b*i
            D.append(d)         
        C=set(C)
        D=set(D)
        E=C&D
        E=list(E)
        E.sort()
        print(E[0])        
    except:
        break

大数翻倍法



这篇关于python常见计算题型的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程