华为牛客网python考试题库及答案

亲爱的朋友们，今天我们要讨论，牛客网华为软件测试题库 牛客网华为机试题答案，让我们开始吧！

目录

一、字符串（知识点）

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

HJ2 计算某字符出现次数（简单）

HJ4 字符串分隔（简单）

HJ5 进制转换（简单）

HJ10 字符个数统计（简单）

HJ11 数字颠倒（简单）

HJ12 字符串反转（简单）

HJ14 字符串排序（简单）

HJ17 坐标移动（中等）

HJ18 识别有效的IP地址和掩码并进行分类统计（较难）

自己研究的题解，也有借鉴评论区牛人思路，答案不唯一，仅供学习参考，也欢迎大家指出问题，共同学习

一、字符串（知识点）

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

描述

计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000python源码库。（注：字符串末尾不以空格为结尾）

输入描述：

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

输出描述：

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

示例1

输入：hello nowcoder

输出：8

说明：最后一个单词为nowcoder，长度为8

import sys

a = input().split()
print(len(a[-1]))

分析：利用split将字符串按空格拆分成一个列表，再利用len和[-1]取最后一个字符串的长度。

HJ2 计算某字符出现次数（简单）

描述

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

数据范围：1≤n≤1000 

输入描述：

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

输出描述：

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

示例1

输入：ABCabc

           A

输出：2

import sys

st1 = input().lower()
st2 = input().lower()
print(st1.count(st2))

分析：将两次输入都小写化（lower），以至于不用区分大小写，再利用st1.count(st2)，意为st2在st1中的个数。

HJ4 字符串分隔（简单）

描述

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

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

输入描述：

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

输出描述：

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

示例1

输入：abc

输出：abc00000

import sys

#   :0<8s  格式左对齐 右补0 输出8个字符串
while True:
    try:
        l = input()
        for i in range(0, len(l), 8):  #间隔8
            print("{:0<8s}".format(l[i:i+8]))
    except:
        break

分析：主要利用一个循环，遍历每8个字符的开头，为了输出0-8,8-16……，补0利用初始化函数format，:0<8s意为左对齐 右补0, 输出8个字符。（利用while和try的意图在于可以循环输入，直到输入一个非十六进制数，退出并且不会报错）

HJ5 进制转换（简单）

描述

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

数据范围：保证结果在 1≤n≤2**31−1 

输入描述：

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

输出描述：

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

示例1

输入：0xAA

输出：170

import sys

while True:
    try:
        a = input()
        print(int(a,16))
    except:
        break

分析：利用int()将其他进制转换为十进制--->int(a,16)十六进制转换为十进制，int（a,8）八进制转换为十进制，int(a,2)二进制转换为十进制。bin(a)将其他进制转换为二进制。

HJ10 字符个数统计（简单）

描述

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

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

数据范围：1≤n≤500 

输入描述：

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

输出描述：

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

示例1

输入：abc

输出：3

示例2

输入：aaa

输出：1

str = input()
lst = set(str)
print(len(lst))

分析：利用集合的不重复性，将字符串类型转换为集合类型，集合的长度即不同元素的数量。

HJ11 数字颠倒（简单）

描述

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

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

数据范围：  0≤n≤2**30−1 

输入描述：

输入一个int整数

输出描述：

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

示例1

输入：1516000

输出：0006151

示例2

输入：0

输出：0

a = input()
b = a[::-1]
print(b)

分析：利用Python自带的切片逻辑实现逆序输出。

HJ12 字符串反转（简单）

描述

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

输入描述：

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

输出描述：

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

示例1

输入：abcd

输出：dcba

while True:
    try:
        str = input()
        for i in str:
            # islower()判断字符串中是否含有一个小写字母，所以利用循环逐个判断
            if not i.islower():  
                break  # 如果有一个不为小写字母，则重新输入
        if i.islower():  # 如果最后一个i为小写字母，那么代表全都为小写字母，则逆序输出
            print(str[::-1])
    except:
        break

分析：for循环逐个判断字符串是否为小写字母（利用islower()），有一个不是则重新输入，全部都是则逆序输出。

HJ14 字符串排序（简单）

描述

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

数据范围：1≤n≤1000  ，字符串长度满足 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

# 法一：
n = int(input())
list = []
for i in range(n):
    str = input()  # 一行一行输入字符串
    list.append(str)  # 添加成列表
()  # 将列表里的字符串排序
for j in list:
    print(j)  # 一行一行输出字符串

# 法二：
n = int(input())
list = []
for i in range(n):
    list.append(input())
print("\n".join(sorted(list)))

分析：利用列表sort（）排序，可以指定比较的形式和顺序，没有返回值。join（）用指定的字符连接列表元素。

HJ17 坐标移动（中等）

描述

开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

输入：

合法坐标为A(或者D或者W或者S) + 数字（两位以内）

坐标之间以;分隔。

非法坐标点需要进行丢弃。如AA10;  A1A;  $%$;  YAD; 等。

下面是一个简单的例子 如：

A10;S20;W10;D30;X;A1A;B10A11;;A10;

处理过程：

起点（0,0）

+   A10   =  （-10,0）

+   S20   =  (-10,-20)

+   W10  =  (-10,-10)

+   D30  =  (20,-10)

+   x    =  无效

+   A1A   =  无效

+   B10A11   =  无效

+  一个空 不影响

+   A10  =  (10,-10)

结果 （10， -10）

数据范围：每组输入的字符串长度满足 1≤n≤10000  ，坐标保证满足 −2**31≤x, y≤2**31−1  ，且数字部分仅含正数

输入描述：

一行字符串

输出描述：

最终坐标，以逗号分隔

示例1

输入：A10;S20;W10;D30;X;A1A;B10A11;;A10;

输出：10,-10

示例2

输入：ABC;AKL;DA1;

输出：0,0

str = input()
list = str.split(";")  # 按分隔符分割字符串，返回列表
x = 0
y = 0
for i in list:
    # 如果不满足2、3的长度就跳过（满足：A11）
    if len(i) not in [2, 3]:
        continue
    try:  #避免类型转换错误，如果不能转换就跳转到except，直接pass
        direction = i[0].lower()
        step = int(i[1:])

        # 判断每个操作的长度是否合规、是否为空、方向是否正确
        if i != '' and direction in ['a', 'd', 's', 'w']:
            if direction == 'a':
                x -= step
            elif direction == 'd':
                x += step
            elif direction == 's':
                y -= step
            elif direction == 'w':
                y += step
    except:
        continue  # 如果异常就跳过这条
print(f'{x},{y}')

分析：抓住过滤的条件，非空、字符串长度、以asdw开头，借助异常捕获筛掉后两位不为数字的字符串。

HJ18 识别有效的IP地址和掩码并进行分类统计（较难）

描述

请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址从1.0.0.0到126.255.255.255;

B类地址从128.0.0.0到191.255.255.255;

C类地址从192.0.0.0到223.255.255.255;

D类地址从224.0.0.0到239.255.255.255；

E类地址从240.0.0.0到255.255.255.255

私网IP范围是：

从10.0.0.0到10.255.255.255

从172.16.0.0到172.31.255.255

从192.168.0.0到192.168.255.255

子网掩码为二进制下前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）

（注意二进制下全是1或者全是0均为非法子网掩码）

注意：

1. 类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略

2. 私有IP地址和A,B,C,D,E类地址是不冲突的

输入描述：

多行字符串。每行一个IP地址和掩码，用~隔开。

请参考帖子处理循环输入的问题。

输出描述：

统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。

示例1

输入：

10.70.44.68~255.254.255.0
1.0.0.1~255.0.0.0
192.168.0.2~255.255.255.0
19..0.~255.255.255.0

输出：

1 0 1 0 0 2 1

说明：

10.70.44.68~255.254.255.0的子网掩码非法，19..0.~255.255.255.0的IP地址非法，所以错误IP地址或错误掩码的计数为2；
1.0.0.1~255.0.0.0是无误的A类地址；
192.168.0.2~255.255.255.0是无误的C类地址且是私有IP；
所以最终的结果为1 0 1 0 0 2 1        

示例2

输入：

0.201.56.50~255.255.111.255
127.201.56.50~255.255.111.255

输出：

0 0 0 0 0 0 0

说明：

类似于【0.*.*.*】和【127.*.*.*】的IP地址不属于上述输入的任意一类，也不属于不合法ip地址，计数时请忽略         

# HJ18 识别有效的IP地址和掩码并进行分类统计
import sys


# 检查IP是否合规，不合规返回false
def check_ip(ip):
    # 先划分部位
    ip_list = ip.split('.')
    # ip长度有4位，且每一位不为空，不满足条件就返回FALSE
    if len(ip_list) != 4 or '' in ip_list:
        return False
    # 遍历每一位，判断范围是否属于0-255（最基本的规则）
    for i in ip_list:
        try:  # 如果输入非数字，异常->FALSE不合规
            if int(i) < 0 or int(i) > 255:  # 不属于这个范围的就返回FALSE
                return False
        except:
            return False
    return True


# 检查掩码是否合规，不合规返回false
def check_mask(mask):
    # 先判断掩码是否合规（按IP的方法）
    if not check_ip(mask):
        return False
    # 全255和全0的都视为非法
    if mask == '255.255.255.255' or mask == '0.0.0.0':
        return False
    # 划分掩码部位，将每部分都转化为二进制
    mask_list = mask.split('.')
    mask_bit = []
    for i in mask_list:
        try:
            j = bin(int(i))[2:]  # 每段都转换为二进制(j:'ob11111111')，所以还要去掉前面两个二进制前缀'ob'
            mask_bit.append(j.zfill(8))  # zfill(n)返回n个长度的字符串，右对齐，左填充0
        except:
            return False
    whole_mask = ''.join(mask_bit)  # 将4段二进制连接起来的字符串
    # 查第一个0的位置
    whole_find_0 = ('0')
    # 查最后一个1的位置
    whole_rfind_1 = whole_mask.rfind('1')
    # 如果最后一个1之后就是第一个0的位置，则表示0前面都是1，掩码合规
    if whole_rfind_1 + 1 == whole_find_0:
        return True
    else:
        return False


# 检查IP分类是否为私网（已经满足IP规格）
def check_private_ip(ip):
    try:
        # 划分部位
        ip_list = ip.split('.')
        if ip_list[0] == '10':
            return True
        elif ip_list[0] == '172' and 16 <= int(ip_list[1]) <= 31:
            return True
        elif ip_list[0] == '192' and ip_list[1] == '168':
            return True
        else:
            return False
    except:
        return False


ip_class_dic = {
    'a': 0,
    'b': 0,
    'c': 0,
    'd': 0,
    'e': 0,
    'error': 0,
    'private': 0
}

# 从标准输入读取多行数据，直到遇到EOF结束标志(ctrl+D结束输入)，可在控制台与用户交互并读取用户的输入
for line in sys.stdin:  # 输入一行读一行，如果输入有异常(不满足输入格式的话，例如没有掩码）则结束循环输入
    try:  # 如果出现异常则结束循环（结束输入）
        ip = line.split('~')[0]  # IP
        mask = line.split('~')[1]  # 掩码（此时会将换行符\n算进来，但没关系，后面是用数字计算的）

        # 1.1先判断IP地址是否合规
        if check_ip(ip):
            # 2.1如果合规就按第一部分进行分类
            first = int(ip.split('.')[0])
            # 2.2这两个不计
            if first == 0 or first == 127:
                continue  # 表示进行下一个输入
            # 2.3再判断掩码是否合规，如果掩码也合规，则判断IP类型
            if check_mask(mask):
                # 3.1先判断是否为私有IP（必须判断），是则私网+1
                if check_private_ip(ip):
                    ip_class_dic['private'] += 1
                # 3.2再判断是abcde类型中的哪种（必须判断）
                if 0 < first < 127:
                    ip_class_dic['a'] += 1
                elif 127 < first <= 191:
                    ip_class_dic['b'] += 1
                elif 192 <= first <= 223:
                    ip_class_dic['c'] += 1
                elif 224 <= first <= 239:
                    ip_class_dic['d'] += 1
                elif 240 <= first <= 255:
                    ip_class_dic['e'] += 1
            # 2.4如果（IP合规）掩码不合规，则error+1
            else:
                ip_class_dic['error'] += 1
        # 1.2如果IP不合规，则error+1
        else:
            ip_class_dic['error'] += 1
    except:
        break

# 最后将字典里的值循环输出
for i in ip_class_dic.values():
    print(i, end=' ')

分析：（该题较难，掌握字符串的基本应用即可。）

主要思路：循环输入，分割变量，判断ip、掩码、私网、类型

1.检查是否符合ip规格，否->error+1，是则2，不计直接continue

2.检查是否符合掩码规格，否->error+1，是则3

3.判断是否私网，判断是哪个类型的地址。（分别判断）否->error+1

4.用字典来表示变量

注：ip和掩码都符合规格才算是合法地址，才分类，有一个不符合规格就是非法+1（先判断ip，不合法直接error+1，如果ip合法，再判断掩码，掩码不合法直接error+1，如果掩码合法，再看ip地址是属于哪个类型）

拓展：sys.stdin和文件读取的区别

# 读取普通文件
with open('data'.txt) as f:
    lines = f.readlines()
    for line in lines:
        print(line)


# 读取标准输入
import sys

for line in sys.stdin:  # 循环读取，输入一行读一行
    print(line)

for line in sys.stdin.readlines():  # 输入一堆文本，一行一行读
    print(line)

原文地址1：https://blog.csdn.net/weixin_51754286/article/details/134668942
参考资料：python中用turtle画一个圆形 https://blog.csdn.net/SXIAOYAN_/article/details/140061099