devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

牛客网华为软件测试题库,牛客网华为机试题答案

作者：weixin_40725706 | 2024-04-22 14:40:07

赞

踩

牛客网华为软件测试题库,牛客网华为机试题答案

大家好，给大家分享一下牛客网华为软件测试题库，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！

目录

一、字符串（知识点）

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

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

HJ4 字符串分隔（简单）

HJ5 进制转换（简单）

HJ10 字符个数统计（简单）

HJ11 数字颠倒（简单）

HJ12 字符串反转（简单）

HJ14 字符串排序（简单）

HJ17 坐标移动（中等）

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

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

一、字符串（知识点）

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

描述

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

输入描述：

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

输出描述：

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

示例1

输入：hello nowcoder

输出：8

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

  1. import sys
  2.  
  3. a = input().split()
  4. print(len(a[-1]))

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

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

描述

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

数据范围：1≤n≤1000 

输入描述：

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

输出描述：

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

示例1

输入：ABCabc

           A

输出：2

  1. import sys
  2.  
  3. st1 = input().lower()
  4. st2 = input().lower()
  5. print(st1.count(st2))

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

HJ4 字符串分隔（简单）

描述

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

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

输入描述：

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

输出描述：

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

示例1

输入：abc

输出：abc00000

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

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

HJ5 进制转换（简单）

描述

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

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

输入描述：

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

输出描述：

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

示例1

输入：0xAA

输出：170

  1. import sys
  2.  
  3. while True:
  4.     try:
  5.         a = input()
  6.         print(int(a,16))
  7.     except:
  8.         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

  1. str = input()
  2. lst = set(str)
  3. print(len(lst))

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

HJ11 数字颠倒（简单）

描述

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

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

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

输入描述：

输入一个int整数

输出描述：

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

示例1

输入：1516000

输出：0006151

示例2

输入：0

输出：0

  1. a = input()
  2. b = a[::-1]
  3. print(b)
  4.

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

HJ12 字符串反转（简单）

描述

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

输入描述：

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

输出描述：

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

示例1

输入：abcd

输出：dcba

  1. while True:
  2.     try:
  3.         str = input()
  4.         for i in str:
  5.             # islower()判断字符串中是否含有一个小写字母，所以利用循环逐个判断
  6.             if not i.islower():  
  7.                 break  # 如果有一个不为小写字母，则重新输入
  8.         if i.islower():  # 如果最后一个i为小写字母，那么代表全都为小写字母，则逆序输出
  9.             print(str[::-1])
  10.     except:
  11.         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
  1. # 法一：
  2. n = int(input())
  3. list = []
  4. for i in range(n):
  5.     str = input()  # 一行一行输入字符串
  6.     list.append(str)  # 添加成列表
  7. list.sort()  # 将列表里的字符串排序
  8. for j in list:
  9.     print(j)  # 一行一行输出字符串
  10.  
  11. # 法二：
  12. n = int(input())
  13. list = []
  14. for i in range(n):
  15.     list.append(input())
  16. 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

  1. str = input()
  2. list = str.split(";")  # 按分隔符分割字符串，返回列表
  3. x = 0
  4. y = 0
  5. for i in list:
  6.     # 如果不满足2、3的长度就跳过（满足：A11）
  7.     if len(i) not in [2, 3]:
  8.         continue
  9.     try:  #避免类型转换错误，如果不能转换就跳转到except，直接pass
  10.         direction = i[0].lower()
  11.         step = int(i[1:])
  12.  
  13.         # 判断每个操作的长度是否合规、是否为空、方向是否正确
  14.         if i != '' and direction in ['a', 'd', 's', 'w']:
  15.             if direction == 'a':
  16.                 x -= step
  17.             elif direction == 'd':
  18.                 x += step
  19.             elif direction == 's':
  20.                 y -= step
  21.             elif direction == 'w':
  22.                 y += step
  23.     except:
  24.         continue  # 如果异常就跳过这条
  25. 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地址和掩码，用~隔开。

请参考帖子https://www.nowcoder.com/discuss/276处理循环输入的问题。

输出描述：

统计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地址，计数时请忽略         
  1. # HJ18 识别有效的IP地址和掩码并进行分类统计
  2. import sys
  3.  
  4.  
  5. # 检查IP是否合规，不合规返回false
  6. def check_ip(ip):
  7.     # 先划分部位
  8.     ip_list = ip.split('.')
  9.     # ip长度有4位，且每一位不为空，不满足条件就返回FALSE
  10.     if len(ip_list) != 4 or '' in ip_list:
  11.         return False
  12.     # 遍历每一位，判断范围是否属于0-255（最基本的规则）
  13.     for i in ip_list:
  14.         try:  # 如果输入非数字，异常->FALSE不合规
  15.             if int(i) < 0 or int(i) > 255:  # 不属于这个范围的就返回FALSE
  16.                 return False
  17.         except:
  18.             return False
  19.     return True
  20.  
  21.  
  22. # 检查掩码是否合规，不合规返回false
  23. def check_mask(mask):
  24.     # 先判断掩码是否合规（按IP的方法）
  25.     if not check_ip(mask):
  26.         return False
  27.     # 全255和全0的都视为非法
  28.     if mask == '255.255.255.255' or mask == '0.0.0.0':
  29.         return False
  30.     # 划分掩码部位，将每部分都转化为二进制
  31.     mask_list = mask.split('.')
  32.     mask_bit = []
  33.     for i in mask_list:
  34.         try:
  35.             j = bin(int(i))[2:]  # 每段都转换为二进制(j:'ob11111111')，所以还要去掉前面两个二进制前缀'ob'
  36.             mask_bit.append(j.zfill(8))  # zfill(n)返回n个长度的字符串，右对齐，左填充0
  37.         except:
  38.             return False
  39.     whole_mask = ''.join(mask_bit)  # 将4段二进制连接起来的字符串
  40.     # 查第一个0的位置
  41.     whole_find_0 = whole_mask.find('0')
  42.     # 查最后一个1的位置
  43.     whole_rfind_1 = whole_mask.rfind('1')
  44.     # 如果最后一个1之后就是第一个0的位置，则表示0前面都是1，掩码合规
  45.     if whole_rfind_1 + 1 == whole_find_0:
  46.         return True
  47.     else:
  48.         return False
  49.  
  50.  
  51. # 检查IP分类是否为私网（已经满足IP规格）
  52. def check_private_ip(ip):
  53.     try:
  54.         # 划分部位
  55.         ip_list = ip.split('.')
  56.         if ip_list[0] == '10':
  57.             return True
  58.         elif ip_list[0] == '172' and 16 <= int(ip_list[1]) <= 31:
  59.             return True
  60.         elif ip_list[0] == '192' and ip_list[1] == '168':
  61.             return True
  62.         else:
  63.             return False
  64.     except:
  65.         return False
  66.  
  67.  
  68. ip_class_dic = {
  69.     'a': 0,
  70.     'b': 0,
  71.     'c': 0,
  72.     'd': 0,
  73.     'e': 0,
  74.     'error': 0,
  75.     'private': 0
  76. }
  77.  
  78. # 从标准输入读取多行数据，直到遇到EOF结束标志(ctrl+D结束输入)，可在控制台与用户交互并读取用户的输入
  79. for line in sys.stdin:  # 输入一行读一行，如果输入有异常(不满足输入格式的话，例如没有掩码）则结束循环输入
  80.     try:  # 如果出现异常则结束循环（结束输入）
  81.         ip = line.split('~')[0]  # IP
  82.         mask = line.split('~')[1]  # 掩码（此时会将换行符\n算进来，但没关系，后面是用数字计算的）
  83.  
  84.         # 1.1先判断IP地址是否合规
  85.         if check_ip(ip):
  86.             # 2.1如果合规就按第一部分进行分类
  87.             first = int(ip.split('.')[0])
  88.             # 2.2这两个不计
  89.             if first == 0 or first == 127:
  90.                 continue  # 表示进行下一个输入
  91.             # 2.3再判断掩码是否合规，如果掩码也合规，则判断IP类型
  92.             if check_mask(mask):
  93.                 # 3.1先判断是否为私有IP（必须判断），是则私网+1
  94.                 if check_private_ip(ip):
  95.                     ip_class_dic['private'] += 1
  96.                 # 3.2再判断是abcde类型中的哪种（必须判断）
  97.                 if 0 < first < 127:
  98.                     ip_class_dic['a'] += 1
  99.                 elif 127 < first <= 191:
  100.                     ip_class_dic['b'] += 1
  101.                 elif 192 <= first <= 223:
  102.                     ip_class_dic['c'] += 1
  103.                 elif 224 <= first <= 239:
  104.                     ip_class_dic['d'] += 1
  105.                 elif 240 <= first <= 255:
  106.                     ip_class_dic['e'] += 1
  107.             # 2.4如果（IP合规）掩码不合规，则error+1
  108.             else:
  109.                 ip_class_dic['error'] += 1
  110.         # 1.2如果IP不合规，则error+1
  111.         else:
  112.             ip_class_dic['error'] += 1
  113.     except:
  114.         break
  115.  
  116. # 最后将字典里的值循环输出
  117. for i in ip_class_dic.values():
  118.     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和文件读取的区别

  1. # 读取普通文件
  2. with open('data'.txt) as f:
  3.     lines = f.readlines()
  4.     for line in lines:
  5.         print(line)
  6.  
  7.  
  8. # 读取标准输入
  9. import sys
  10.  
  11. for line in sys.stdin:  # 循环读取，输入一行读一行
  12.     print(line)
  13.  
  14. for line in sys.stdin.readlines():  # 输入一堆文本，一行一行读
  15.     print(line)

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览60402 人正在系统学习中
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/469049
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号