当前位置: 首页 > article >正文

【2024年华为OD机试】(B卷,100分)- 热点网站统计(Java JS PythonC/C++)

在这里插入图片描述

一、问题描述

题目描述

企业路由器的统计页面需要动态统计公司访问最多的网页URL的Top N。设计一个算法,能够高效动态统计Top N的页面。

输入描述

每一行都是一个URL或一个数字:

  • 如果是URL,代表一段时间内的网页访问。
  • 如果是数字N,代表本次需要输出的Top N个URL。

输入约束:

  1. 总访问网页数量小于5000个,单网页访问次数小于65535次。
  2. 网页URL仅由字母、数字和点分隔符组成,且长度小于等于127字节。
  3. 数字是正整数,小于等于10且小于当前总访问网页数。

输出描述

每行输入对应一行输出,输出按访问次数排序的前N个URL,用逗号分隔。

输出要求:

  1. 每次输出要统计之前所有输入,而不仅仅是本次输入。
  2. 如果有访问次数相等的URL,按URL的字符串字典序升序排列,输出排序靠前的URL。

用例

用例 1

输入:

news.qq.com
news.sina.com.cn
news.qq.com
news.qq.com
game.163.com
game.163.com
www.huawei.com
www.cctv.com
3
www.huawei.com
www.cctv.com
www.huawei.com
www.cctv.com
www.huawei.com
www.cctv.com
www.huawei.com
www.cctv.com
www.huawei.com
3

输出:

news.qq.com,game.163.com,news.sina.com.cn
www.huawei.com,www.cctv.com,news.qq.com

说明:

  • 第一次输出时,统计了之前所有输入的URL访问次数,输出Top 3。
  • 第二次输出时,继续统计了所有输入的URL访问次数,输出Top 3。

用例 2

输入:

news.qq.com
www.cctv.com
1
www.huawei.com
www.huawei.com
2
3

输出:

news.qq.com
www.huawei.com,news.qq.com
www.huawei.com,news.qq.com,www.cctv.com

说明:

  • 第一次输出时,统计了之前所有输入的URL访问次数,输出Top 1。
  • 第二次输出时,继续统计了所有输入的URL访问次数,输出Top 2。
  • 第三次输出时,继续统计了所有输入的URL访问次数,输出Top 3。

题目解析

核心逻辑

  1. 动态统计

    • 每次输入URL时,更新该URL的访问次数。
    • 每次输入数字N时,输出当前访问次数最多的Top N个URL。
  2. 统计范围

    • 每次输出时,统计的是之前所有输入的URL访问次数,而不仅仅是本次输入。
  3. 排序规则

    • 按访问次数从高到低排序。
    • 如果访问次数相同,按URL的字典序升序排列。
  4. 性能优化

    • 由于总访问网页数量小于5000个,单网页访问次数小于65535次,因此需要设计一个高效的算法,确保每次统计和输出的时间复杂度尽可能低。

关键点

  1. 数据结构选择

    • 使用哈希表(如unordered_map)来存储每个URL的访问次数,确保更新和查询的时间复杂度为O(1)。
    • 使用优先队列(如堆)或排序算法来快速获取Top N的URL。
  2. 动态更新

    • 每次输入URL时,更新哈希表中的访问次数。
    • 每次输入数字N时,从哈希表中提取所有URL及其访问次数,进行排序并输出Top N。
  3. 排序规则实现

    • 在排序时,先按访问次数降序排序,如果访问次数相同,再按URL的字典序升序排序。
  4. 输出格式

    • 输出时,将Top N的URL用逗号分隔。

注意事项

  1. 统计范围

    • 每次输出时,统计的是之前所有输入的URL访问次数,而不仅仅是本次输入。
  2. 性能优化

    • 由于总访问网页数量较大(最多5000个),单网页访问次数较多(最多65535次),需要确保算法的效率。
  3. 边界条件

    • 输入的数字N必须小于等于10且小于当前总访问网页数。
    • 输入的URL长度不超过127字节。

总结

本题的核心在于动态统计URL的访问次数,并在每次输入数字N时快速输出Top N的URL。通过合理选择数据结构和排序算法,可以高效地实现这一功能。

二、JavaScript算法源码

这段代码实现了一个简单的URL统计和排序功能。它通过读取用户输入,统计每个URL出现的次数,并根据用户指定的数量n,返回出现次数最多的前n个URL。以下是代码的详细注释和讲解:

// 引入readline模块,用于从标准输入读取数据
const rl = require("readline").createInterface({ input: process.stdin });

// 获取异步迭代器,用于逐行读取输入
var iter = rl[Symbol.asyncIterator]();

// 定义一个异步函数readline,用于读取下一行输入
const readline = async () => (await iter.next()).value;

// 使用立即执行函数表达式(IIFE)来执行异步代码
void (async function () {
  // 定义一个缓存对象,用于存储URL及其出现的次数
  const cache = {};

  // 进入一个无限循环,持续读取用户输入
  while (true) {
    // 等待读取下一行输入
    const line = await readline();

    // 判断输入是否为纯数字(即用户要求输出前n个URL)
    if (/^\d+$/.test(line)) {
      // 如果是数字,调用sortURL函数并输出结果
      console.log(sortURL(parseInt(line)));
    } else {
      // 如果不是数字,说明是URL,更新缓存中的统计次数
      cache[line] ? cache[line]++ : (cache[line] = 1);
    }
  }

  // 定义一个函数sortURL,用于根据URL的出现次数进行排序并返回前n个URL
  function sortURL(n) {
    // 将缓存对象转换为数组,每个元素是一个[key, value]的数组
    return Object.entries(cache)
      // 对数组进行排序
      .sort((a, b) => {
        // 首先按出现次数降序排序
        const res = b[1] - a[1];
        // 如果出现次数相同,则按URL的字典序升序排序
        return res == 0 ? (a[0] > b[0] ? 1 : -1) : res;
      })
      // 截取前n个元素
      .slice(0, n)
      // 将每个元素的key(即URL)提取出来
      .map((entry) => entry[0])
      // 将URL数组用逗号连接成一个字符串
      .join(",");
  }
})();

代码讲解:

  1. 引入readline模块

    • readline模块用于从标准输入(如终端)逐行读取数据。这里通过createInterface方法创建了一个接口,并将其输入流设置为process.stdin
  2. 异步迭代器

    • rl[Symbol.asyncIterator]()返回一个异步迭代器,允许我们使用await逐行读取输入。
  3. readline函数

    • 这是一个异步函数,每次调用时会返回输入流的下一行内容。
  4. 立即执行函数表达式 (IIFE)

    • void (async function () { ... })(); 是一个立即执行的异步函数表达式,用于在代码加载时立即执行异步操作。
  5. 缓存对象 cache

    • cache是一个普通的JavaScript对象,用于存储URL及其出现的次数。键是URL,值是该URL出现的次数。
  6. 主循环

    • 代码进入一个无限循环,不断读取用户输入。
    • 如果输入是纯数字(通过正则表达式/^\d+$/判断),则调用sortURL函数并输出结果。
    • 如果输入不是数字,则认为是URL,更新cache中该URL的计数。
  7. sortURL函数

    • 该函数接受一个参数n,表示要返回的前n个URL。
    • Object.entries(cache)cache对象转换为一个数组,数组的每个元素是一个[key, value]的数组,其中key是URL,value是出现次数。
    • sort方法对数组进行排序:
      • 首先按出现次数降序排序(b[1] - a[1])。
      • 如果出现次数相同,则按URL的字典序升序排序(a[0] > b[0] ? 1 : -1)。
    • slice(0, n)截取排序后的前n个元素。
    • map((entry) => entry[0])提取每个元素的URL。
    • join(",")将URL数组用逗号连接成一个字符串并返回。

示例运行:

假设输入如下:

https://example.com
https://example.com
https://example.org
https://example.net
https://example.net
https://example.net
2

程序会输出:

https://example.net,https://example.com

解释:

  • https://example.net出现了3次,https://example.com出现了2次,https://example.org出现了1次。
  • 用户输入2,表示要输出出现次数最多的前2个URL,因此输出https://example.net,https://example.com

总结:

这段代码通过简单的缓存和排序机制,实现了对URL出现次数的统计和排序功能。它适用于处理小规模的输入数据,但对于大规模数据,可能需要更高效的算法和数据结构。

三、Java算法源码

这段Java代码实现了一个与之前JavaScript代码类似的功能:统计URL出现的次数,并根据用户输入的正整数n,返回出现次数最多的前n个URL。以下是代码的详细注释和讲解:


代码详解

import java.util.HashMap;
import java.util.Objects;
import java.util.Scanner;
import java.util.StringJoiner;
import java.util.regex.Pattern;

public class Main {
  // 正则表达式,用于判断一个字符串是否为正整数
  static Pattern reg = Pattern.compile("^\\d+$");

  // 使用HashMap缓存每个URL及其出现次数
  static HashMap<String, Integer> cache = new HashMap<>();

  public static void main(String[] args) {
    // 创建Scanner对象,用于从标准输入读取数据
    Scanner sc = new Scanner(System.in);

    // 循环读取每一行输入
    while (sc.hasNextLine()) {
      String tmp = sc.nextLine();

      // 判断输入是否为正整数
      if (reg.matcher(tmp).find()) {
        // 如果是正整数,调用sortURL方法并输出结果
        System.out.println(sortURL(Integer.parseInt(tmp)));
      } else {
        // 如果是URL,更新缓存中的统计次数
        cache.put(tmp, cache.getOrDefault(tmp, 0) + 1);
      }
    }
  }

  // 根据URL出现次数排序并返回前n个URL
  public static String sortURL(int n) {
    // 使用StringJoiner将结果用逗号连接
    StringJoiner sj = new StringJoiner(",");

    // 对缓存中的URL进行排序
    cache.entrySet().stream()
        .sorted(
            (a, b) ->
                // 首先按出现次数降序排序
                Objects.equals(a.getValue(), b.getValue())
                    // 如果出现次数相同,则按URL的字典序升序排序
                    ? a.getKey().compareTo(b.getKey())
                    : b.getValue() - a.getValue())
        // 限制只取前n个URL
        .limit(n)
        // 提取URL
        .map(ele -> ele.getKey())
        // 将URL添加到StringJoiner中
        .forEach(url -> sj.add(url));

    // 返回最终的字符串结果
    return sj.toString();
  }
}

代码讲解

1. 正则表达式 Pattern reg
  • Pattern.compile("^\\d+$") 用于匹配一个字符串是否为正整数。
  • ^ 表示字符串的开始,\d+ 表示一个或多个数字,$ 表示字符串的结束。
  • 在代码中,reg.matcher(tmp).find() 用于判断输入字符串 tmp 是否为正整数。
2. 缓存 HashMap<String, Integer> cache
  • cache 是一个 HashMap,用于存储URL及其出现的次数。
  • 键(key)是URL(String 类型),值(value)是该URL出现的次数(Integer 类型)。
3. 主方法 main
  • 使用 Scanner 从标准输入逐行读取数据。
  • 如果输入是正整数,调用 sortURL 方法并输出结果。
  • 如果输入是URL,更新 cache 中该URL的计数:
    • cache.getOrDefault(tmp, 0):如果 tmp 已经存在于 cache 中,则返回其值;否则返回默认值 0
    • cache.put(tmp, cache.getOrDefault(tmp, 0) + 1):将URL的计数加1。
4. sortURL 方法
  • 该方法接受一个整数 n,表示要返回的前 n 个URL。
  • 使用 StringJoiner 将结果用逗号连接。
  • cache 中的URL进行排序:
    • cache.entrySet().stream():将 cache 转换为流(Stream),便于后续操作。
    • sorted(...):对流中的元素进行排序:
      • 首先按出现次数降序排序(b.getValue() - a.getValue())。
      • 如果出现次数相同,则按URL的字典序升序排序(a.getKey().compareTo(b.getKey()))。
    • limit(n):限制只取前 n 个URL。
    • map(ele -> ele.getKey()):提取每个元素的URL。
    • forEach(url -> sj.add(url)):将URL添加到 StringJoiner 中。
  • 最终返回 StringJoiner 的结果。

示例运行

假设输入如下:

https://example.com
https://example.com
https://example.org
https://example.net
https://example.net
https://example.net
2

程序会输出:

https://example.net,https://example.com

解释:

  • https://example.net 出现了3次,https://example.com 出现了2次,https://example.org 出现了1次。
  • 用户输入 2,表示要输出出现次数最多的前2个URL,因此输出 https://example.net,https://example.com

代码优化建议


总结

这段Java代码通过 HashMap 统计URL的出现次数,并通过流(Stream)对结果进行排序和限制,最终输出前 n 个URL。代码结构清晰,功能明确,适合处理小规模数据。对于大规模数据,可能需要进一步优化性能。

四、Python算法源码

这段Python代码实现了一个与之前JavaScript和Java代码类似的功能:统计URL出现的次数,并根据用户输入的正整数n,返回出现次数最多的前n个URL。以下是代码的详细注释和讲解:


代码详解

# 缓存字典,记录每个URL出现的次数
cache = {}

# 题解列表(未使用,可以删除)
ans = []

# 定义sortURL函数,用于根据URL出现次数排序并返回前n个URL
def sortURL(n):
    # 将cache字典转换为列表,每个元素是一个(key, value)的元组
    urlCount = list(cache.items())

    # 对列表进行排序
    # key=lambda x: (-x[1], x[0]) 表示:
    # 1. 首先按出现次数降序排序(-x[1])
    # 2. 如果出现次数相同,则按URL的字典序升序排序(x[0])
    urlCount.sort(key=lambda x: (-x[1], x[0]))

    # 使用map提取前n个URL,并用逗号连接成一个字符串
    return ",".join(map(lambda x: x[0], urlCount[:n]))


# 主循环,持续读取用户输入
while True:
    # 读取一行输入
    tmp = input()

    # 判断输入是否为正整数
    if tmp.isnumeric():
        # 如果是正整数,调用sortURL函数并输出结果
        print(sortURL(int(tmp)))
    else:
        # 如果是URL,更新缓存中的统计次数
        if cache.get(tmp) is None:
            # 如果URL不在缓存中,初始化次数为1
            cache[tmp] = 1
        else:
            # 如果URL已经在缓存中,次数加1
            cache[tmp] += 1

代码讲解

1. 缓存字典 cache
  • cache 是一个字典,用于存储URL及其出现的次数。
  • 键(key)是URL(str 类型),值(value)是该URL出现的次数(int 类型)。
2. sortURL 函数
  • 该函数接受一个整数 n,表示要返回的前 n 个URL。
  • cache.items()cache 字典转换为一个列表,列表的每个元素是一个 (key, value) 的元组。
  • urlCount.sort(key=lambda x: (-x[1], x[0])) 对列表进行排序:
    • 首先按出现次数降序排序(-x[1])。
    • 如果出现次数相同,则按URL的字典序升序排序(x[0])。
  • map(lambda x: x[0], urlCount[:n]) 提取前 n 个URL。
  • ",".join(...) 将URL列表用逗号连接成一个字符串并返回。
3. 主循环
  • 使用 while True 进入一个无限循环,持续读取用户输入。
  • tmp = input() 读取一行输入。
  • 判断输入是否为正整数:
    • 如果是正整数,调用 sortURL 函数并输出结果。
    • 如果不是正整数,则认为是URL,更新 cache 中该URL的计数:
      • 如果URL不在 cache 中,初始化次数为1。
      • 如果URL已经在 cache 中,次数加1。

示例运行

假设输入如下:

https://example.com
https://example.com
https://example.org
https://example.net
https://example.net
https://example.net
2

程序会输出:

https://example.net,https://example.com

解释:

  • https://example.net 出现了3次,https://example.com 出现了2次,https://example.org 出现了1次。
  • 用户输入 2,表示要输出出现次数最多的前2个URL,因此输出 https://example.net,https://example.com

代码优化建议

  1. 输入结束条件

    • 当前代码是一个无限循环,可以通过特定的输入(如 exit)来结束程序。
  2. 异常处理

    • 可以增加对非法输入的处理,例如非正整数或空输入。
  3. 性能优化

    • 如果输入数据量较大,可以考虑使用更高效的数据结构(如 collections.Counter)来统计URL出现次数。
  4. 代码简化

    • cache.get(tmp) is None 可以简化为 tmp not in cache
    • map(lambda x: x[0], urlCount[:n]) 可以简化为列表推导式 [x[0] for x in urlCount[:n]]

优化后的代码

from collections import Counter

# 缓存字典,记录每个URL出现的次数
cache = Counter()

# 定义sortURL函数,用于根据URL出现次数排序并返回前n个URL
def sortURL(n):
    # 对cache字典进行排序
    sorted_urls = sorted(cache.keys(), key=lambda x: (-cache[x], x))
    # 返回前n个URL,用逗号连接
    return ",".join(sorted_urls[:n])


# 主循环,持续读取用户输入
while True:
    # 读取一行输入
    tmp = input()

    # 判断输入是否为正整数
    if tmp.isnumeric():
        # 如果是正整数,调用sortURL函数并输出结果
        print(sortURL(int(tmp)))
    else:
        # 如果是URL,更新缓存中的统计次数
        cache[tmp] += 1

优化点

  1. 使用 collections.Counter

    • Counter 是一个专门用于计数的字典子类,可以简化代码逻辑。
  2. 简化排序逻辑

    • 直接对 cache.keys() 进行排序,避免转换为列表。
  3. 代码更简洁

    • 使用 Counter 后,代码逻辑更加清晰和简洁。

总结

这段Python代码通过字典统计URL的出现次数,并通过排序和限制返回前 n 个URL。代码逻辑清晰,适合处理小规模数据。通过优化,代码可以更加简洁和高效。

五、C/C++算法源码:


C++ 实现

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
#include <sstream>

using namespace std;

// 缓存map,记录每个URL出现的次数
map<string, int> cache;

// sortURL函数,用于根据URL出现次数排序并返回前n个URL
string sortURL(int n) {
    // 将map转换为vector,便于排序
    vector<pair<string, int>> urlCount(cache.begin(), cache.end());

    // 对vector进行排序
    // 使用lambda表达式定义排序规则:
    // 1. 首先按出现次数降序排序
    // 2. 如果出现次数相同,则按URL的字典序升序排序
    sort(urlCount.begin(), urlCount.end(), [](const pair<string, int>& a, const pair<string, int>& b) {
        if (a.second != b.second) {
            return a.second > b.second; // 按次数降序
        } else {
            return a.first < b.first; // 按URL升序
        }
    });

    // 提取前n个URL
    stringstream result;
    for (int i = 0; i < n && i < urlCount.size(); ++i) {
        if (i > 0) {
            result << ",";
        }
        result << urlCount[i].first;
    }

    return result.str();
}

int main() {
    string tmp;

    // 主循环,持续读取用户输入
    while (getline(cin, tmp)) {
        // 判断输入是否为正整数
        bool isNumber = true;
        for (char ch : tmp) {
            if (!isdigit(ch)) {
                isNumber = false;
                break;
            }
        }

        if (isNumber) {
            // 如果是正整数,调用sortURL函数并输出结果
            int n = stoi(tmp);
            cout << sortURL(n) << endl;
        } else {
            // 如果是URL,更新缓存中的统计次数
            cache[tmp]++;
        }
    }

    return 0;
}

C++ 代码讲解

  1. map<string, int> cache

    • 使用 map 存储URL及其出现次数,键为URL(string 类型),值为出现次数(int 类型)。
  2. sortURL 函数

    • map 转换为 vector<pair<string, int>>,便于排序。
    • 使用 sort 函数对 vector 进行排序,排序规则为:
      • 首先按出现次数降序排序。
      • 如果出现次数相同,则按URL的字典序升序排序。
    • 使用 stringstream 将前 n 个URL用逗号连接成一个字符串并返回。
  3. 主循环

    • 使用 getline(cin, tmp) 逐行读取输入。
    • 判断输入是否为正整数:
      • 如果是正整数,调用 sortURL 函数并输出结果。
      • 如果是URL,更新 cache 中该URL的计数。
  4. 输入结束条件

    • 当前代码是一个无限循环,可以通过特定的输入(如 exit)来结束程序。

C 语言实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_URL_LENGTH 1000
#define MAX_URLS 10000

// 定义URL结构体
typedef struct {
    char url[MAX_URL_LENGTH];
    int count;
} URLCount;

// 缓存数组,记录每个URL及其出现次数
URLCount cache[MAX_URLS];
int cacheSize = 0;

// 比较函数,用于排序
int compare(const void* a, const void* b) {
    URLCount* urlA = (URLCount*)a;
    URLCount* urlB = (URLCount*)b;

    // 首先按出现次数降序排序
    if (urlA->count != urlB->count) {
        return urlB->count - urlA->count;
    }
    // 如果出现次数相同,则按URL的字典序升序排序
    return strcmp(urlA->url, urlB->url);
}

// sortURL函数,用于根据URL出现次数排序并返回前n个URL
void sortURL(int n) {
    // 对缓存数组进行排序
    qsort(cache, cacheSize, sizeof(URLCount), compare);

    // 输出前n个URL
    for (int i = 0; i < n && i < cacheSize; ++i) {
        if (i > 0) {
            printf(",");
        }
        printf("%s", cache[i].url);
    }
    printf("\n");
}

// 判断字符串是否为正整数
int isNumeric(const char* str) {
    for (int i = 0; str[i] != '\0'; ++i) {
        if (str[i] < '0' || str[i] > '9') {
            return 0;
        }
    }
    return 1;
}

int main() {
    char tmp[MAX_URL_LENGTH];

    // 主循环,持续读取用户输入
    while (fgets(tmp, sizeof(tmp), stdin)) {
        // 去掉换行符
        tmp[strcspn(tmp, "\n")] = '\0';

        // 判断输入是否为正整数
        if (isNumeric(tmp)) {
            // 如果是正整数,调用sortURL函数并输出结果
            int n = atoi(tmp);
            sortURL(n);
        } else {
            // 如果是URL,更新缓存中的统计次数
            int found = 0;
            for (int i = 0; i < cacheSize; ++i) {
                if (strcmp(cache[i].url, tmp) == 0) {
                    cache[i].count++;
                    found = 1;
                    break;
                }
            }
            if (!found) {
                // 如果URL不在缓存中,添加到缓存
                strcpy(cache[cacheSize].url, tmp);
                cache[cacheSize].count = 1;
                cacheSize++;
            }
        }
    }

    return 0;
}

C 语言代码讲解

  1. URLCount 结构体

    • 用于存储URL及其出现次数,包含两个字段:
      • url:URL字符串。
      • count:URL出现次数。
  2. cache 数组

    • 使用数组存储URL及其出现次数,cacheSize 记录当前缓存的大小。
  3. compare 函数

    • 用于 qsort 排序的比较函数,规则为:
      • 首先按出现次数降序排序。
      • 如果出现次数相同,则按URL的字典序升序排序。
  4. sortURL 函数

    • 使用 qsortcache 数组进行排序。
    • 输出前 n 个URL,用逗号分隔。
  5. isNumeric 函数

    • 判断字符串是否为正整数。
  6. 主循环

    • 使用 fgets 逐行读取输入。
    • 判断输入是否为正整数:
      • 如果是正整数,调用 sortURL 函数并输出结果。
      • 如果是URL,更新 cache 中该URL的计数。

总结

  • C++ 实现:利用了STL的 mapvector,代码简洁高效。
  • C 语言实现:使用数组和结构体,适合对内存和性能有严格要求的场景。
  • 两种实现都遵循了相同的逻辑:统计URL出现次数,排序并输出前 n 个URL。

六、尾言

什么是华为OD?

华为OD(Outsourcing Developer,外包开发工程师)是华为针对软件开发工程师岗位的一种招聘形式,主要包括笔试、技术面试以及综合面试等环节。尤其在笔试部分,算法题的机试至关重要。

为什么刷题很重要?

  1. 机试是进入技术面的第一关:
    华为OD机试(常被称为机考)主要考察算法和编程能力。只有通过机试,才能进入后续的技术面试环节。

  2. 技术面试需要手撕代码:
    技术一面和二面通常会涉及现场编写代码或算法题。面试官会注重考察候选人的思路清晰度、代码规范性以及解决问题的能力。因此提前刷题、多练习是通过面试的重要保障。

  3. 入职后的可信考试:
    入职华为后,还需要通过“可信考试”。可信考试分为三个等级:

    • 入门级:主要考察基础算法与编程能力。
    • 工作级:更贴近实际业务需求,可能涉及复杂的算法或与工作内容相关的场景题目。
    • 专业级:最高等级,考察深层次的算法以及优化能力,与薪资直接挂钩。

刷题策略与说明:

2024年8月14日之后,华为OD机试的题库转为 E卷,由往年题库(D卷、A卷、B卷、C卷)和全新题目组成。刷题时可以参考以下策略:

  1. 关注历年真题:

    • 题库中的旧题占比较大,建议优先刷历年的A卷、B卷、C卷、D卷题目。
    • 对于每道题目,建议深度理解其解题思路、代码实现,以及相关算法的适用场景。
  2. 适应新题目:

    • E卷中包含全新题目,需要掌握全面的算法知识和一定的灵活应对能力。
    • 建议关注新的刷题平台或交流群,获取最新题目的解析和动态。
  3. 掌握常见算法:
    华为OD考试通常涉及以下算法和数据结构:

    • 排序算法(快速排序、归并排序等)
    • 动态规划(背包问题、最长公共子序列等)
    • 贪心算法
    • 栈、队列、链表的操作
    • 图论(最短路径、最小生成树等)
    • 滑动窗口、双指针算法
  4. 保持编程规范:

    • 注重代码的可读性和注释的清晰度。
    • 熟练使用常见编程语言,如C++、Java、Python等。

如何获取资源?

  1. 官方参考:

    • 华为招聘官网或相关的招聘平台会有一些参考信息。
    • 华为OD的相关公众号可能也会发布相关的刷题资料或学习资源。
  2. 加入刷题社区:

    • 找到可信的刷题交流群,与其他备考的小伙伴交流经验。
    • 关注知名的刷题网站,如LeetCode、牛客网等,这些平台上有许多华为OD的历年真题和解析。
  3. 寻找系统性的教程:

    • 学习一本经典的算法书籍,例如《算法导论》《剑指Offer》《编程之美》等。
    • 完成系统的学习课程,例如数据结构与算法的在线课程。

积极心态与持续努力:

刷题的过程可能会比较枯燥,但它能够显著提升编程能力和算法思维。无论是为了通过华为OD的招聘考试,还是为了未来的职业发展,这些积累都会成为重要的财富。

考试注意细节

  1. 本地编写代码

    • 在本地 IDE(如 VS Code、PyCharm 等)上编写、保存和调试代码,确保逻辑正确后再复制粘贴到考试页面。这样可以减少语法错误,提高代码准确性。
  2. 调整心态,保持冷静

    • 遇到提示不足或实现不确定的问题时,不必慌张,可以采用更简单或更有把握的方法替代,确保思路清晰。
  3. 输入输出完整性

    • 注意训练和考试时都需要编写完整的输入输出代码,尤其是和题目示例保持一致。完成代码后务必及时调试,确保功能符合要求。
  4. 快捷键使用

    • 删除行可用 Ctrl+D,复制、粘贴和撤销分别为 Ctrl+CCtrl+VCtrl+Z,这些可以正常使用。
    • 避免使用 Ctrl+S,以免触发浏览器的保存功能。
  5. 浏览器要求

    • 使用最新版的 Google Chrome 浏览器完成考试,确保摄像头开启并正常工作。考试期间不要切换到其他网站,以免影响考试成绩。
  6. 交卷相关

    • 答题前,务必仔细查看题目示例,避免遗漏要求。
    • 每完成一道题后,点击【保存并调试】按钮,多次保存和调试是允许的,系统会记录得分最高的一次结果。完成所有题目后,点击【提交本题型】按钮。
    • 确保在考试结束前提交试卷,避免因未保存或调试失误而丢分。
  7. 时间和分数安排

    • 总时间:150 分钟;总分:400 分。
    • 试卷结构:2 道一星难度题(每题 100 分),1 道二星难度题(200 分)。及格分为 150 分。合理分配时间,优先完成自己擅长的题目。
  8. 考试环境准备

    • 考试前请备好草稿纸和笔。考试中尽量避免离开座位,确保监控画面正常。
    • 如需上厕所,请提前规划好时间以减少中途离开监控的可能性。
  9. 技术问题处理

    • 如果考试中遇到断电、断网、死机等技术问题,可以关闭浏览器并重新打开试卷链接继续作答。
    • 出现其他问题,请第一时间联系 HR 或监考人员进行反馈。

祝你考试顺利,取得理想成绩!


http://www.kler.cn/a/526574.html

相关文章:

  • “星门计划对AI未来的意义——以及谁将掌控它”
  • FastExcel使用详解
  • 使用langchain ollama gradio搭建一个本地基于deepseek r1的RAG问答系统
  • Docker容器数据恢复
  • 大模型知识蒸馏技术(2)——蒸馏技术发展简史
  • 网络安全技术简介
  • 使用DeepSeek API生成Markdown文件
  • 使用Ollama和Open WebUI快速玩转大模型:简单快捷的尝试各种llm大模型,比如DeepSeek r1
  • 33【脚本解析语言】
  • 知识推理简要介绍
  • Letta - 构建有状态LLM应用程序
  • OpenCV实战:车辆统计
  • UML状态机图-并发的表示方法
  • 【Linux】makefile、进度条实现
  • 【ArcGIS遇上Python】批量提取多波段影像至单个波段
  • 【Linux】从硬件到软件了解进程
  • 【愚公系列】《循序渐进Vue.js 3.x前端开发实践》035-组合式API的应用
  • AI大模型开发原理篇-5:循环神经网络RNN
  • 计算机网络之计算机网络分层结构
  • 【RocketMQ 存储】- RocketMQ存储类 MappedFile
  • INCOSE需求编写指南-附录 A: 参考文献
  • 鸟瞰欧洲(意境欧洲) 第一季
  • 尚硅谷spring框架视频教程——学习笔记一(IOC、AOP)
  • 【视频+图文详解】HTML基础3-html常用标签
  • 如何在本地部署deepseek-r1模型【详细步骤】
  • Java8_StreamAPI