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条配置命令，它们执行的结果分别是：

注意：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

大数翻倍法