2017年华为Fx计划在线机试题（详解）

最新推荐文章于 2020-11-24 06:25:53 发布
置顶 最新推荐文章于 2020-11-24 06:25:53 发布
阅读量5.8k 收藏 6
点赞数 2
CC 4.0 BY-SA版权
分类专栏： 2017校招 文章标签： Fx计划 2017华为在线机试 华为任务调度 华为ip地址排序 华为机场大雾机试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14927217/article/details/70369276
本文探讨了三个具体算法问题：寻找最短飞行路径、任务调度过程以及IP地址排序。通过实例展示了如何利用回溯法解决最短路径问题，如何实现任务调度的抢占式调度策略，以及如何对IP地址进行合法性和类型分类。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1，题目描述
小k是x区域的销售经理，他平时常驻“5”城市，并且经常要到“1”，“2”，“3”，“4”，“6”城市出差。当机场出现大雾的情况下，会导致对应城市的所有航班的起飞及降落均停止（即不能从该城市出发，其他城市也不能到达该城市）。小k希望知道如果他需要到x城市出差时，如果遇到y城市出现大雾，他最短的飞行时间及飞行路径。
注意：当两个城市不可达时，消耗时间默认取1000.
各城市间的飞行时间如下表所示，行代表始发城市，列代表终点城市，矩阵中的值代表从始发城市飞行到终点城市所消耗的时间（单位小时），M代表不可达（注意飞行路径是单向的，即A–>B不等于B–>A）
例如：
1）从1号城市飞行到4号城市花费5h，从4号城市飞到1号城市花费2h
2）从5号城市飞行到3号城市不可达，从3号城市飞行到5号城市花费7h
这里写图片描述
输入描述：
输入出差城市x（x可以是1,2,3,4,6）
输入大雾城市y（y可以是0,1,2,3,4,5,6，为0时代表没有出现大雾）
输出描述：
输出最短飞行时间（不可达时为1000）
输出飞行路径，使用“[]”包围所有值，使用“,”分割数值（不可达时“[]”）
输入例子：
2
4
输出例子：
6
[5,1,2]

解题思路：

  1. 如果目标城市和大雾城市是同一个的话，依题意所知，一定不可达
  2. 如果大雾城市就是出发城市的话，依旧不可达
  3. 当没有城市有大雾，也就是说输入y=0时，首先设置最低时长为直达的时间，然后使用回溯法计算从出发城市到目标城市的所有路径，此路径包括不可达与可达路径，当路径不可达时，我们设置达到时长是M=1000，最后计算所有可能的路径时长，求最小值
  4. 当有大雾城市的时候，我们计算路径的时候直接移除该城市的所有路径的情况，也就是说在计算的路径的时候直接不考虑该城市。之后的情况也就和上面类似了。
  5. 注意细节，因为A城市到B城市的时长，与B城市到A城市的时长是不相同的，所以计算路径的时候，不能仅仅计算子集那么简单，还要计算该子集路径的全排列！
    代码简单易懂！欢迎纠正。
    public static void getMinPath(int x,int y){
        int M=1000;
        int [][]matrix={{M,2,10,5,3,M},{M,M,12,M,M,10},{M,M,M,M,7,M}//初始化数组
        ,{2,M,M,M,2,M},{4,M,M,1,M,M},{3,M,1,M,2,M}};
        List<Integer> target=new ArrayList<Integer>();//初始化目标城市
        target.add(1);
        target.add(2);
        target.add(3);
        target.add(4);
        target.add(6);
        if(!target.contains(x)||y>6||y<0){//非法输入的讨论
            System.out.println("非法输入");
            return;
        }
        if(x==y){//目标城市和大雾城市相同，肯定是不可达
            System.out.println(1000);
            System.out.println("[]");
            return;
        }
        if(y==5){//大雾城市就是出发城市，肯定不可达
            System.out.println(1000);
            System.out.println("[]");
            return;
        }
        if(y==0){//没有大雾的天气
            target.remove((Integer)x);
            List<List<Integer>> result=new ArrayList<List<Integer>>();//取子集
            List<Integer> tempList=new ArrayList<Integer>();//临时存储
            List<List<Integer>> last=new ArrayList<List<Integer>>();//取所有的路径情况
            for(int i=1;i<=target.size();i++)
                subSet(target, i, 0, result, tempList); 
            for(int i=0;i<result.size();i++){
                List<Integer> temp=result.get(i);
                rank(temp, tempList, last);
            }
            int min=matrix[4][x-1];//初始值为直达
            String str="[5,";
            int index=-1;
            for(int i=0;i<last.size();i++){
                List<Integer> temp=last.get(i);
                int sum=matrix[4][temp.get(0)-1];
                for(int j=1;j<temp.size();j++)
                    sum+=matrix[temp.get(j-1)-1][temp.get(j)-1];
                sum+=matrix[temp.get(temp.size()-1)-1][x-1];
                if(min>sum){
                    min=sum;
                    index=i;
                }
            }
            //输出处理start
            if(index==-1){//如果在直达的情况最小
                if(min==1000){//如果直到最小值是1000的话，则说明这条路径是没有的
                    System.out.println(1000);
                    System.out.println("[]");
                }else{//反之输出直达路径
                    System.out.println(min);
                    System.out.println(str+(x)+"]");
                }
            }else{
                System.out.println(min);
                for(int i=0;i<last.get(index).size();i++){
                    str+=last.get(index).get(i)+",";
                }
                System.out.println(str+x+"]");
            }
            //输出处理end
        }else{//有大雾的天气，但是不是出发点，也不是目的地
            target.remove((Integer)x);
            target.remove((Integer)y);
            List<List<Integer>> result=new ArrayList<List<Integer>>();//取子集
            List<Integer> tempList=new ArrayList<Integer>();//临时存储
            List<List<Integer>> last=new ArrayList<List<Integer>>();//取所有的路径情况
            for(int i=1;i<=target.size();i++)
                subSet(target, i, 0, result, tempList); 
            for(int i=0;i<result.size();i++){
                List<Integer> temp=result.get(i);
                rank(temp, tempList, last);
            }
            int min=matrix[4][x-1];//初始值为直达
            String str="[5,";
            int index=-1;
            for(int i=0;i<last.size();i++){
                List<Integer> temp=last.get(i);
                int sum=matrix[4][temp.get(0)-1];
                for(int j=1;j<temp.size();j++)
                    sum+=matrix[temp.get(j-1)-1][temp.get(j)-1];
                sum+=matrix[temp.get(temp.size()-1)-1][x-1];
                if(min>sum){
                    min=sum;
                    index=i;
                }
            }
            //输出处理start
            if(index==-1){
                if(min==1000){
                    System.out.println(1000);
                    System.out.println("[]");
                }else{
                    System.out.println(min);
                    System.out.println(str+(x)+"]");
                }
            }else{
                System.out.println(min);
                for(int i=0;i<last.get(index).size();i++){
                    str+=last.get(index).get(i)+",";
                }
                System.out.println(str+x+"]");
            }
            //输出处理end
        }
    }

   public static void subSet(List<Integer> target,int k,int start,List<List<Integer>> result,List<Integer> tempList){
        //计算所有的路径
        if(k<0)
            return;
        else if(k==0){
            result.add(new ArrayList<Integer>(tempList));
        }else{
            for(int i=start;i<target.size();i++){
                tempList.add(target.get(i));
                subSet(target, k-1, i+1, result, tempList);
                tempList.remove(tempList.size()-1);
            }
        }
    }

   public static void rank(List<Integer> list,List<Integer> tempList,List<List<Integer>> result){
        //路径的全排列
        if(tempList.size()==list.size()){
            result.add(new ArrayList(tempList));
        }else{
            for(int i=0;i<list.size();i++){
                if(tempList.contains(list.get(i)))
                    continue;
                tempList.add(list.get(i));
                rank(list, tempList, result);
                tempList.remove(tempList.size()-1);
            }
        }
    }

2,任务调度过程
题目描述：
输入五个任务的ID，任务优先级，开始运行时间和运行时长，其中调度过程是抢占式的，即优先级数值高的任务可以抢占正在运行的优先级值低的任务，最后输出前200秒，任务调度过程
输入描述：
任务信息输入格式：[任务ID.优先级.任务开始时间.任务时长]；任务与任务之间使用“|”隔开，5个任务ID为1-5；优先级范围是0-200
输出描述：
输出任务信息为：任务ID.任务时长;任务之间使用“|”隔离；如果无任何任务运行，则任务ID为0
输入例子：
[1.80.1.10]|[2.20.11.15]|[3.50.21.10]|[4.123.31.10]|[5.100.41.10]
输出例子：
0.1|1.10|2.10|3.10|4.10|5.10|2.5|0.144
题目解析：
1，该题目的输入输出处理起来相当不易，注意的是”|”和”.”在使用字符串截取的时候都需要转义字符“\\”；
2，因为任务是抢占式的，所以我们处理的时候优先级高者优先处理；
3，我们可以逐秒分析，分析该时刻应该是哪个任务所拥有执行，如果没有任务执行，则任务id为0；

废话不多说，代码够详细！

import java.util.*;
public class FX002 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String str=sc.nextLine();
            String []arr=str.split("\\|");
            List<Job> list=new ArrayList<Job>();//存放任务
            for(int i=0;i<arr.length;i++){
                String temp=arr[i].substring(1, arr[i].length()-1);
                String []arrTemp=temp.split("\\.");
                int id=Integer.parseInt(arrTemp[0]);
                int priorty=Integer.parseInt(arrTemp[1]);
                int start=Integer.parseInt(arrTemp[2]);
                int lasting=Integer.parseInt(arrTemp[3]);
                Job job=new Job(id, priorty, start, lasting);
                list.add(job);
            }
            List<Job> postSort=sortByPriorty(list);//将任务按照优先级排序
            List<Integer> q=new ArrayList<Integer>();//存放每刻时间的任务id
            for(int i=0;i<200;i++){
                Job currentJob=null;//当前任务
                for(Job job:postSort){
                    if(job.start<=i&&job.left>0){
                        currentJob=job;//选取此刻优先级最高的任务并且该任务剩余的工作量大于0
                        break;//获取之后即跳出，以防被低优先级的任务抢去
                    }
                }
                if(currentJob==null){
                    q.add(0);//如果此刻没有任务，则将此刻id赋值0
                }else{
                    q.add(currentJob.id);//存放任务id
                    currentJob.left--;//该任务的工作量递减
                }   
            }
            q.add(-1);//存放任务id的链表结束符
            String s="";//返回结果
            int count=1;//计数器：在链表中连续工作的时间数
            for(int i=0;i<q.size()-1;i++){
                if(q.get(i)==q.get(i+1)){
                    count++;
                }else{
                    s+=q.get(i)+"."+count+"|";
                    count=1;
                }
            }
            System.out.println(s.substring(0, s.length()-1));//输出结果
        }
    }
    public static List<Job> sortByPriorty(List<Job> list){//任务按优先级排序
        List<Integer> priortyList=new ArrayList<Integer>();
        for(Job j:list)
            priortyList.add(j.priorty);
        Collections.sort(priortyList);
        List<Integer> index=new ArrayList<Integer>();
        for(Integer i:priortyList){
            int start=-1;
            loop:for(Job j:list){
                start++;
                if(i==j.priorty){
                    index.add(start);
                    start=-1;
                    break loop;
                }
            }
        }
        List<Job> postSort=new ArrayList<Job>();
        for(Integer i:index)
            postSort.add((list.get(i)));
        List<Job> result=new ArrayList<Job>();
        for(int i=0;i<postSort.size();i++)
            result.add(postSort.get(postSort.size()-1-i));
        return result;
    }

}
class Job{
    int id;//任务id
    int priorty;//优先级
    int start;//开始时间
    int lasting;//工作时长
    int left;//剩余工作时长
    public Job(int id,int priorty,int start,int lasting){
        this.id=id;
        this.priorty=priorty;
        this.start=start;
        this.lasting=lasting;
        this.left=lasting;
    }
}

测试样例，如图所示：

这里写图片描述

3，IP地址排序
题目描述：
一组IP地址可能包含A,B,C,D,E类型，请按照ip地址类型输出，相同ip地址类型的按照ip地址的大小排序，按照整数大小从小到达排序。错误ip地址不参与排序。
输入描述：
输入5行，每行均为一个ip地址，ip地址可能是错误的，错误ip地址不参与排序
输出描述：
输出N行，每行输出相同类型的IP地址且按照ip地址大小排序，使用“[]”包围所有值，使用“,”分割数值
输入例子：
80.1.1.1
90.1.1.1
180.1.1.1
190.1.1.1
200.1.1.1
输出描述：
A:[80.1.1.1,90.1.1.1]
B:[180.1.1.1,190.1.1.1]
C:[200.1.1.1]
解题分析：

  1. 第一步要做的就是合法性分析，此题目要求比较低，合法性分析咱们只需要分析其每位数字是否处于0-255之间即可
  2. 将ip地址分类
  3. 因为是需要对每组的IP地址进行排序，所有我们直接调用Collections.sort()，这给我们省去了很大的麻烦
  4. 当然排序算法如果觉得不可靠的话，可随意写了就行。
    废话不说，直接上代码！
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class FX003 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s1=sc.nextLine();
            String s2=sc.nextLine();
            String s3=sc.nextLine();
            String s4=sc.nextLine();
            String s5=sc.nextLine();
            List<String> list=new ArrayList<String>();
            list.add(s1);
            list.add(s2);
            list.add(s3);
            list.add(s4);
            list.add(s5);
            classifyIP(list);
        }
    }
    public static void classifyIP(List<String> list){
        List<String> A=new ArrayList<String>();
        List<String> B=new ArrayList<String>();
        List<String> C=new ArrayList<String>();
        List<String> D=new ArrayList<String>();
        List<String> E=new ArrayList<String>();
        for(int i=0;i<list.size();i++){
            if(isValid(list.get(i))){
                String []arr=list.get(i).split("\\.");
                int x=Integer.parseInt(arr[0]);
                if(x>=0&&x<=127)//A
                    A.add(list.get(i));
                else if(x>=128&&x<=191)//B
                    B.add(list.get(i));
                else if(x>=192&&x<=223)//C
                    C.add(list.get(i));
                else if(x>=224&&x<=239)//D
                    D.add(list.get(i));
                else//E
                    E.add(list.get(i));
            }
        }
        if(!A.isEmpty()){
            Collections.sort(A);//排序
            System.out.print("A:");
            System.out.println(A);
        }
        if(!B.isEmpty()){
            Collections.sort(B);
            System.out.print("B:");
            System.out.println(B);
        }
        if(!C.isEmpty()){
            Collections.sort(C);
            System.out.print("C:");
            System.out.println(C);
        }
        if(!D.isEmpty()){
            Collections.sort(D);
            System.out.print("D:");
            System.out.println(D);
        }
        if(!E.isEmpty()){
            Collections.sort(E);
            System.out.print("E:");
            System.out.println(E);
        }
    }
    public static boolean isValid(String s){//题干中指出：ip地址合法性的判断答题者只需负责数字的大小验证
        String []arr=s.split("\\.");
        for(int i=0;i<arr.length;i++){
            if(Integer.parseInt(arr[i])>255||Integer.parseInt(arr[i])<0)
                return false;
        }
        return true;
    }
}

这里写图片描述

2025华为OD机考备考攻略 、刷题技巧 以及 最新2025B卷题库目录分值说明 + 考点说明+在线OJ
算法大师！
03-18 43万+
2025华为OD机考备考攻略 、刷题技巧 以及 最新2025B卷题库目录分值说明 + 考点说明+在线OJ。2025年5月9日，华为od机考已经从2025年A卷（2025A卷）切换到华为OD2025年B卷（2025B卷）,有人说是16号，实际上是9号全面切换到B卷。
华为OD机试 - 内存资源分配 内存池（Python） | 机试题算法思路
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
02-17 3608
主要思路是遍历所有任务，对于每个任务，从资源池中选择一个最小的大于等于该任务的资源。如果找到这样的资源，则为 True，将该资源数量减 1；参加华为od机试，一定要注意不要完全背诵代码，需要理解之后模仿写出，通过率才会高。用户会进行一系列内存申请，需要按需分配内存池中的资源，返回申请结果成功失败列表。有一个简易内存池，内存按照大小粒度分类，每个粒度有若干个可用内存资源。为原创内容，该部分版权由 OD 联盟共同拥有，并授权组内成员发布。一个粒度信息内用冒号分割，冒号前为内存粒度大小，冒号后为数量，
华南农业大学编译原理实验_FX科学家计划 || 部门介绍—2012实验室之中央软件院...
weixin_39929877的博客
11-24 1470
这是一篇干货推送2020届顶尖人才招聘计划的号角已经吹响相信不少同学已经报名了项目想要了解具体部门信息那就一定要看下去啦~此次部门介绍将以系列形式连续六天推出同学们快快各取所需吧～FX科学家计划部门介绍2012实验室之中央软件院 华为中央软件院隶属2012实验室，作为华为端、管、云核心的ICT软件基础设施提供者，是连接应用和硬件的核心枢纽。在操作系统、分布式数据库、云网络、大数...
华为fx测试题
njudongchen的博客
04-23 1885
1. 小K是X区域的销售经理，他平常常驻“5”城市，并且经常要到“1”、“2”、“3”、“4”、“6”城市出差。当机场出现大雾情况时，会导致对应城市的所有航班的起飞及降落均停止（即不能从该城市出发，其他城市也不能到达该城市）。小K希望知道如果他需要到X城市出差时，如果遇到Y城市出现大雾，他最短的飞行时间及飞行路径。注意：当两个城市间不可达时，消耗时间默认取1000.各城市简的飞行时间如下表所示，加
华为机试
nameix的博客
09-13 580
1.华为机试---数据分类整理 2.华为机试----大数求余
简记华为FX三面（算法工程师-机器学习岗）
hjxu2016的博客
07-22 1899
此篇文章记录于2018年笔者当时校招之路 时过一年，又是一轮毕业季，故放出此私密文章，为广大应届生分享笔者当时校招之路，虽因种种原因，与华为失之交臂。 笔者当时应聘的是算法工程师-机器学习岗位，所以基本和机器学习相关。码字不易，错别字海涵，提醒必改！ 第一面、电话面，点到为止，确认是否有准备，如果准备不充分，建议放弃此次机会，问的很基础，大约16分钟。比如softmax函数，dropout函...
简记华为FX笔试题（三）阶乘
hjxu2016的博客
07-22 402
此篇文章记录于2018年笔者当时校招之路 时过一年，又是一轮毕业季，故放出此私密文章，为广大应届生分享笔者当时校招之路，虽因种种原因，与华为失之交臂。 输入一个整数N，输出N！的值，即1*2*3*..*N 但是N！可能很大，超出整数范围，也就是说要用字符串来表示罗。 这涉及一个大数相乘的运算。 关于大数相乘，网上有很多答案，在这里就不单独介绍了，先贴出我的代码，与广大IT友分享，令祝大家...
华为杯研究生数模竞赛2017年试题
09-10
包括2017年的全部试题，分别是： A题：无人机在抢险救灾中的优化运用 B题：面向下一代光通信的 VCSEL 激光器仿真建模 C题：航班恢复问题 D题：基于监控视频的前景目标提取 E题：多波次导弹发射中的规划问题 F题：...
华为机试题（非牛客网试练题）OD考试题分析.rar
06-24
华为机试题（非牛客网试练题）OD考试题分析，不定期更新，文档含代码解答
2017年华为网络技术大赛个人笔记
06-04
华为网络技术大赛（2017）初赛、复赛、决赛 Evernote个人笔记
简记华为FX笔试题（二）之字符串输入
hjxu2016的博客
07-22 489
此篇文章记录于2018年笔者当时校招之路 时过一年，又是一轮毕业季，故放出此私密文章，为广大应届生分享笔者当时校招之路，虽因种种原因，与华为失之交臂。 题目自己定的，具体叫啥笔者也不是很清楚，题意大体如下 输入一串字符串，以英文逗号分隔，如 A1,B2,C3,a9,d0,然后按照每个字符串最后一个数字的ASCII码作为优先级，按照优先级 从高到底输出出栈的字符串，同样以英文逗号作为分隔，优...
简记华为FX笔试题（一）之字符串加密
hjxu2016的博客
07-22 437
此篇文章记录于2018年笔者当时校招之路 时过一年，又是一轮毕业季，故放出此私密文章，为广大应届生分享笔者当时校招之路 可能上批FX笔试题太难了，这次笔试题大大降低了难度。 题目大体意思是这样，输入一个字符串，然后将每个字符加密拼接， 拼接算法是将每个字符转换为二进制数字，然后将这些二进制数字分别逆序后，再拼接。 比如 输入 ab 输出 10000110100011 这道题是比较简单...
华为实习之旅(附顶尖人才计划面经)
沉迷单车的追风少年
07-24 1245
不知不觉来菊厂已经一个多月了，今天提交了辞职报告，离开也进入倒计时喽，这些日子确实学到了很多东西，真要说再见还真有点不舍哈哈 目录 菊厂技术 菊厂生活 菊厂传闻 顶尖人才计划面经 菊厂技术 这一点上不得不说是我收货最多的部分，菊厂的技术氛围非常好，内部论坛的博客非常多，绝大部分问题都能在内部论坛上讨论解决。 mentor人也非常好，就是比较忙，我都不太好意思打扰他，实在没搞清楚的才去问他，他都会非常耐心的帮我review code，每次review收货都非常多。 印象最深刻的是有一次我co
华为薪酬大揭密
SpringArt
11-13 4461
1、基本工资。华为的基本工资起薪是分应届生和社会招聘的，2000年华为应届本科起薪是税前4000，硕士生税前5000，博士人少就不提了。社招的要自己和公司谈，有的很牛的不会谈结果比应届还低，有的很一般的会吹结果很高，但总的说比应届的高。2000年来的一般进公司3个月左右有一次加薪， 200到3000不等，取决于你的部门和表现，但基本按部门，好部门表现差的比差部门好的涨得还多。涨的多的包括研发和市场...
华为“达芬奇计划”首次曝光！
IT派
07-15 751
据外媒 The Information 报道，华为目前正在开展一个代号为达芬奇计划“Project Da Vinci”的新项目！“达芬奇计划”旨在将AI带入华为所有的产品...
2019华为机试
Chasing_Shadows的博客
08-29 1万+
因为时间关系，没有通过率验证，输出形式的0 2 0 4 0 6 0 8 0 10 0 8 0 6 0 4 0 2 事后试着奇数位输出‘0’,偶数位输出 实部与虚部之和，这样结果符合测试样例 感觉不出来原因错在哪里。。。。有大佬知道的话请留言告诉我。。。。 示例： 输入为20行 数字‘1’，输出18行     附上个人代码； #include&lt;iostream&gt...
华为武长区笔试2017
高筑墙，广积粮，缓称王
03-25 1607
题目1描述请您写一个reverseAdd函数，该函数根据输入的两个正整数a和b,然后分别将它们的数字按照高位在右边的方式反转后求和。 例如，reverseAdd（123,456）==321+654 ==975输入描述函数原型：int reverseAdd(int a,int b); 输入： 输入的a,b参数均为有效取值范围[1,70000]区间上的正整数。 100和200反转后的值为1和2（前导0
华为研发岗位两轮面试的准备（本科生，已经拿到offer，月薪20k，15薪）
热门推荐
oliverxu.cn
10-15 4万+
专业面试： 自我介绍：3-5分钟把自己的校园经历简单介绍一下 面试官您好，很高兴能有机会来参加面试，我叫周杰伦，来自上海市，现在正在上海交通大学学习。 首先，我在大学期间非常重视专业知识的学习，我平时学习非常用功，在每学年的考试中都始终保持年级前10名的成绩，整个大学期间成绩排名为第1，排名人数95人，获得过1次二等奖学金，1次一等奖学金。 其次，我还非常注重实践经验的积累。在大学期间，我积极...
对华为招聘人才的一点看法
eltonzhao的专栏
01-23 3117
导读： 　　首先：华为招聘搞的是海笔和海面，所以场面很混乱，华为不刷简历，不刷笔试，我真不明白，对于这个，我们可以给两个理由去解释： 　　第一，就是华为仅仅是通过自己的校园招聘去宣传华为，我知道去年华为来天津的学校招聘，第一次来时，我们学校的人一个都没招，弄的我们学校很郁闷，于是第二次补招才招了几个，我们学校在天津甚至在全国都还是有点名字的，华为没招一个，就很难说的过去，当然你可以说我们学
华为机试题：算法设计与打分规则详解
本题是关于华为机试题中的一段代码实现，涉及C语言编程中的函数设计与计算选手得分逻辑。题目背景是模拟华为2012年的校园招聘机试场景，考生需要对选秀节目的打分规则进行处理，该规则根据不同类型的评委（专家评委...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Narasimha_Karumanchi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值