校招算法笔面试 | 华为机试-数据分类处理

原创 已于 2025-05-10 09:59:51 修改 · 445 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #面试 #华为 #算法华为 #笔试 #算法华为笔试

于 2025-05-10 09:58:54 首次发布

题目## 题目

题目链接

解题思路

这是一个数组分组问题，需要将数组分成两组，使得：

  1. 所有5的倍数必须在其中一个组中
  2. 所有3的倍数（不包括5的倍数）在另一个组中
  3. 其他数字可以任意分配
  4. 要求两组各元素加起来的和相等

实现思路

  1. 首先将数组分成三类：

    • 5的倍数（必须在第一组）
    • 3的倍数（必须在第二组）
    • 其他数字（可以任意分配）

  2. 使用DFS或动态规划尝试分配其他数字，使两组和相等

代码

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        // 去掉0
        vector<int> nonZeroNums;
        for (int num : nums) {
            if (num != 0) nonZeroNums.push_back(num);
        }
        
        // 分类统计
        vector<int> group5, group3, others;
        int sum5 = 0, sum3 = 0;
        
        for (int num : nonZeroNums) {
            if (num % 5 == 0) {
                group5.push_back(num);
                sum5 += num;
            } else if (num % 3 == 0) {
                group3.push_back(num);
                sum3 += num;
            } else {
                others.push_back(num);
            }
        }
        
        return dfs(others, 0, sum5 - sum3);
    }
    
private:
    bool dfs(vector<int>& nums, int index, int diff) {
        if (index == nums.size()) {
            return diff == 0;
        }
        
        // 尝试将当前数字加入第一组（5的倍数组）
        if (dfs(nums, index + 1, diff + nums[index])) {
            return true;
        }
        
        // 尝试将当前数字加入第二组（3的倍数组）
        if (dfs(nums, index + 1, diff - nums[index])) {
            return true;
        }
        
        return false;
    }
};

int main() {
    int n;
    while (cin >> n) {
        vector<int> nums(n);
        for (int i = 0; i < n; i++) {
            cin >> nums[i];
        }
        Solution sol;
        cout << (sol.canPartition(nums) ? "true" : "false") << endl;
    }
    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = sc.nextInt();
            }
            System.out.println(canPartition(nums) ? "true" : "false");
        }
    }
    
    public static boolean canPartition(int[] nums) {
        // 去掉0
        List<Integer> nonZeroNums = new ArrayList<>();
        for (int num : nums) {
            if (num != 0) nonZeroNums.add(num);
        }
        
        // 分类统计
        List<Integer> group5 = new ArrayList<>();
        List<Integer> group3 = new ArrayList<>();
        List<Integer> others = new ArrayList<>();
        int sum5 = 0, sum3 = 0;
        
        for (int num : nonZeroNums) {
            if (num % 5 == 0) {
                group5.add(num);
                sum5 += num;
            } else if (num % 3 == 0) {
                group3.add(num);
                sum3 += num;
            } else {
                others.add(num);
            }
        }
        
        return dfs(others, 0, sum5 - sum3);
    }
    
    private static boolean dfs(List<Integer> nums, int index, int diff) {
        if (index == nums.size()) {
            return diff == 0;
        }
        
        // 尝试将当前数字加入第一组（5的倍数组）
        if (dfs(nums, index + 1, diff + nums.get(index))) {
            return true;
        }
        
        // 尝试将当前数字加入第二组（3的倍数组）
        if (dfs(nums, index + 1, diff - nums.get(index))) {
            return true;
        }
        
        return false;
    }
}

def can_partition(nums):
    # 特殊处理0
    nums = [x for x in nums if x != 0]  # 去掉0
    
    # 分类统计
    group5 = []  # 5的倍数
    group3 = []  # 3的倍数（不含5的倍数）
    others = []  # 其他数
    
    for num in nums:
        if num % 5 == 0:
            group5.append(num)
        elif num % 3 == 0:
            group3.append(num)
        else:
            others.append(num)
    
    sum5 = sum(group5)
    sum3 = sum(group3)
    
    def dfs(index, diff):
        if index == len(others):
            return diff == 0
            
        # 尝试将当前数字加入第一组（5的倍数组）
        if dfs(index + 1, diff + others[index]):
            return True
            
        # 尝试将当前数字加入第二组（3的倍数组）
        if dfs(index + 1, diff - others[index]):
            return True
            
        return False
    
    return dfs(0, sum5 - sum3)

# 主程序
while True:
    try:
        n = int(input())
        nums = list(map(int, input().split()))
        print("true" if can_partition(nums) else "false")
    except:
        break

算法及复杂度

算法分析

  • 算法：DFS（深度优先搜索）
    1. 先将数组分成三类：5的倍数、3的倍数、其他数字
    2. 使用DFS尝试分配其他数字到两个组中
    3. 判断是否能使两组和相等

复杂度分析

  • 时间复杂度： O ( 2 n ) \mathcal{O}(2^n) O(2n) - 其中n是非3和5倍数的数字个数
  • 空间复杂度： O ( n ) \mathcal{O}(n) O(n) - 递归调用栈的深度

题目链接

解题思路

  1. 首先需要处理两个输入序列：原始序列I和规则序列R
  2. 对规则序列R进行排序和去重
  3. 对于R中的每个数字r：
    • 在I序列中查找包含r的所有数字
    • 记录这些数字在原序列中的位置
  4. 按照要求的格式输出结果：
    • 先输出总的匹配数量
    • 然后按R中数字的顺序输出匹配结果

代码

#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
using namespace std;

bool contains(int num, int target) {
    string numStr = to_string(num);
    string targetStr = to_string(target);
    return numStr.find(targetStr) != string::npos;
}

int main() {
    int n, m;
    while (cin >> n) {
        vector<int> I(n);
        for (int i = 0; i < n; i++) {
            cin >> I[i];
        }
        
        cin >> m;
        vector<int> R(m);
        for (int i = 0; i < m; i++) {
            cin >> R[i];
        }
        
        // 对R进行排序和去重
        set<int> uniqueR(R.begin(), R.end());
        vector<int> sortedR(uniqueR.begin(), uniqueR.end());
        
        vector<int> result;
        // 处理每个规则数字
        for (int r : sortedR) {
            vector<pair<int, int>> matches;  // (位置, 值)
            for (int i = 0; i < n; i++) {
                if (contains(I[i], r)) {
                    matches.push_back({i, I[i]});
                }
            }
            
            if (!matches.empty()) {
                result.push_back(r);
                result.push_back(matches.size());
                for (auto& match : matches) {
                    result.push_back(match.first);
                    result.push_back(match.second);
                }
            }
        }
        
        // 输出结果
        cout << result.size() << " ";
        for (int i = 0; i < result.size(); i++) {
            cout << result[i];
            if (i < result.size() - 1) cout << " ";
        }
        cout << endl;
    }
    return 0;
}

import java.util.*;

public class Main {
    private static boolean contains(int num, int target) {
        return String.valueOf(num).contains(String.valueOf(target));
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int[] I = new int[n];
            for (int i = 0; i < n; i++) {
                I[i] = sc.nextInt();
            }
            
            int m = sc.nextInt();
            int[] R = new int[m];
            for (int i = 0; i < m; i++) {
                R[i] = sc.nextInt();
            }
            
            // 对R进行排序和去重
            TreeSet<Integer> uniqueR = new TreeSet<>();
            for (int r : R) uniqueR.add(r);
            
            List<Integer> result = new ArrayList<>();
            // 处理每个规则数字
            for (int r : uniqueR) {
                List<int[]> matches = new ArrayList<>();  // [位置, 值]
                for (int i = 0; i < n; i++) {
                    if (contains(I[i], r)) {
                        matches.add(new int[]{i, I[i]});
                    }
                }
                
                if (!matches.isEmpty()) {
                    result.add(r);
                    result.add(matches.size());
                    for (int[] match : matches) {
                        result.add(match[0]);
                        result.add(match[1]);
                    }
                }
            }
            
            // 输出结果
            System.out.print(result.size());
            for (int val : result) {
                System.out.print(" " + val);
            }
            System.out.println();
        }
    }
}

def contains(num, target):
    """检查数字num是否包含target作为子串"""
    num_str = str(num)
    target_str = str(target)
    return target_str in num_str

while True:
    try:
        # 读取序列I
        I = list(map(int, input().split()))
        n = I[0]
        I = I[1:]
        
        # 读取序列R
        R = list(map(int, input().split()))
        m = R[0]
        R = R[1:]
        
        # 对R进行排序和去重
        unique_R = sorted(set(R))
        
        result = []
        # 处理每个规则数字
        for r in unique_R:
            matches = []  # [(位置, 值)]
            for i in range(len(I)):
                if contains(I[i], r):
                    matches.append((i, I[i]))
            
            if matches:
                result.append(r)
                result.append(len(matches))
                for pos, val in matches:
                    result.append(pos)
                    result.append(val)
        
        # 输出结果
        print(len(result), end='')
        for i in range(len(result)):
            print(f" {result[i]}", end='')
        print()
            
    except EOFError:
        break

算法及复杂度

  • 算法：字符串匹配 + 排序
  • 时间复杂度： O ( m log ⁡ m + n ⋅ m ⋅ k ) \mathcal{O}(m \log m + n \cdot m \cdot k) O(mlogm+n⋅m⋅k)，其中n是序列I的长度，m是序列R的长度，k是数字转字符串后的平均长度
  • 空间复杂度： O ( m + n ) \mathcal{O}(m + n) O(m+n)，用于存储结果和临时数据
校招算法笔面试 | 华为机试-合法IP
wc529065的博客
05-08 436
牛客题库题解牛客题库题解
校招算法笔面试 | 华为机试-矩阵乘法
wc529065的博客
05-12 608
牛客题库题解
校招算法笔面试 | 华为机试-24点游戏算法
wc529065的博客
05-07 359
牛客题库题解
校招算法笔面试 | 华为机试-迷宫问题
wc529065的博客
05-14 846
牛客题库题解
校招算法笔面试 | 华为机试-四则运算
wc529065的博客
05-08 379
牛客题库题解
校招算法笔面试 | 华为机试-素数伴侣
wc529065的博客
05-12 629
牛客题库题解牛客题库题解牛客题库题解牛客题库题解
校招算法笔面试 | 华为机试-字符串加密
wc529065的博客
05-08 317
牛客题库题解牛客题库题解
校招算法笔面试 | 华为机试-蛇形矩阵
wc529065的博客
05-13 738
牛客题库题解
校招算法笔面试 | 华为机试-购物单
wc529065的博客
05-13 901
牛客题库题解
校招算法笔面试 | 华为机试-高精度整数加法
wc529065的博客
05-14 506
牛客题库题解
校招算法笔面试 | 华为机试-整数与IP地址间的转换
wc529065的博客
05-10 446
牛客题库题解牛客题库题解
【校招+社招】华为OD机试 - 找终点（Java & JS & Python & C & C++）
走向CTO的路上...
07-09 601
深度优先搜索算法是一种时间复杂度为 O(V + E) 的算法，其中 V 是网格中的格子数，E 是格子之间的边数。在最坏情况下，该算法会访问所有网格中的格子，因此时间复杂度为 O(V)。给定一个二维网格，其中每个格子要么是可通行（1），要么是障碍物（0）。从网格的左上角（0, 0）出发，可以向上下左右四个方向移动，直到到达网格的右下角（n-1, m-1）。求解从起点到终点的最短路径，并输出路径。该算法的基本思想是：从起点开始，依次探索当前格子的所有未探索的相邻格子，直到找到终点或探索所有格子。
练题100天——DAY21：统计奇数个数+合并有序数组
最新发布
2301_81099859的博客
12-07 217
今天写了两道题，难度，并更新了之前的DAY13的冒泡排序+二进制求和、DAY14全排列的思路。
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 193
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 1031
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
C++ ⼀级 2024 年 03 ⽉
weixin_46669997的博客
12-05 29
当 N 为9, 6, 3, 0时，满足条件 N % 3 == 0，因此它们被输出并跟随一个 #。要注意的是，字符串“a+1= ”最后有一个空格，因而输出的内容是：a+1= 2，答案为A。输入21，21%3的结果为0，进入if的分支，因而第4行代码可以被执行。19.【判断题】C++表达式 “10”*2 执行时将报错，因为 “10” 是字符串类型而2是整数类型，它们数据类型不同，不能在一起运算。Cout后面有两个<<，第1个输出字符串5%2=，第2个输出算术运算“5%2”的结果，为1，答案为D。
浅谈：快递物流与算法的相关性（五）
Duoya1105的博客
12-05 161
NP-C 的英文全称是 Non-deterministic Polynomial Complete，即多项式复杂程度的非确定性问题。简单的写法是NP=P？，问题就在这个问号上，到底有没有让NP=P的算法，或是如何证明NP≠P。启发式算法的思想是：在不断解决问题的过程中寻找解决问题的最优方案。再举一个通俗的例子：当我们用数字密码解锁手机时，如果我们不知道密码是多少，必须将所有的数字组合依次尝试。这听起来像是一句废话，如果将它抽象一点的表述，就是：能用电脑快速验证一个解的问题，是否也能够用电脑快速地求出解。
[优选算法专题十.哈希表 ——NO.55~57 两数之和、判定是否互为字符重排、存在重复元素]
2401_83386596的博客
12-03 688
两数之和问题的最优解法采用哈希表实现O(n)时间复杂度，通过存储元素值与下标的映射关系，快速查找互补值。字符重排判定问题通过单哈希数组统计字符出现次数，先加后减并实时校验，确保字符种类和数量完全一致。存在重复元素问题使用哈希集合检测重复元素，遍历数组时检查元素是否已存在于集合中。三种解法均利用哈希结构优化查找效率，将时间复杂度从暴力解法的O(n²)降至O(n)，是典型空间换时间策略的工业级实现。
简单多源BFS问题
MiauwYuki的博客
12-03 191
简单多源BFS问题
华为机试通关指南：算法与编程实战技巧
资源摘要信息:"华为机试一霸教你过华为机试.pdf"是一份专为准备参加华为软件类岗位校园招聘上机考试的求职者量身打造的实战指导手册，内容聚焦于如何高效备考、快速提升编程能力与应试技巧。该资料以“内功心法”和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值