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 二維數組操作

描述

有一個大小的數據表，你會依次進行以下5種操作：

1.輸入和，初始化大小的表格。

2.輸入x_1x1、y_1y1、x_2x2、y_2y2，交換坐標在(x_1,y_1)(x1,y1)和(x_2,y_2)(x2,y2)的兩個數。

3.輸入，在第行上方添加一行。

4.輸入，在第列左邊添加一列。

5.輸入、，查找坐標為的單元格的值。

請編寫程序，判斷對表格的各種操作是否合法。

詳細要求:

1.數據表的最大規格為9行*9列，對表格進行操作時遇到超出規格應該返回錯誤。

2.對於插入操作，如果插入后行數或列數超過9了則應返回錯誤。如果插入成功了則將數據表恢復至初始化的大小，多出的數據則應舍棄。

3.所有輸入坐標操作，對大小的表格，行號坐標只允許0_{m-1，列號坐標只允許0}n-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

大數翻倍法