华为OD机试之刷题之路（每日一题）

说明：文章只写了题目标题，可以在牛客上搜索题目的完整描述：
https://www.nowcoder.com/ta/huawei
以下题目均为初级和中级难度（初级难度可能不会写思路）。

1. 整数与IP地址之间的转换：

思路：使用了bin(), int(), zfill()等内置函数，前两个函数能够实现十进制与二级制之间的转换，zfill函数能够进行补0操作
代码：

def ip_v_input(ip_v):
    if '.' in ip_v:
        res = ''
        ip_v_l = ip_v.split('.')
        for i in ip_v_l:
            i = bin(int(i))[2:].zfill(8)
            res += i
        print(int(res, 2))
    else:
        res = bin(int(ip_v))[2:].zfill(32)
        res_l = []
        for i in range(len(res)):
            res_l.append(res[i*8: (i+1)*8])
            if i >=3:
                break
        res_l = [str(int(i, 2)) for i in res_l]
        print('.'.join(res_l))
    
while True:
    try:
        ip_v = input().split()
        ip_v = ip_v[0]
        ip_v_input(ip_v)
    except:
        break

2. 坐标移动：

思路：判断每一个坐标输入是否合规，如果合规，再判断输入是以哪个字母开头，在各自分支进行对应运算
代码：

from types import CodeType
import re


x_value, y_value = 0, 0
str_l = input().split(';')

for item in str_l:
    flag = re.findall(r'^[ASWD]{1}[0-9]{1,2}$', item)
    if flag:
        nums = int(re.findall(r'(\d+)', item)[0])
        if item.startswith('A'):
            x_value -= nums
        elif item.startswith('D'):
            x_value += nums
        elif item.startswith('W'):
            y_value += nums
        elif item.startswith('S'):
            y_value -= nums
    else:
        continue
print(f"{x_value},{y_value}")

3. 密码验证合格：

思路：定义几个函数，来判定密码中是否含有数字，大小写字母；再定义一个判断是否有相同子串的函数
代码：

from os import ST_RELATIME
import re


def panduan1(s_str):
    flag = re.findall(r'[a-z]+', s_str)
    if flag:
        return True
    else:
        return False

def panduan2(s_str):
    flag = re.findall(r'[A-Z]+', s_str)
    if flag:
        return True
    else:
        return False

def panduan3(s_str):
    flag = re.findall(r'[0-9]+', s_str)
    if flag:
        return True
    else:
        return False

def panduan4(s_str):
    other_str = []
    for i in s_str:
        if panduan1(i) or panduan2(i) or panduan3(i):
            continue
        else:
            other_str.append(i)
    if other_str:
        return True
    else:
        return False

def check_str(s_str):
    for i in range(len(s_str)):
        str_1 = s_str[i: i+3]
        str_2 = s_str[i+3:]
        if str_1 in str_2:
            return False
    return True

while True:
    try:
        str_l = input().split()
        s_str = str_l[0]

        if len(s_str) <= 8:
            print('NG')
        else:
            res = [panduan1(s_str), panduan2(s_str), panduan3(s_str),panduan4(s_str)]
            res_num = 0
            for item in res:
                if item:
                    res_num += 1
            if res_num >= 3 and check_str(s_str):
                print('OK')
            else:
                print('NG')
    except:
        break

4. 删除字符串中出现次数最少的字符：

思路：将输入的字符串转为列表，去重，创建以列表元素为键，值为0的字典，遍历字符串，计算字符串中每个元素的个数，最后再做排序删除处理
代码：

s_str = input().split()
s_str = s_str[0]
str_l = []

for s in s_str:
    str_l.append(s)
 
str_l = list(set(str_l))
str_dir = {}
for i in str_l:
    str_dir[i] = 0

for i in str_l:
    for j in s_str:
        if i == j:
            str_dir[i] += 1

str_dir_sort = sorted(str_dir.items(), key = lambda x:x[1])
min_v = str_dir_sort[0][1]
remove_s = [] 
for i in str_dir_sort:
    if i[1] == min_v:
        remove_s.append(i[0])

new_s = ''
for i in s_str:
    if i not in remove_s:
        new_s += i

print(new_s)

5. 输入整型数组和排序标识，对其元素按照升序或降序进行排序

思路： 使用sorted()函数，默认为升序排列，当reverse=True为降序排列

def my_sort(num_l, flag):
    num_l = [int(i) for i in num_l]
    if flag == '0':
        new_l = sorted(num_l)
    else:
        new_l = sorted(num_l, reverse=True)
    new_l = [str(i) for i in new_l]
    print(' '.join(new_l))
while True:
    try:
        nums = input()
        num_l = input().split()
        flag = input()
        my_sort(num_l, flag)
    except:
        break

6. leetcode 1839 最长子字符串

题目链接：https://leetcode.cn/problems/longest-substring-of-all-vowels-in-order/
思路：
想法就是把所有的连续相同字符缩减为1， 然后另外给出一个计数器，当符合‘aeiou’的时候就更新最大值。
比如：aeiaaioaaaaeiiiiouuuooaauuaeiu
缩减为：aeiaioaeiouoauaeiu 和 [1,1,1,2,1,1,4,1,4,1,3,2,2,2,1,1,1,1]
显然缩减后的字符串只有一个'aeiou'在 6-10，计数得 4+1+4+1+3 = 13

# import re


# class Solution:
#     def longestBeautifulSubstring(self, word: str) -> int:
#         if len(word) < 5:
#             return 0
#         res = re.findall(r'a+e+i+o+u+', word)
#         if res:
#             if len(res) > 1:
#                 # res = sorted(res, key = lambda x:len(x))
#                 # res = res[-1]
#                 res = max([len(i) for i in res])
#                 # res_num = len(res)
#                 return res
#             else:
#                 res = res[0]
#                 res_num = len(res)
#                 return res_num
#         else:
#             return 0
# 以上被注释部分，只能通过部分用例，当测试word字符特别长的时候，会超时。
class Solution:
    def longestBeautifulSubstring(self, word: str) -> int:
        new_word = ''
        count = []
        for i in range(len(word)):
            if i == 0 or word[i] != word[i-1]:
                new_word += word[i]
                count.append(1)
            else:
                count[-1] += 1
        res = 0
        for i in range(len(new_word)-4):
            if new_word[i:i+5] == 'aeiou':
                res = max(res, sum(count[i:i+5]))
        return res

7. HJ46 截取字符串

input_str = input()
input_num = input()

print(input_str[0:int(input_num)])

8. 合并表记录：

思路：这个主要是考察输入输出，动态输入n组键值对；由于将相同索引的值合并，所以可以用字典来合并存储，索引若不是字典的键，则增加键，若已存在，则合并该索引对应的值。

nums = int(input())
list_a = []
for i in range(nums):
    list_a.append(list(map(int,input().split())))
# print(list_a)
dict_a = {}
for i in list_a:
    if i[0] not in dict_a:
        dict_a[i[0]] = i[1]
    else:
        dict_a[i[0]] += i[1]

dict_a = sorted(dict_a.items(), key=lambda x:x[0])
# print(dict_a)
for i in dict_a:
    print(i[0], i[1])