2023年度最全面的华为OD机试真题汇总，高效掌握核心技能！

2024-01-04 19:47:03

华为OD机试真题汇总：掌握核心技能，助力求职成功！

对于有志于加入华为的求职者而言，华为OD机试无疑是一场不容小觑的挑战。作为华为招聘流程中的重要环节，OD机试旨在考察应聘者的技术能力和综合素质。掌握华为OD机试的核心技能，对于求职者在竞争激烈的求职市场中脱颖而出至关重要。

基础题篇：夯实编程基础

华为OD机试基础题主要考察应聘者的编程基础和算法能力。以下列举了三道基础题，供大家参考和练习：

基础题1：找出数组中的最小数字

def find_min(arr):
    min_value = arr[0]
    for i in range(1, len(arr)):
        if arr[i] < min_value:
            min_value = arr[i]
    return min_value

print(find_min([1, 2, 3, 4, 5]))  # Output: 1

基础题2：统计字符串中出现最多的字符

def find_most_frequent_char(string):
    char_counts = {}
    for char in string:
        if char not in char_counts:
            char_counts[char] = 0
        char_counts[char] += 1

    max_count = 0
    most_frequent_char = None
    for char, count in char_counts.items():
        if count > max_count:
            max_count = count
            most_frequent_char = char

    return most_frequent_char

print(find_most_frequent_char("Hello, world!"))  # Output: 'l'

基础题3：找出数组中的最大连续子数组和

def find_max_subarray_sum(arr):
    max_so_far = arr[0]
    max_ending_here = arr[0]

    for i in range(1, len(arr)):
        max_ending_here = max(max_ending_here + arr[i], arr[i])
        max_so_far = max(max_so_far, max_ending_here)

    return max_so_far

print(find_max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4]))  # Output: 6

进阶题篇：突破编程瓶颈

进阶题是对应聘者编程能力的进一步考验，涉及数据结构、算法等知识点。以下列举了三道进阶题，供大家挑战和提升：

进阶题1：找出链表中出现最多的节点值

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

def find_most_frequent_node_value(head):
    node_counts = {}
    while head:
        if head.value not in node_counts:
            node_counts[head.value] = 0
        node_counts[head.value] += 1
        head = head.next

    max_count = 0
    most_frequent_node_value = None
    for node_value, count in node_counts.items():
        if count > max_count:
            max_count = count
            most_frequent_node_value = node_value

    return most_frequent_node_value

head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(1)
head.next.next.next.next = Node(2)

print(find_most_frequent_node_value(head))  # Output: 1

进阶题2：找出二叉树中出现最多的节点值

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def find_most_frequent_node_value(root):
    node_counts = {}
    def traverse(root):
        if root:
            node_counts[root.value] = node_counts.get(root.value, 0) + 1
            traverse(root.left)
            traverse(root.right)

    traverse(root)

    max_count = 0
    most_frequent_node_value = None
    for node_value, count in node_counts.items():
        if count > max_count:
            max_count = count
            most_frequent_node_value = node_value

    return most_frequent_node_value

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(1)
root.left.right = Node(2)
root.right.left = Node(3)
root.right.right = Node(1)

print(find_most_frequent_node_value(root))  # Output: 1

进阶题3：找出图中出现最多的边

class Graph:
    def __init__(self):
        self.vertices = {}

    def add_edge(self, u, v):
        if u not in self.vertices:
            self.vertices[u] = set()
        self.vertices[u].add(v)

def find_most_frequent_edge(graph):
    edge_counts = {}
    for u in graph.vertices:
        for v in graph.vertices[u]:
            edge_tuple = (u, v) if u < v else (v, u)
            edge_counts[edge_tuple] = edge_counts.get(edge_tuple, 0) + 1

    max_count = 0
    most_frequent_edge = None
    for edge_tuple, count in edge_counts.items():
        if count > max_count:
            max_count = count
            most_frequent_edge = edge_tuple

    return most_frequent_edge

graph = Graph()
graph.add_edge(1, 2)
graph.add_edge(2, 3)
graph.add_edge(3, 1)
graph.add_edge(2, 4)
graph.add_edge(4, 5)
graph.add_edge(5, 2)

print(find_most_frequent_edge(graph))  # Output: (2, 3)