前言:

 

多行数据需要输入的时候可以用下面的结构:

while True:
    try:
        n = int(input())
        s = input().split()
        num = []
        for i in s:
            num.append(int(i))
        k = int(input())
        print(num[n-k])
    except:
        break

输入两组数据:

1
8108
1

7
2542 4218 9064 4908 1526 6655 921
1

一次输入两个数组时,可以用下面的输入方式: 

n1 = int(input())
num1 = list(map(int, input().split()))
n2 = int(input())
num2 = list(map(int, input().split()))

一、机试练习篇

1、简单题

HJ1 字符串最后一个单词的长度

描述

计算字符串最后一个单词的长度,单词以空格隔开,字符串长度小于5000。(注:字符串末尾不以空格为结尾)

输入描述:

输入一行,代表要计算的字符串,非空,长度小于5000。

输出描述:

输出一个整数,表示输入字符串最后一个单词的长度。

示例1:

输入:
hello nowcoder

输出:
8

说明:
最后一个单词为nowcoder,长度为8   

实现代码:

s = input()
s_list = s.split(' ')
print(len(s_list[-1]))

 HJ2 计算某字符出现次数

描述

写出一个程序,接受一个由字母、数字和空格组成的字符串,和一个字符,然后输出输入字符串中该字符的出现次数。(不区分大小写字母)

数据范围: 1≤�≤1000 1≤n≤1000 

输入描述:

第一行输入一个由字母、数字和空格组成的字符串,第二行输入一个字符(保证该字符不为空格)。

输出描述:

输出输入字符串中含有该字符的个数。(不区分大小写字母)

示例1

输入:
ABCabc
A

输出:
2

实现代码: 

s1 = input()
s2 = input()
count = 0
for i in s1:
    if(s2.upper() == i.upper()):
        count += 1
print(count)

HJ4 字符串分隔 

描述

•输入一个字符串,请按长度为8拆分每个输入字符串并进行输出;

•长度不是8整数倍的字符串请在后面补数字0,空字符串不处理。

输入描述:

连续输入字符串(每个字符串长度小于等于100)

输出描述:

依次输出所有分割后的长度为8的新字符串

示例1:

输入:
abc

输出:
abc00000

实现代码: 

s = input()
while len(s) > 8:
    print(s[:8])  # 循环迭代每次取前8位字符
    s = s[8:]  #将剩余的字符串取下备下次用
if len(s) != 0:
    for i in range(8 - len(s)):  # 最后不足8位用0补齐
        s += "0"
print(s)

 HJ5 进制转换

描述

写出一个程序,接受一个十六进制的数,输出该数值的十进制表示。

数据范围:保证结果在 1≤�≤231−1 1≤n≤231−1 

输入描述:

输入一个十六进制的数值字符串。

输出描述:

输出该数值的十进制字符串。不同组的测试用例用\n隔开。

示例1

输入:
0xAA

输出:
170

实现代码: 

num = input()
print(int(num, 16))  # int()函数可以将任何进制的数据转换为十进制数据
# print(bin(int(num, 16)))  # bin()函数可以将十进制数据转换为二进制数据

HJ6 质数因子 

描述

功能:输入一个正整数,按照从小到大的顺序输出它的所有质因子(重复的也要列举)(如180的质因子为2 2 3 3 5 )

数据范围: 1≤�≤2×109+14 1≤n≤2×109+14 

输入描述:

输入一个整数

输出描述:

按照从小到大的顺序输出它的所有质数的因子,以空格隔开。

示例1

输入:
180

输出:
2 2 3 3 5

实现代码: 

from math import sqrt
num = int(input())

for i in range(2, int(sqrt(num)) + 1):
    # if(num % i == 0):
    while(num % i == 0):
        num /= i
        print(i, end=' ')#不换行输出
if(num != 1):
    print(int(num))

HJ7 取近似值 

描述

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

数据范围:保证输入的数字在 32 位浮点数范围内

输入描述:

输入一个正浮点数值

输出描述:

输出该数值的近似整数值

示例1

输入:
5.5

输出:
6

说明:
0.5>=0.5,所以5.5需要向上取整为6   

示例2 

输入:
2.499

输出:
2

说明:
0.499<0.5,2.499向下取整为2  

实现代码: 

num = float(input())
small = num - int(num)
if(small >= 0.5):
    print(int(num) + 1)
else:
    print(int(num))

HJ8 合并表记录

描述

数据表记录包含表索引index和数值value(int范围的正整数),请对表索引相同的记录进行合并,即将相同索引的数值进行求和运算,输出按照index值升序进行输出。

提示:

0 <= index <= 11111111

1 <= value <= 100000

输入描述:

先输入键值对的个数n(1 <= n <= 500)
接下来n行每行输入成对的index和value值,以空格隔开

输出描述:

输出合并后的键值对(多行)

示例1

输入:
4
0 1
0 2
1 2
3 4

输出:
0 3
1 2
3 4

示例2 

输入:
3
0 1
0 2
8 9

输出:
0 3
8 9

实现代码: 

num = int(input())
dic = {}
for i in range(num):
    k, v = input().split()  # 一行输入多个变量
    k, v = int(k), int(v)
    if k not in dic:
        dic[k] = v
    else:
        dic[k] += v
for k, v in sorted(dic.items()):#dict按key升序遍历
    print(k, v)
    
# dict按value升序遍历:
# for key,value in sorted(dic.items(),key=lambda x:x[1]):
#         print(key,value)

HJ9 提取不重复的整数 

描述

输入一个 int 型整数,按照从右向左的阅读顺序,返回一个不含重复数字的新的整数。

保证输入的整数最后一位不是 0 。

数据范围: 1≤�≤108 1≤n≤108 

输入描述:

输入一个int型整数

输出描述:

按照从右向左的阅读顺序,返回一个不含重复数字的新的整数

示例1

输入:
9876673

输出:
37689

实现代码: 

num = int(input())
res = []
while(num):
    temp = num % 10
    if(temp not in res):
         res.append(temp)
    num = int(num / 10)
for  i in res:
    print(i, end='')

 HJ10 字符个数统计

描述

编写一个函数,计算字符串中含有的不同字符的个数。字符在 ASCII 码范围内( 0~127 ,包括 0 和 127 ),换行表示结束符,不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次

例如,对于字符串 abaca 而言,有 a、b、c 三种不同的字符,因此输出 3 。

数据范围: 1≤�≤500 1≤n≤500 

输入描述:

输入一行没有空格的字符串。

输出描述:

输出 输入字符串 中范围在(0~127,包括0和127)字符的种数。

示例1

输入:
abc

输出:
3

示例2 

输入:
aaa

输出:
1

实现代码:

s = input()
s_set = set()
for i in s:
    if(i not in s_set):
        s_set.add(i)
print(len(s_set))

HJ11 数字颠倒 

描述

输入一个整数,将这个整数以字符串的形式逆序输出

程序不考虑负数的情况,若数字含有0,则逆序形式也含有0,如输入为100,则输出为001

数据范围: 0≤�≤230−1 0≤n≤230−1 

输入描述:

输入一个int整数

输出描述:

将这个整数以字符串的形式逆序输出

示例1

输入:
1516000

输出:
0006151

示例2 

输入:
0

输出:
0

实现代码:

num = int(input())
if(num / 10 == 0):
    print(num)
res = []
while(num):
    temp = num % 10
    res.append(temp)
    num = int(num / 10)
for i in res:
    print(i, end = '')

HJ12 字符串反转

描述

接受一个只包含小写字母的字符串,然后输出该字符串反转后的字符串。(字符串长度不超过1000)

输入描述:

输入一行,为一个只包含小写字母的字符串。

输出描述:

输出该字符串反转后的字符串。

示例1

输入:
abcd

输出:
dcba

 实现代码:

s = input()
print(s[::-1])

HJ13 句子逆序 

描述

将一个英文语句以单词为单位逆序排放。例如“I am a boy”,逆序排放后为“boy a am I”

所有单词之间用一个空格隔开,语句中除了英文字母外,不再包含其他字符

数据范围:输入的字符串长度满足 1≤�≤1000 1≤n≤1000 

注意本题有多组输入

输入描述:

输入一个英文语句,每个单词用空格隔开。保证输入只包含空格和字母。

输出描述:

得到逆序的句子

示例1

输入:
I am a boy

输出:
boy a am I

示例2 

输入:
nowcoder

输出:
nowcoder

实现代码: 

s = input().split(' ')
s.reverse()
print(' '.join(s))

HJ14 字符串排序 

描述

给定 n 个字符串,请对 n 个字符串按照字典序排列。

数据范围: 1≤�≤1000 1≤n≤1000  ,字符串长度满足 1≤���≤100 1≤len≤100 

输入描述:

输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。

输出描述:

数据输出n行,输出结果为按照字典序排列的字符串。

示例1

输入:
9
cap
to
cat
card
two
too
up
boat
boot

输出:
boat
boot
cap
card
cat
to
too
two
up

 实现代码:

num = int(input())
dic = {}
for i in range(num):
    s = input()
    dic[i] = s
#sorted(dic.items(), key=lambda x:x[1])返回的是list的数组
for k, v in sorted(dic.items(), key=lambda x:x[1]):#按value值升序排列
    print(v)

HJ15 求int型正整数在内存中存储时1的个数 

描述

输入一个 int 型的正整数,计算出该 int 型数据在内存中存储时 1 的个数。

数据范围:保证在 32 位整型数字范围内

输入描述:

 输入一个整数(int类型)

输出描述:

 这个数转换成2进制后,输出1的个数

示例1

输入:
5

输出:
2

示例2 

输入:
0

输出:
0

实现代码: 

num = int(input())
num_bit = bin(num)[2:]
print(num_bit.count('1'))

HJ21 简单密码 

描述

现在有一种密码变换算法。

九键手机键盘上的数字与字母的对应: 1–1, abc–2, def–3, ghi–4, jkl–5, mno–6, pqrs–7, tuv–8 wxyz–9, 0–0,把密码中出现的小写字母都变成九键键盘对应的数字,如:a 变成 2,x 变成 9.

而密码中出现的大写字母则变成小写之后往后移一位,如:X ,先变成小写,再往后移一位,变成了 y ,例外:Z 往后移是 a 。

数字和其它的符号都不做变换。

数据范围: 输入的字符串长度满足 1≤�≤100 1≤n≤100 

输入描述:

输入一组密码,长度不超过100个字符。

输出描述:

输出密码变换后的字符串

示例1

输入:
YUANzhi1987

输出:
zvbo9441987

实现代码: 

s = input()
dic = {
    "1": "1",
    "a": "2",
    "b": "2",
    "c": "2",
    "d": "3",
    "e": "3",
    "f": "3",
    "g": "4",
    "h": "4",
    "i": "4",
    "j": "5",
    "k": "5",
    "l": "5",
    "m": "6",
    "n": "6",
    "o": "6",
    "p": "7",
    "q": "7",
    "r": "7",
    "s": "7",
    "t": "8",
    "u": "8",
    "v": "8",
    "w": "9",
    "x": "9",
    "y": "9",
    "z": "9",
    "0": "0",
}
res = ''
for i in s:
    if(i.isupper()):
        i = i.lower()
        if(i != 'z'):
            res += chr(ord(i) + 1)#得到字母的ASSIC码再将其后移一位
        else:
            res += 'a'#如果是最后一个字母'z',则循环到'a'
    elif(i.islower()):
        res += dic[i]
    else:
        res += i
print(res)

HJ23 删除字符串中出现次数最少的字符

描述

实现删除字符串中出现次数最少的字符,若出现次数最少的字符有多个,则把出现次数最少的字符都删除。输出删除这些单词后的字符串,字符串中其它字符保持原来的顺序。

数据范围:输入的字符串长度满足 1≤�≤20 1≤n≤20  ,保证输入的字符串中仅出现小写字母

输入描述:

字符串只包含小写英文字母, 不考虑非法输入,输入的字符串长度小于等于20个字节。

输出描述:

删除字符串中出现次数最少的字符后的字符串。

示例1

输入:
aabcddd

输出:
aaddd

实现代码: 

s = input()
dic = {}
for i in s:
    if i not in dic:
        dic[i] = 1
    else:
        dic[i] += 1
min_count = min(dic.values())  # 找出出现次数最少的字母
s_del = []
for k in dic:
    if dic[k] == min_count:
        s = s.replace(k, "")  # 用空字符替换掉出现次数最少的字符
print(s)

HJ31 单词倒排 

描述

对字符串中的所有单词进行倒排。

说明:

1、构成单词的字符只有26个大写或小写英文字母;

2、非构成单词的字符均视为单词间隔符;

3、要求倒排后的单词间隔符以一个空格表示;如果原字符串中相邻单词间有多个间隔符时,倒排转换后也只允许出现一个空格间隔符;

4、每个单词最长20个字母;

数据范围:字符串长度满足 1≤�≤10000 1≤n≤10000 

输入描述:

输入一行,表示用来倒排的句子

输出描述:

输出句子的倒排结果

示例1

输入:
I am a student

输出:
student a am I

示例2 

输入:
$bo*y gi!r#l

输出:
l r gi y bo

实现代码: 

s = input()
for i in s:
    if(i.islower() == False and i.isupper() == False):
        s = s.replace(i, ' ')#用空格把冗余的字符去除
res = s.split(' ')
res.reverse()
print(' '.join(res))

HJ34 图片整理

描述

Lily上课时使用字母数字图片教小朋友们学习英语单词,每次都需要把这些图片按照大小(ASCII码值从小到大)排列收好。请大家给Lily帮忙,通过代码解决。

Lily使用的图片使用字符"A"到"Z"、"a"到"z"、"0"到"9"表示。

数据范围:每组输入的字符串长度满足 1≤�≤1000 1≤n≤1000 

输入描述:

一行,一个字符串,字符串中的每个字符表示一张Lily使用的图片。

输出描述:

Lily的所有图片按照从小到大的顺序输出

示例1

输入:
Ihave1nose2hands10fingers

输出:
0112Iaadeeefghhinnnorsssv

 实现代码:

s = input()
print(''.join(sorted(s)))

HJ35 蛇形矩阵

蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。

例如,当输入5时,应该输出的三角形为:

1 3 6 10 15

2 5 9 14

4 8 13

7 12

11

输入描述:

输入正整数N(N不大于100)

输出描述:

输出一个N行的蛇形矩阵。

示例1

输入:
4

输出:
1 3 6 10
2 5 9
4 8
7

实现代码:

num = int(input())
for i in range(1, num + 1):
    step = i + 1# 每一行的步长
    start = (i * (i - 1)) // 2 + 1# 每一行的第一个值
    print(start, end = '')
    for j in range(2, num+2-i):#每行输出多少个值
        start += step
        print('', start, end = '')
        step += 1
    print()#换行

HJ37 统计每个月兔子的总数

描述

有一种兔子,从出生后第3个月起每个月都生一只兔子,小兔子长到第三个月后每个月又生一只兔子。

例子:假设一只兔子第3个月出生,那么它第5个月开始会每个月生一只兔子。

一月的时候有一只兔子,假如兔子都不死,问第n个月的兔子总数为多少?

数据范围:输入满足 1≤�≤31 1≤n≤31 

输入描述:

输入一个int型整数表示第n个月

输出描述:

输出对应的兔子总数

示例1

输入:
3

输出:
2

实现代码:

month = int(input())
n = month - 1
def fun(n):
    if(n < 2):
        return 1
    else:
        return fun(n-1) + fun(n-2)
print(fun(n))

HJ40 统计字符

描述

输入一行字符,分别统计出包含英文字母、空格、数字和其它字符的个数。

数据范围:输入的字符串长度满足 1≤�≤1000 1≤n≤1000 

输入描述:

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

输出描述

统计其中英文字符,空格字符,数字字符,其他字符的个数

示例1

输入:
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][

输出:
26
3
10
12

实现代码:

输入:
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][

输出:
26
3
10
12

HJ54 表达式求值 

描述

给定一个字符串描述的算术表达式,计算出结果值。

输入字符串长度不超过 100 ,合法的字符包括 ”+, -, *, /, (, )” , ”0-9” 。

数据范围:运算过程中和最终结果均满足 ∣���∣≤231−1 ∣val∣≤231−1  ,即只进行整型运算,确保输入的表达式合法

输入描述:

输入算术表达式

输出描述:

计算出结果值

示例1

输入:
400+5

输出:
405

 实现代码:

print(eval(input()))

HJ56 完全数计算 

描述

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

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

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

输入n,请输出n以内(含n)完全数的个数。

数据范围: 1≤�≤5×105 1≤n≤5×105 

输入描述:

输入一个数字n

输出描述:

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

示例1

输入:
1000

输出:
3

实现代码:

from math import sqrt
num = int(input())
count = 0
for i in range(1, num+1):
    sum = 0
    for j in range(1, i):
        if(i % j == 0):
            sum += j
    if(sum == i):
        count += 1
print(count)

 HJ62 查找输入整数二进制中1的个数

输入一个正整数,计算它在二进制下的1的个数。

注意多组输入输出!!!!!!

数据范围: 1≤�≤231−1 1≤n≤231−1 

输入描述:

输入一个整数

输出描述:

计算整数二进制中1的个数

示例1

输入:
5

输出:
2

说明:
5的二进制表示是101,有2个1   

示例2 

输入:
0

输出:
0

实现代码:

x = int(input())
y = int(input())
s1 = bin(x)[2:]
s2 = bin(y)[2:]
print(s1.count('1'))
print(s2.count('1'))

HJ73 计算日期到天数转换 

描述

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

保证年份为4位数且日期合法。

进阶:时间复杂度:�(�) O(n) ,空间复杂度:�(1) O(1) 

输入描述:

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

输出描述:

输出是这一年的第几天

示例1

输入:
2012 12 31

输出:
366

示例2 

输入:
1982 3 4

输出:
63

实现代码: 

s = input().split(' ')
y, m, d = int(s[0]), int(s[1]), int(s[2])
month = [31,28,31,30,31,30,31,31,30,31,30,31]
total_days = sum(month[:m-1]) + d
if(m > 2 and (y%4==0 and y%100!=0 or y%400==0)):#出现闰年的情况
    total_days += 1
print(total_days)

 HJ81 字符串字符匹配

描述

判断短字符串S中的所有字符是否在长字符串T中全部出现。

请注意本题有多组样例输入。

数据范围:1≤���(�),���(�)≤200 1≤len(S),len(T)≤200 

进阶:时间复杂度:�(�) O(n) ,空间复杂度:�(�) O(n) 

输入描述:

输入两个字符串。第一个为短字符串,第二个为长字符串。两个字符串均由小写字母组成。

输出描述:

如果短字符串的所有字符均在长字符串中出现过,则输出字符串"true"。否则输出字符串"false"。

示例1

输入:
bc
abc

输出:
true

说明:
其中abc含有bc,输出"true"

实现代码: 

s1 = list(set(input()))
s2 = list(set(input()))
for i in s1:
    if i not in s2:
        print("false")
        break
    # 直到最后一个字符都在s2里,那么我们称字符串匹配成功
    if i == s1[-1] and i in s2:
        print("true")

HJ84 统计大写字母个数 

描述

找出给定字符串中大写字符(即'A'-'Z')的个数。

数据范围:字符串长度:1≤∣�∣≤250 1≤∣s∣≤250 

字符串中可能包含空格或其他字符

进阶:时间复杂度:�(�) O(n) ,空间复杂度:�(�) O(n) 

输入描述:

对于每组样例,输入一行,代表待统计的字符串

输出描述:

输出一个整数,代表字符串中大写字母的个数

示例1

输入:
A 1 0 1 1150175017(&^%&$vabovbaoadd 123#$%#%#O

输出:
2

实现代码: 

s = input()
cnt = 0
for i in s:
    if(i.isupper()):
        cnt += 1
print(cnt)

 HJ85 最长回文子串

描述

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

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

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

数据范围:字符串长度1≤�≤350 1≤s≤350 

进阶:时间复杂度:�(�) O(n) ,空间复杂度:�(�) O(n) 

输入描述:

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

输出描述:

返回最长回文子串的长度

示例1

输入:
cdabbacc

输出:
4

说明:
abba为最长的回文子串  

实现代码: 

def isHuiWenStr(subStr:str):#判断当前子串是不是回文字符
    start = 0
    end = len(subStr) - 1
    while(start < end):
        if(subStr[start] != subStr[end]):
            return False
        start = start + 1
        end = end - 1
    return True

s = input()
if(len(s) < 2):
    print(s)
maxLen = 1#记录最大回文字符长度
for i in range(len(s)-1):
    for j in range(i + 1, len(s)):
        if((j - i + 1) > maxLen and isHuiWenStr(s[i:j+1])):
            maxLen = j - i + 1
print(maxLen)



HJ86 求最大连续bit数 

描述

求一个int类型数字对应的二进制数字中1的最大连续数,例如3的二进制为00000011,最大连续2个1

数据范围:数据组数:1≤�≤5 1≤t≤5 ,1≤�≤500000 1≤n≤500000 

进阶:时间复杂度:�(����) O(logn) ,空间复杂度:�(1) O(1) 

输入描述:

输入一个int类型数字

输出描述:

输出转成二进制之后连续1的个数

示例1

输入:
200

输出:
2

说明:
200的二进制表示是11001000,最多有2个连续的1。  

实现代码:

num = int(input())
s = bin(num)[2:]
res = 1
temp = 1
for i in range(len(s)):
   if(s[i] == '1'):
        for j in range(i + 1, len(s)):
            if(s[i] == s[j]):
                temp += 1
            else:
                break
        res = max(res, temp)
        temp = 1
print(res)

 HJ94 记票统计

描述

请实现一个计票统计系统。你会收到很多投票,其中有合法的也有不合法的,请统计每个候选人得票的数量以及不合法的票数。

(注:不合法的投票指的是投票的名字不存在n个候选人的名字中!!)

数据范围:每组输入中候选人数量满足 1≤�≤100 1≤n≤100  ,总票数量满足 1≤�≤100 1≤n≤100 

输入描述:

第一行输入候选人的人数n,第二行输入n个候选人的名字(均为大写字母的字符串),第三行输入投票人的人数,第四行输入投票。

输出描述:

按照输入的顺序,每行输出候选人的名字和得票数量(以" : "隔开,注:英文冒号左右两边都有一个空格!),最后一行输出不合法的票数,格式为"Invalid : "+不合法的票数。

示例1

输入:
4
A B C D
8
A D E CF A GG A B

输出:
A : 3
B : 1
C : 0
D : 1
Invalid : 3

说明:
E CF GG三张票是无效的,所以Invalid的数量是3. 

实现代码: 

n1 = int(input())
s1 = input().split(" ")
n2 = int(input())
s2 = input().split(" ")
dic = {}
for i in s1:
    dic[i] = 0
for k in dic:#统计票数
    for i in s2:
        if i == k:
            dic[k] += 1
sum = 0
for k, v in dic.items():#统计总的有效票数
    sum += v
dic.update({'Invalid': len(s2) - sum})#更新无效票数

for k, v in dic.items():
    print(k, ":", v)

HJ96 表示数字 

描述

将一个字符串中所有的整数前后加上符号“*”,其他字符保持不变。连续的数字视为一个整数。

数据范围:字符串长度满足 1≤�≤100 1≤n≤100 

输入描述:

输入一个字符串

输出描述:

字符中所有出现的数字前后加上符号“*”,其他字符保持不变

示例1

输入:
Jkdi234klowe90a3

输出:
Jkdi*234*klowe*90*a*3*

实现代码: 

s = input()
res = ""
if s[0] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}:
    res = "*" + res
    res += s[0]
else:
    res += s[0]
for i in range(1, len(s)):
    if (
        s[i - 1] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
        and s[i] not in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
        or s[i] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
        and s[i - 1] not in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}
    ):
        res += "*"
        res += s[i]
    else:
        res += s[i]
if s[-1] in {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"}:
    res += "*"
print(res)

HJ102 字符统计 

描述

输入一个只包含小写英文字母和数字的字符串,按照不同字符统计个数由多到少输出统计结果,如果统计的个数相同,则按照ASCII码由小到大排序输出。

数据范围:字符串长度满足 1≤���(���)≤1000 1≤len(str)≤1000 

输入描述:

一个只包含小写英文字母和数字的字符串。

输出描述:

一个字符串,为不同字母出现次数的降序表示。若出现次数相同,则按ASCII码的升序输出。

示例1

输入:
aaddccdc

输出:
cda

说明:
样例里,c和d出现3次,a出现2次,但c的ASCII码比d小,所以先输出c,再输出d,最后输出a.

 实现代码:

s = input()
dic = {}
for i in s:
    if i not in dic:
        dic[i] = 1
    else:
        dic[i] += 1
dic = sorted(dic.items(), key=lambda x: x[0])  # key先按字符ASCII排序
dic = sorted(dic, key=lambda x: x[1], reverse=True)  # 按统计数目value排序,再按降序排列
for k, v in dic:
    print("".join(k), end="")

 HJ106 字符逆序

描述

将一个字符串str的内容颠倒过来,并输出。

数据范围:1≤���(���)≤10000 1≤len(str)≤10000 

输入描述:

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

输出描述:

输出逆序的字符串

示例1

输入:
I am a student

输出:
tneduts a ma I

示例2 

输入:
nowcoder

输出:
redocwon

实现代码: 

s = input().split(' ')
s.reverse()
for i in s:
    print(''.join(i[::-1]), end = ' ')

HJ60 查找组成一个偶数最接近的两个素数 

描述

任意一个偶数(大于2)都可以由2个素数组成,组成偶数的2个素数有很多种情况,本题目要求输出组成指定偶数的两个素数差值最小的素数对。

数据范围:输入的数据满足 4≤�≤1000 4≤n≤1000 

输入描述:

输入一个大于2的偶数

输出描述:

从小到大输出两个素数

示例1

输入:
20

输出:
7
13

示例2 

输入:
4

输出:
2
2

实现代码: 

def prime(num):  # 判断是否为素数
    flag = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            flag = False
            break
    return flag
    
n = int(input())
res = []
for i in range(2, int(n / 2 + 1)):#从中间像两边靠,最终结果就是距离最短的两个素数
    if prime(i) and prime(n - i):
        res = [i, n - i]
for j in res:
    print(j)

HJ72 百钱买百鸡问题 

描述

公元五世纪,我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”:鸡翁一值钱五,鸡母一值钱三,鸡雏三值钱一。百钱买百鸡,问鸡翁、鸡母、鸡雏各几何?

现要求你打印出所有花一百元买一百只鸡的方式。

输入描述:

输入任何一个整数,即可运行程序。

输出描述:

 输出有数行,每行三个整数,分别代表鸡翁,母鸡,鸡雏的数量

示例1

输入:
1

输出:
0 25 75
4 18 78
8 11 81
12 4 84

思路:

  1. 题目翻译之后的意思是,公鸡一只5元,母鸡一只3元,小鸡三只1元
  2. 用100元买100只鸡,给出所有的购买方案

实现代码: 

while True:
    try:
        n = int(input())
        for i in range(21):
            for j in range(34):
                for k in range(101):
                    if 5*i + 3*j + 1*k/3 == 100 and i + j + k == 100:
                        print(i, j, k)
    except:
        break

HJ76 尼科彻斯定理 

描述

验证尼科彻斯定理,即:任何一个整数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个连续奇数之和的形式输出。

数据范围:1≤�≤100 1≤m≤100 

进阶:时间复杂度:�(�) O(m) ,空间复杂度:�(1) O(1) 

输入描述:

输入一个int整数

输出描述:

输出分解后的string

示例1

输入:
6

输出:
31+33+35+37+39+41

实现代码:

n = int(input())
for i in range(n*n*n):
    if(n*i + n*(n-1) == n*n*n):#连续的n个奇数相加:i+(i+2)+...+(i+(n-1)*2) = n*i + n(n-1)
        print(i, end='')
        for j in range(1,n):#相等开始输出连续n-1个数字
            print('+' + str(i + 2*j), end='')

HJ80 整型数组合并 

描述

题目标题:

将两个整型数组按照升序合并,并且过滤掉重复数组元素。

输出时相邻两数之间没有空格。

输入描述:

输入说明,按下列顺序输入:
1 输入第一个数组的个数
2 输入第一个数组的数值
3 输入第二个数组的个数
4 输入第二个数组的数值

输出描述:

输出合并之后的数组

示例1

输入:
3
1 2 5
4
-1 0 3 2

输出:
-101235

实现代码: 

n1 = int(input())
num1 = list(map(int, input().split()))
n2 = int(input())
num2 = list(map(int, input().split()))

res = set(num1 + num2)
res = sorted(res)
for i in res:
    print(i, end="")

HJ91 走方格的方案数

描述

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

注:沿棋盘格之间的边缘线行走

数据范围: 1≤�,�≤8 1≤n,m≤8 

输入描述:

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

输出描述:

输出一行结果

示例1

输入:
2 2

输出:
6

实现代码: 

def fun(x,y):
    if(x == 0 or y == 0):
        return 1
    else:
        return fun(x-1, y)+fun(x, y-1)
while True:
    try:
        n, m = map(int, input().split())
        print(fun(n, m))
    except:
        break

HJ108 求最小公倍数 

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

数据范围:1≤�,�≤100000 1≤a,b≤100000 

输入描述:

输入两个正整数A和B。

输出描述:

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

示例1

输入:
5 7

输出:
35

示例2 

输入:
2 4

输出:
4

思路:

 

实现代码:

def gcd(m, n):#最大公约数
    if(n == 0):
        return m
    else:
        return gcd(n, m % n)
def lcm(a, b):#最小公倍数
    return (a * b) / gcd(a, b)
while True:
    try:
        A , B = map(int, input().split())
        print(int(lcm(A, B)))
    except:
        break

 HJ61 放苹果

描述

把m个同样的苹果放在n个同样的盘子里,允许有的盘子空着不放,问共有多少种不同的分法?

注意:如果有7个苹果和3个盘子,(5,1,1)和(1,5,1)被视为是同一种分法。

数据范围: 0≤m≤10 , 1≤n≤10 。

输入描述:

输入两个int整数

输出描述:

输出结果,int型

示例1

输入:
7 3

输出:
8

实现代码: 

def fun(m, n):#m个苹果放入n个盘子
# 如果没有苹果了或只有1个苹果,则方案数返回1;如果只有一个盘子了,剩下的苹果必须全放盘子里,因此也只剩下一种方案
    if(m == 0 or m == 1 or n == 1):
        return 1
#如果盘子数量多于苹果,说明必定有n-m个盘子会空着,因此必定的事情不会影响方案数
    elif(m < n ):#当苹果m的个数小于盘子个数n时,最少有n-m空盘子,这些空盘子对结果没有影响,所在只要在意如何把m个苹果放入m个盘子里
        return fun(m, m)
#如果苹果多,则要考虑盘子中是否要放苹果,如果空一个,则要递归(m,n-1);如果不空,则相当于所有盘子都要放至少一个苹果,这个条件等价于所有盘子都少掉一个苹果的方案数
    else:#当苹果m的个数超过盘子个数n时,分盘子有空的和盘子放满两种情况
        return fun(m, n-1) + fun(m-n, n)
while True:
    try:
        m, n = map(int, input().split())
        print(fun(m, n))
    except:
        break

2、中等题

HJ26 字符串排序

描述

编写一个程序,将输入字符串中的字符按如下规则排序。

规则 1 :英文字母从 A 到 Z 排列,不区分大小写。

如,输入: Type 输出: epTy

规则 2 :同一个英文字母的大小写同时存在时,按照输入顺序排列。

如,输入: BabA 输出: aABb

规则 3 :非英文字母的其它字符保持原来的位置。
 

如,输入: By?e 输出: Be?y

数据范围:输入的字符串长度满足 1≤�≤1000 1≤n≤1000 

输入描述:

输入字符串

输出描述:

输出字符串

示例1

输入:
A Famous Saying: Much Ado About Nothing (2012/8).

输出:
A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).

实现代码: 

s = input()
s_char = []
res = ''
for i in s:#先筛选出来字母字符
    if(i.isalpha()):
        s_char.append(i)
# s_char.sort(key=lambda x: x.upper())
s_char.sort(key=lambda x:x.lower())#全转成小写再排序
j = 0
for i in s:
    if(i.isalpha()):
        res += s_char[j]
        j += 1
    else:
        res += i
print(res)

HJ92 在字符串中找出连续最长的数字串

描述

输入一个字符串,返回其最长的数字子串,以及其长度。若有多个最长的数字子串,则将它们全部输出(按原字符串的相对位置)

本题含有多组样例输入。

数据范围:字符串长度 1≤�≤200 1≤n≤200  , 保证每组输入都至少含有一个数字

输入描述:

输入一个字符串。1<=len(字符串)<=200

输出描述:

输出字符串中最长的数字字符串和它的长度,中间用逗号间隔。如果有相同长度的串,则要一块儿输出(中间不要输出空格)。

示例1

输入:
abcd12345ed125ss123058789
a8a72a6a5yy98y65ee1r2

输出:
123058789,9
729865,2

说明:
样例一最长的数字子串为123058789,长度为9
样例二最长的数字子串有72,98,65,长度都为2    

 实现代码:

while True:
    try:
        s = input()
        dic = {}
        for i in s:
            if i.isdigit() == False:
                s = s.replace(i, " ")
        res = s.split(" ")
        for j in res:
            dic[j] = len(j)
        dic = sorted(dic.items(), key=lambda x: x[1], reverse=True)  # 倒序排序最长的子串在第一个
        maxLen = dic[0][1]
        temp = ""
        for k, v in dic:
            if v == maxLen:
                temp += k
        # print(temp + "," + str(maxLen))
        print(temp + ',', end='')
        print(maxLen)
        
    except:
        break

二、笔试真题篇

三、面试篇

物联沃分享整理
物联沃-IOTWORD物联网 » 华为暑期实习

发表评论