精华内容
下载资源
问答
  • 华为上机考试

    2014-07-18 12:21:17
    这是一个求解一元二次方程的计算程序!
  • 华为上机考试注意事项及编程技巧

    千次阅读 2020-01-19 11:47:02
    华为上机考试注意事项及编程技巧 这是一篇关于华为招聘软件类职位上机考试的博客,主要介绍一下华为机考的流程、注意事项以及一些机试题中常用的编程技巧,写得有点长,但都是尽心尽力敲的,如果真的要...

    华为上机考试注意事项及编程技巧

     

    这是一篇关于华为招聘软件类职位上机考试的博客,主要介绍一下华为机考的流程、注意事项以及一些机试题中常用的编程技巧,写得有点长,但都是尽心尽力敲的,如果真的要参加华为招聘(或者类似公司的招聘),建议稍微花点时间看完。话不多说,直接进入正题。
     

    一、什么是华为上机考试


    华为上机考试是华为招聘软件类职位的一个环节,这里以校招为例,华为校招正常流程分为简历注册、简历筛选、上机考试(软件类)、综合测评、专业面试、综合面试、签约洽谈七个流程,上机考试可以说是相当重要的一个环节。
    华为机试到目前为止,历年来都是三道编程题,第一道题100分,第二道题200分,第三道题300分,大多情况难度依次递增,个人认为其主要考察对编程语言的运用和简单的算法设计,答题语言可以自选,有C/C++、Java,每种语言的编译器和编译环境每年可能会有轻微改动,目前C/C++语言使用Visual Studio 2005的编译环境(预计很长一段时间内都会是这个),所以建议平常练习的时候用Visual Studio进行编程,常见的win7系统下可以装Visual Studio 2010,因为Visual Studio 2005最开始是对xp系统的,装在win7下还要进行各种设置,较为麻烦。
    上机考试需要在指定时间登录华为的软件考试平台进行答题,考试时长两个小时。具体操作步骤如下:

    • 1、打开浏览器输入上机考试的网址;
    • 2、输入姓名、邮箱和手机号等个人信息,提交登录;
    • 3、登录后会进入试题说明页面,考试阅读完试题要求后,进入考试;
    • 4、认真阅读考试题目,考试题目可以随意切换,只要没有点提交,不计入答题次数,但要注意切换之后原来答题框内的代码会消失。有能力完成三道题的人,建议先把三道题都浏览一遍,从自己拿手的做起(但不建议一开始就做第三道)。
    • 5、认真审题后,在自己的本地编译器上编写代码和调试,调试通过后,将代码复制到对应题目的答题框内(注意一定要复制完整的代码),点击“提交”即可,之后页面会显示“提交成功”,提交成功后等待十几秒,系统会给出该道题目的判卷结果;
    • 6、判卷结果大致有“编译未通过”、“运行超时”、“部分测试用例未通过”、“全部测试用例通过”四种结果。如果出现“编译未通过”,则说明提交的代码语法或者链接错误,点击页面上的编译结果,会给出编译信息,据此修改自己的代码;如果出现“运行超时”,建议检查一下自己的输入是否过于繁琐(比如明明可以一次读取一行,却一个字符一个字符输入),或者while、for循环是否能够保证正常退出;如果出现“部分测试用例未通过”,这就需要重新审题,检查自己漏掉了哪些输入情况(这个时候千万不要怀疑判卷平台,一定是你自己错了);

    7、三道题目都提交完成并通过后,点击交卷按钮,完成后按系统提示退出考试即可。

     

    二、华为上机考试的注意事项

    华为机试主要考察对编程语言的运用和简单的算法设计,虽说真金不怕火炼,但一些细小的问题可能会浪费很多时间,这在机试过程中是致命的,因此总结一下在机试中的一些注意事项。
     

    1、时间安排。华为机试一共两个小时,题量为三道题,如果将难度按照星等来划分的话大体可分为两种模式,第一种为一星或二星、三星、五星,第二种为二星、四星、五星,
    这里可能有人会对第二种模式有疑问,需要说明的是,针对第二种情况,第2、3题是有继承性的,即是说第2题的算法或者代码经过改进就可以用于第3题,因此难度上有所提升也是很正常的。答题时间分配各有各的安排,这里个人建议如果是能做完三道题的人,时间按照20、40、60(模式一)或25、50、45(模式二);如果做不完三道题的人,根据自己的熟练程度安排时间。另外,华为在学校安排的统一机试都是严格按照系统时间而非登录时间进行的,如果安排在上午10:00到12:00机试,则12:00一到,考试自动截止,如果你在10:30才点击开始考试,截止时间仍然是12:00。因此,要提前进入考场,登录平台完善个人信息(在开考之前就可以登录平台和填写个人信息)。这里说的都是指在学校的统一机试,华为最近每年校招之前有一个提前批次的内退和优招,这个机考时间是按照登录时间来算的。

     

    2、考场注意事项。一定要提前进入考场,进入考场后需要进行一些准备,第一,阅读考场内标明的注意事项;第二,找合适的座位,开机查看电脑可否正常使用,检查网络连接是否正常;第三,检查鼠标键盘等外设是否可用,尤其是键盘,如果答题答到一半发现键盘上有一个按键不好用了,这是非常坑爹的事,检验方法是新建一个空白文档,然后把键盘上的所有按键都敲一遍,另外说一下万一真的答题到一半时键盘按键不好用了怎么办,微软有自带的频幕软键盘,在开始中输入“osk.exe”运行程序即可调用出频幕软键盘;第四,检查浏览器是否可用,是否可以登录考试平台;第五,检查本地开发平台和编译器是否可用,写一个小测试用例看看能不能编译和运行。
     

    3、VS下新建立的工程项目在编译过程中可能会遇到这样的问题:LINK : fatal error LNK1123: 转换到 COFF 期间失败: 文件无效或损坏。这既不是语法错误也不是链接的问题,而是嵌入清单的问题,具体原理自行百度,这里只说一下解决办法:右键->工程属性->配置属性-> 清单工具->输入和输出->嵌入清单,选择[否]。
     

    4、注意题目的输入输出要求。一定注意审题,请认真阅读每个机试题目的问题描述,每个题目最下方都有该题目对应的测试数据和提示信息,程序运行前后的输入输出必须与测试数据的输入输出完全一致,不能在程序运行时输出其他任何题目中没有要求的提示语句,例如printf(“请输入字符串”)。请删除此类无效代码。否则您的程序提交后会显示答案错误。
     

    5、C++语言在提交时,不能有#include ”stdafx.h”和system(“pause”)等语句,主函数也不能是int _tmain(int argc, _TCHAR* argv[])而应当直接写成int main()。对于不加system(“pause”)语句调试闪退的现象,可以在return 0后打上断点,也可以使用ctrl+F5直接执行。
     

    6、字符串问题。在对字符串进行操作时,一定要记得结尾符’\0’,例如char a[10]中实际只能放入9个有用字符,最后一位需要放置结尾符。在字符串输入和for循环中经常会因为忽略了结尾符而出错。
     

    7、提交注意事项。提交后,运行超时的,一般应检查输入情况和for、while循环,例如不能用while循环逐个字符读取,保证for循环和while循环可以正常退出等。代码提交后,系统会及时对题目进行打分,并进行提示,可以在答题页面中单击“状态”按钮,查看题目得分,每次提交都会有一次记录,每次提交后台系统都会打分,若多次提交同一个题目,分数以最高分为准。若题目有错误,或者没有得满分,单击状态按钮后弹出的页面中,查看本次提交的记录,如果有错误,该行会提示代码有某种类型的错误,例如,编译错误,答案错误等等,在错误的文字上单击,即可跳转到该错误的详细解析页面,页面中下方会显示此次提交的代码在后台系统中的出错信息,参考该错误信息进行调试。注意,每个题提交次数不能超过5次。
     

    8、对于输入问题。后台输入均为字符串,未明确说明以“\n”结束的,用while(ch=’\n’)这样的写法可能会导致死循环机试的题目中并没有严格定义每行输入的结束符号是回车符或者EOF或者空格或者’\0’等,请按照机试题目要求,逐行读取输入,然后再对输入数据进行处理,不要采用循环逐个读取单个字符,否则可能会导致您本地测试通过,但是提交后系统返回运行超时或者答案错误。建议使用字符串保存输入,再做处理。不要使用’\n’、 ’\0’
    作为while的跳出条件,不要认为后台输入数据时以回车符结束(除非特别声明)。

     

    9、对于测试用例。判题不会用题目中给出的测试用例,即是说直接printf题目中的测试用例输出是不能得分的,想要投机取巧混一点得分是不行的。另外所有的测试用例都是无法看到的,如果是部分测试用例未通过,并不能知道哪类测试用例没有通过,只能自己去检查是否审题有误,或者是考虑情况是否全面。
     

    三、华为上机考试的编程技巧
     

    华为机试的考点,有17个部分,包含:排序,求最大最小数,链表,大数、高精度数运算,字符串常见操作,数组常见操作,四则运算,求数的各种附属数,匹配问题,进制转换,二叉树,规划问题,最短路径问题,图联通问题,对数字进行特殊判断。这里简单列举一些机试编程的常用函数和技巧,只是提出一个参考,函数更为具体的用法可以自行查阅。
    1、排序算法。排序算法有快速排序、选择排序、插入排序、冒泡排序、堆排序、归并排序、桶排序等,在编程里面较为好用的当属冒泡排序,以下是一段冒泡排序的代码,尤其要注意第二个for循环的循环控制语句。

    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }

    2、字符操作。有很多机试题目需要对字符(不是字符串)进行判断和操作,这里列举一些常用的操作和编程技巧。
    判断一个字符是数字: if(c>=’0’ && c<=’9’);
    判断一个字符是大写字母: f(c>=’A’ && c<=’Z’);
    将char型数字转换为int型的一位数: int b = c - ‘0’;
    将int型数字转换为char型数字: char c = char(b + ‘0’);
    将大写字母转换为小写字母: char xiaoxie = daxie + (‘a’ - ‘A’);

     

    3、字符串操作
    依据条件筛选出一个长度不定的字符串:

    int n = 0;
    for(int i=0;i<n;i++)
    {
        if(/*a[i]符合条件*/)
        {
            b[n] = a[i];
            N++;
        }
    }
    B[n] = ‘\0’;

    以下是string.h库中的常用函数
    求字符串长度: int len = strlen(str);
    字符串复制: strcpy();
    字符串比较: strcmp();
    字符串拼接: strcat();
    查询字串: strchr();
    查询子串: strstr();
    以下是stdlib.h库中的常用函数
    将数字字符串(如”136”)转换为int型:int i = atoi(str);
    将数字字符串(如”136”)转换为float型:int f = atof(str);
    将数字字符串(如”136”)转换为long型:int l = atol(str);
    将int型多位数字转换为字符串型: itoa(str, i, 10);(第三个参数表示进制)
    另外C++还有一种string类,可以更方便地对字符串作处理,可自行查阅。

     

    4、记录数组原位置并进行交换处理的问题。在编程中经常会遇到对数组元素进行交换,当交换并处理后,需要按原始位置输出时,可以使用结构体来简化编程。例如,对一组整数的最大元素加上次大元素的值,次大元素加上第三大元素的值,第三大元素加上第四大元素的值……最小元素加0,依次对每一个元素进行处理,处理完成后按照原始数组的元素位置输出处理结果,使用结构体来编写程序会使得这种处理变简单,代码如下:

    struct mydata
    {
        int num;//存放数据
        Int index; //记录原始数据的下标位置
    } 
    mydata data[n];
    for(int i=0;i<n;i++)
    {
        std::cin>>mydata.num;
        index = i;
    }
    for(int i=0;i<n;i++)//冒泡排序
    {
        for(int j=0;j<n-1-i;j++)
        {
            if(data[j].num<data[j+1].num)
            {
                mydata temp = data[j];
                data[j] = data[j+1];
                data[j+1] = temp;
            }
        }
    }
    for(int i=1;i<n;i++)//这里要注意,只能从最大元素开始
    {
        data[i].num = data[i].num + data[i+1].num;
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(i != data[j].index)
                continue;
            else
            {
                std::cout<<data[j].num;
                break;
            }
        }
    }

    5、排序函数。C/C++中自带有排序函数sort,位于头文件stdlib.h中,可以实现快速排序(此处说的快速是指编写程序快速,并非排序算法中的快速排序),具体用法为:
    sort(a,a+len(a));//将数组a按照默认升序排列
    sort(a,a+len(a),cmp);//将数组a按照cmp函数指定的规则排列,例如如下的为降序规则

    bool cmp(int para1,int para2)
    {
        return a>b;
    }

    6、C/C++中定义了vector容器,位于头文件vector中,这是一种类似链表的结构,可以实现动态增长和删除,简单用法如下。
    几种vector声明:

     

    vectorvec1; //定义空的vector
    vectorvec2(10); //产生大小为10的vector
    vectorvec3(10,-1); //产生大小为10,并且每个元素都是-1的vector
    vectorvec4(v3); //用一个vector产生一个vecotr

     

    尾部插入元素: vec.push_back(a);
    尾部删除元素: vec.pop_back(a);
    插入元素: vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a;
    删除元素: vec.erase(vec.begin()+2);删除第3个元素
    vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始
    向量大小: vec.size();
    清空: vec.clear();

     

    实用迭代器访问元素:
    vector::iterator ita; //声明一个迭代器
    int i=0;
    for(ita=v1.begin(), i=0;ita != v1.end();i++,ita++){}//v1.begin()指向v1的第一个元素,v1.end()指向最后元素的下一位置。

    展开全文
  • 华为上机考试题库C++完整版,非常全的参考资料,详细解答,决胜宝典
  • 华为上机考试注意事项及编程技巧(精品)

    万次阅读 多人点赞 2018-03-25 14:49:07
    这是一篇关于华为招聘软件类职位上机... 一、什么是华为上机考试 华为上机考试是华为招聘软件类职位的一个环节,这里以校招为例,华为校招正常流程分为简历注册、简历筛选、上机考试(软件类)、综合测评、专业面...

    这是一篇关于华为招聘软件类职位上机考试的博客,主要介绍一下华为机考的流程、注意事项以及一些机试题中常用的编程技巧,写得有点长,但都是尽心尽力敲的,如果真的要参加华为招聘(或者类似公司的招聘),建议稍微花点时间看完。话不多说,直接进入正题。 
    一、什么是华为上机考试 
    华为上机考试是华为招聘软件类职位的一个环节,这里以校招为例,华为校招正常流程分为简历注册、简历筛选、上机考试(软件类)、综合测评、专业面试、综合面试、签约洽谈七个流程,上机考试可以说是相当重要的一个环节。 
    华为机试到目前为止,历年来都是三道编程题,第一道题100分,第二道题200分,第三道题300分,大多情况难度依次递增,个人认为其主要考察对编程语言的运用和简单的算法设计,答题语言可以自选,有C/C++、Java,每种语言的编译器和编译环境每年可能会有轻微改动,目前C/C++语言使用Visual Studio 2005的编译环境(预计很长一段时间内都会是这个),所以建议平常练习的时候用Visual Studio进行编程,常见的win7系统下可以装Visual Studio 2010,因为Visual Studio 2005最开始是对xp系统的,装在win7下还要进行各种设置,较为麻烦。 
    上机考试需要在指定时间登录华为的软件考试平台进行答题,考试时长两个小时。具体操作步骤如下: 
    1、打开浏览器输入上机考试的网址; 
    2、输入姓名、邮箱和手机号等个人信息,提交登录; 
    3、登录后会进入试题说明页面,考试阅读完试题要求后,进入考试; 
    4、认真阅读考试题目,考试题目可以随意切换,只要没有点提交,不计入答题次数,但要注意切换之后原来答题框内的代码会消失。有能力完成三道题的人,建议先把三道题都浏览一遍,从自己拿手的做起(但不建议一开始就做第三道)。 
    5、认真审题后,在自己的本地编译器上编写代码和调试,调试通过后,将代码复制到对应题目的答题框内(注意一定要复制完整的代码),点击“提交”即可,之后页面会显示“提交成功”,提交成功后等待十几秒,系统会给出该道题目的判卷结果; 
    6、判卷结果大致有“编译未通过”、“运行超时”、“部分测试用例未通过”、“全部测试用例通过”四种结果。如果出现“编译未通过”,则说明提交的代码语法或者链接错误,点击页面上的编译结果,会给出编译信息,据此修改自己的代码;如果出现“运行超时”,建议检查一下自己的输入是否过于繁琐(比如明明可以一次读取一行,却一个字符一个字符输入),或者while、for循环是否能够保证正常退出;如果出现“部分测试用例未通过”,这就需要重新审题,检查自己漏掉了哪些输入情况(这个时候千万不要怀疑判卷平台,一定是你自己错了); 
    7、三道题目都提交完成并通过后,点击交卷按钮,完成后按系统提示退出考试即可。 
    二、华为上机考试的注意事项 
    华为机试主要考察对编程语言的运用和简单的算法设计,虽说真金不怕火炼,但一些细小的问题可能会浪费很多时间,这在机试过程中是致命的,因此总结一下在机试中的一些注意事项。 
    1、时间安排。华为机试一共两个小时,题量为三道题,如果将难度按照星等来划分的话大体可分为两种模式,第一种为一星或二星、三星、五星,第二种为二星、四星、五星, 
    这里可能有人会对第二种模式有疑问,需要说明的是,针对第二种情况,第2、3题是有继承性的,即是说第2题的算法或者代码经过改进就可以用于第3题,因此难度上有所提升也是很正常的。答题时间分配各有各的安排,这里个人建议如果是能做完三道题的人,时间按照20、40、60(模式一)或25、50、45(模式二);如果做不完三道题的人,根据自己的熟练程度安排时间。另外,华为在学校安排的统一机试都是严格按照系统时间而非登录时间进行的,如果安排在上午10:00到12:00机试,则12:00一到,考试自动截止,如果你在10:30才点击开始考试,截止时间仍然是12:00。因此,要提前进入考场,登录平台完善个人信息(在开考之前就可以登录平台和填写个人信息)。这里说的都是指在学校的统一机试,华为最近每年校招之前有一个提前批次的内退和优招,这个机考时间是按照登录时间来算的。 
    2、考场注意事项。一定要提前进入考场,进入考场后需要进行一些准备,第一,阅读考场内标明的注意事项;第二,找合适的座位,开机查看电脑可否正常使用,检查网络连接是否正常;第三,检查鼠标键盘等外设是否可用,尤其是键盘,如果答题答到一半发现键盘上有一个按键不好用了,这是非常坑爹的事,检验方法是新建一个空白文档,然后把键盘上的所有按键都敲一遍,另外说一下万一真的答题到一半时键盘按键不好用了怎么办,微软有自带的频幕软键盘,在开始中输入“osk.exe”运行程序即可调用出频幕软键盘;第四,检查浏览器是否可用,是否可以登录考试平台;第五,检查本地开发平台和编译器是否可用,写一个小测试用例看看能不能编译和运行。 
    3、VS下新建立的工程项目在编译过程中可能会遇到这样的问题:LINK : fatal error LNK1123: 转换到 COFF 期间失败: 文件无效或损坏。这既不是语法错误也不是链接的问题,而是嵌入清单的问题,具体原理自行百度,这里只说一下解决办法:右键->工程属性->配置属性-> 清单工具->输入和输出->嵌入清单,选择[否]。 
    4、注意题目的输入输出要求。一定注意审题,请认真阅读每个机试题目的问题描述,每个题目最下方都有该题目对应的测试数据和提示信息,程序运行前后的输入输出必须与测试数据的输入输出完全一致,不能在程序运行时输出其他任何题目中没有要求的提示语句,例如printf(“请输入字符串”)。请删除此类无效代码。否则您的程序提交后会显示答案错误。 
    5、C++语言在提交时,不能有#include ”stdafx.h”和system(“pause”)等语句,主函数也不能是int _tmain(int argc, _TCHAR* argv[])而应当直接写成int main()。对于不加system(“pause”)语句调试闪退的现象,可以在return 0后打上断点,也可以使用ctrl+F5直接执行。 
    6、字符串问题。在对字符串进行操作时,一定要记得结尾符’\0’,例如char a[10]中实际只能放入9个有用字符,最后一位需要放置结尾符。在字符串输入和for循环中经常会因为忽略了结尾符而出错。 
    7、提交注意事项。提交后,运行超时的,一般应检查输入情况和for、while循环,例如不能用while循环逐个字符读取,保证for循环和while循环可以正常退出等。代码提交后,系统会及时对题目进行打分,并进行提示,可以在答题页面中单击“状态”按钮,查看题目得分,每次提交都会有一次记录,每次提交后台系统都会打分,若多次提交同一个题目,分数以最高分为准。若题目有错误,或者没有得满分,单击状态按钮后弹出的页面中,查看本次提交的记录,如果有错误,该行会提示代码有某种类型的错误,例如,编译错误,答案错误等等,在错误的文字上单击,即可跳转到该错误的详细解析页面,页面中下方会显示此次提交的代码在后台系统中的出错信息,参考该错误信息进行调试。注意,每个题提交次数不能超过5次。 
    8、对于输入问题。后台输入均为字符串,未明确说明以“\n”结束的,用while(ch=’\n’)这样的写法可能会导致死循环机试的题目中并没有严格定义每行输入的结束符号是回车符或者EOF或者空格或者’\0’等,请按照机试题目要求,逐行读取输入,然后再对输入数据进行处理,不要采用循环逐个读取单个字符,否则可能会导致您本地测试通过,但是提交后系统返回运行超时或者答案错误。建议使用字符串保存输入,再做处理。不要使用’\n’、 ’\0’ 
    作为while的跳出条件,不要认为后台输入数据时以回车符结束(除非特别声明)。 
    9、对于测试用例。判题不会用题目中给出的测试用例,即是说直接printf题目中的测试用例输出是不能得分的,想要投机取巧混一点得分是不行的。另外所有的测试用例都是无法看到的,如果是部分测试用例未通过,并不能知道哪类测试用例没有通过,只能自己去检查是否审题有误,或者是考虑情况是否全面。 
    三、华为上机考试的编程技巧 
    华为机试的考点,有17个部分,包含:排序,求最大最小数,链表,大数、高精度数运算,字符串常见操作,数组常见操作,四则运算,求数的各种附属数,匹配问题,进制转换,二叉树,规划问题,最短路径问题,图联通问题,对数字进行特殊判断。这里简单列举一些机试编程的常用函数和技巧,只是提出一个参考,函数更为具体的用法可以自行查阅。 
    1、排序算法。排序算法有快速排序、选择排序、插入排序、冒泡排序、堆排序、归并排序、桶排序等,在编程里面较为好用的当属冒泡排序,以下是一段冒泡排序的代码,尤其要注意第二个for循环的循环控制语句。

    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    2、字符操作。有很多机试题目需要对字符(不是字符串)进行判断和操作,这里列举一些常用的操作和编程技巧。 
    判断一个字符是数字: if(c>=’0’ && c<=’9’); 
    判断一个字符是大写字母: f(c>=’A’ && c<=’Z’); 
    将char型数字转换为int型的一位数: int b = c - ‘0’; 
    将int型数字转换为char型数字: char c = char(b + ‘0’); 
    将大写字母转换为小写字母: char xiaoxie = daxie + (‘a’ - ‘A’); 
    3、字符串操作 
    依据条件筛选出一个长度不定的字符串:

    int n = 0;
    for(int i=0;i<n;i++)
    {
        if(/*a[i]符合条件*/)
        {
            b[n] = a[i];
            N++;
        }
    }
    B[n] = ‘\0’;
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    以下是string.h库中的常用函数 
    求字符串长度: int len = strlen(str); 
    字符串复制: strcpy(); 
    字符串比较: strcmp(); 
    字符串拼接: strcat(); 
    查询字串: strchr(); 
    查询子串: strstr(); 
    以下是stdlib.h库中的常用函数 
    将数字字符串(如”136”)转换为int型:int i = atoi(str); 
    将数字字符串(如”136”)转换为float型:int f = atof(str); 
    将数字字符串(如”136”)转换为long型:int l = atol(str); 
    将int型多位数字转换为字符串型: itoa(str, i, 10);(第三个参数表示进制) 
    另外C++还有一种string类,可以更方便地对字符串作处理,可自行查阅。 
    4、记录数组原位置并进行交换处理的问题。在编程中经常会遇到对数组元素进行交换,当交换并处理后,需要按原始位置输出时,可以使用结构体来简化编程。例如,对一组整数的最大元素加上次大元素的值,次大元素加上第三大元素的值,第三大元素加上第四大元素的值……最小元素加0,依次对每一个元素进行处理,处理完成后按照原始数组的元素位置输出处理结果,使用结构体来编写程序会使得这种处理变简单,代码如下:

    struct mydata
    {
        int num;//存放数据
        Int index; //记录原始数据的下标位置
    } 
    mydata data[n];
    for(int i=0;i<n;i++)
    {
        std::cin>>mydata.num;
        index = i;
    }
    for(int i=0;i<n;i++)//冒泡排序
    {
        for(int j=0;j<n-1-i;j++)
        {
            if(data[j].num<data[j+1].num)
            {
                mydata temp = data[j];
                data[j] = data[j+1];
                data[j+1] = temp;
            }
        }
    }
    for(int i=1;i<n;i++)//这里要注意,只能从最大元素开始
    {
        data[i].num = data[i].num + data[i+1].num;
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            if(i != data[j].index)
                continue;
            else
            {
                std::cout<<data[j].num;
                break;
            }
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    5、排序函数。C/C++中自带有排序函数sort,位于头文件stdlib.h中,可以实现快速排序(此处说的快速是指编写程序快速,并非排序算法中的快速排序),具体用法为: 
    sort(a,a+len(a));//将数组a按照默认升序排列 
    sort(a,a+len(a),cmp);//将数组a按照cmp函数指定的规则排列,例如如下的为降序规则

    bool cmp(int para1,int para2)
    {
        return a>b;
    }
    • 1
    • 2
    • 3
    • 4

    6、C/C++中定义了vector容器,位于头文件vector中,这是一种类似链表的结构,可以实现动态增长和删除,简单用法如下。 
    几种vector声明: 
    vectorvec1; //定义空的vector 
    vectorvec2(10); //产生大小为10的vector 
    vectorvec3(10,-1); //产生大小为10,并且每个元素都是-1的vector 
    vectorvec4(v3); //用一个vector产生一个vecotr 
    尾部插入元素: vec.push_back(a); 
    尾部删除元素: vec.pop_back(a); 
    插入元素: vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a; 
    删除元素: vec.erase(vec.begin()+2);删除第3个元素 
    vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始 
    向量大小: vec.size(); 
    清空: vec.clear(); 
    实用迭代器访问元素: 
    vector::iterator ita; //声明一个迭代器 
    int i=0; 
    for(ita=v1.begin(), i=0;ita != v1.end();i++,ita++){}//v1.begin()指向v1的第一个元素,v1.end()指向最后元素的下一位置。

    展开全文
  • 华为上机考试题库

    千次下载 热门讨论 2013-05-14 17:20:09
    华为秋季校招时候的上机题库,把这些题都做会了,应该就没有问题了
  • 华为上机考试集锦

    2016-08-10 20:33:00
    2019独角兽企业重金招聘Python工程师标准>>> ...

    1.

    存储日志信息:

    import java.util.*;
    
    public class Main{
    
        public static void main(String[] args){
            Scanner sc=new Scanner(System.in);
    
            Main m=new Main();
            ArrayList list=new ArrayList();
            while(sc.hasNext()){
                if(list.size()>=8)break;
    
                Node n=m.new Node(sc.next(),sc.nextInt());
    
                if(list.contains(n)){
                    ((Node)list.get(list.indexOf(n))).time++;
                }else{
                    list.add(n);
                }
    
                int size=list.size();
                
                for(int i=0;i<size;i++)
                {
                    Node tmp=(Node)list.get(i);
                    System.out.println(tmp.fname+" "+tmp.line+" "+tmp.time);
                }
            }
    
        }
    
        //用于存储信息的结点
        public class Node{
            public String abpath;
            public String fname;
            public int line;
            public int time=1;
    
            public Node(String abpath,int line){
    
                String[] list=abpath.split("\\\\");
                this.fname=list[list.length-1];
                this.line=line;
                this.abpath=abpath;
    
            }
    
            public boolean equals(Object n){
                Node tmp=(Node)n;
    
                return this.abpath.equals(tmp.abpath)&&this.line==tmp.line;
    
            }
        }
    }

     

    2.比较扑克牌的大小

    import java.util.*;
    
    public class Main{
    
        public static void main(String[] args){
            Scanner sc=new Scanner(System.in);
    
            while(sc.hasNextLine()){
                String str=sc.nextLine();
                String[] list=str.split("-");
    
    //先去掉王的情况
                if(list[0].contains("joker JOKER")){
    
                    System.out.println(list[0]);
                    continue;
                }
                if(list[1].contains("joker JOKER")){
    
                    System.out.println(list[1]);
                    continue;
                }
    
                String[] u1=list[0].split(" ");
                String[] u2=list[1].split(" ");
    
                if(u1.length==1&&u2.length==1){
    
                    if(compare(u1[0],u2[0])){
                        System.out.println(list[0]);
                    }else{
                        System.out.println(list[1]);
                    }
    
                }else if(u1.length==2&&u2.length==2){
    
                    if(compare(u1[0],u2[0])){
                        System.out.println(list[0]);
                    }else{
                        System.out.println(list[1]);
                    }
                }else if(u1.length==3&&u2.length==3){
    
                    if(compare(u1[0],u2[0])){
                        System.out.println(list[0]);
                    }else{
                        System.out.println(list[1]);
                    }
                }else if(u1.length==4&&u2.length==4){
                    if(compare(u1[0],u2[0])){
                        System.out.println(list[0]);
                    }else{
                        System.out.println(list[1]);
                    }
                }else if(u1.length>5&&u2.length>5){
    
                    if(compare(u1[0],u2[0])){
                        System.out.println(list[0]);
                    }else{
                        System.out.println(list[1]);
                    }
    
                }else System.out.println("ERROR");
    
            }
        }
    
        public static boolean compare(String a,String b){
            if(a.equals("2")){
                a="15";
            }
            else if(a.equals("J")){
                a="11";
            }
            else if(a.equals("Q")){
                a="12";
            }
            else if(a.equals("K")){
                a="13";
            }
            else if(a.equals("A")){
                a="14";
            }
    
    
            if(b.equals("2")){
                b="15";
            }
            else if(b.equals("J")){
                b="11";
            }
            else if(b.equals("Q")){
                b="12";
            }
            else if(b.equals("K")){
                b="13";
            }
            else if(b.equals("A")){
                b="14";
            }
    
            return a.equals(b);
        }
    }

     

    3.循环移动

    用额外的数组来保存移动之后的结果

    循环移动
    描述:

    有10个整数,使前面各数顺序向后移m个位置,最后m个数变成最前面m个数。

    计算移动后的整数序列的前m个和后m个数的和。

     

    运行时间限制: 无限制
    内存限制: 无限制
    输入:

    先输入10个整数,以空格分隔;

    再输入移动个数(即整数m)。

    输出:

    移动后的整数序列。

    移动后的整数序列的前m个和后m个数的和。

    样例输入:
    1 2 3 4 5 6 7 8 9 10
    3
    样例输出:
    8 9 10 1 2 3 4 5 6 7
    27 18
    view plaincopy to clipboardprint?
    import java.util.*;  
      
    public class Main{  
      
        public static void main(String[] args){  
            Scanner sc=new Scanner(System.in);  
      
            while(sc.hasNext()){  
                int[] tmp=new int[10];  
                int[] list=new int[10];  
                for(int i=0;i<10;i++){  
                    list[i]=sc.nextInt();  
                    tmp[i]=list[i];  
                }  
      
                int m=sc.nextInt();  
      
                for(int i=0;i<10;i++){  
                    list[(i+m)%10]=tmp[i];  
                }  
                int sum=0;  
                for(int i=0;i<10;i++){  
                    if(i!=9)System.out.print(list[i]+" ");  
                    else System.out.println(list[i]);  
                }  
                
                for(int i=0;i<m;i++){  
                    sum+=list[i];  
                }  
                System.out.print(sum+" ");  
                sum=0;  
                for(int i=9;i>9-m;i--){  
                    sum+=list[i];  
                }  
                System.out.print(sum);  
            }  
      
        }  
      
    }    

     

    转载于:https://my.oschina.net/lovezfy/blog/730830

    展开全文
  • 1、选秀节目打分,分为专家评委和大众评委,score[] 数组里面存储每个评委打的分数,judge_type[] 里存储与 score[] 数组对应的评委类别,judge_type[i] == 1,表示专家评委,judge_type[i] == 2,表示大众评委,n...

    1、选秀节目打分,分为专家评委和大众评委,score[] 数组里面存储每个评委打的分数,judge_type[] 里存储与 score[] 数组对应的评委类别,judge_type[i] == 1,表示专家评委,judge_type[i] == 2,表示大众评委,n表示评委总数。打分规则如下:专家评委和大众评委的分数先分别取一个平均分(平均分取整),然后,总分 = 专家评委平均分  * 0.6 + 大众评委 * 0.4,总分取整。如果没有大众评委,则 总分 = 专家评委平均分,总分取整。函数最终返回选手得分。

     函数接口   int cal_score(int score[], int judge_type[], int n) 

     

    1. #include<stdio.h>     
    2. #include<string.h>     
    3. #include<iostream.h>     
    4. #include<conio.h>     
    5. #define N 5     
    6.     
    7. int cal_score(int score[], int judge_type[], int n)     
    8.     
    9. {    
    10.     int expert=0;    
    11.     int dazhong=0;    
    12.     int zongfen=0;    
    13.     int i;    
    14.     int number=0;    
    15.         
    16.     for(i=0;i<N;i++)    
    17.     {    
    18.         if(judge_type[i]==1)    
    19.         {    
    20.             expert=expert+score[i];    
    21.             number++;    
    22.         }    
    23.         else dazhong=dazhong+score[i];    
    24.     }    
    25.     if(number==N)    
    26.     {    
    27.         zongfen=(int)(expert/N);    
    28.     }    
    29.     else    
    30.             
    31.     {    
    32.         expert=(int)(expert/number);    
    33.         dazhong=(int)(dazhong/(N-number));    
    34.         zongfen=int(0.6*expert+0.4*dazhong);    
    35.             
    36.     }    
    37.     return zongfen;    
    38.         
    39. }    
    40. int main()    
    41. {    
    42.     int score[N];    
    43.     int judge_type[N];    
    44.     int numberlast=0;    
    45.     int i;    
    46.     printf("please input the %d score:\n",N);    
    47.     for(i=0;i<N;i++)    
    48.         scanf("%d",&score[i]);    
    49.     printf("please input the level(1:expert,2:dazhong)\n");    
    50.     for(i=0;i<N;i++)    
    51.         scanf("%d",&judge_type[i]);    
    52.     numberlast=cal_score(score,judge_type,N);    
    53.     printf("the last score is %d\n",numberlast);    
    54.     return 0;    
    55. }    


     

    运行结果分析:

    please input the 5 score:
    90 80 87 89 91
    please input the level(1:expert,2:dazhong)
    1 2 1 1 1
    the last score is 85 

     

    2、给定一个数组input[] ,如果数组长度n为奇数,则将数组中最大的元素放到 output[] 数组最中间的位置,如果数组长度n为偶数,则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上,然后再按从大到小的顺序,依次在第一个位置的两边,按照一左一右的顺序,依次存放剩下的数。

          例如:input[] = {3, 6, 1, 9, 7}   output[] = {3, 7, 9, 6, 1};             input[] = {3, 6, 1, 9, 7, 8}    output[] = {1, 6, 8, 9, 7, 3}

    1. #include<stdio.h>     
    2. #include<string.h>     
    3. #include<conio.h>     
    4.     
    5.     
    6.     
    7. void sort(int input[], int n, int output[])    
    8. {    
    9.     int i,j;    
    10.     int k=1;    
    11.     int temp;    
    12.     int med;    
    13.     for(i=0;i<n;i++)    
    14.         for(j=0;j<n-i;j++)    
    15.             if(input[j]>input[j+1])    
    16.             {temp=input[j];input[j]=input[j+1];input[j+1]=temp;}    
    17.             if(n%2!=0)    
    18.             {    
    19.                 for(i=0;i<n;i++)    
    20.                     printf("%2d",input[i]);    
    21.                 printf("\n");    
    22.                 med=(n-1)/2;    
    23.                 output[med]=input[n-1];    
    24.                 for(i=1;i<=med;i++)    
    25.                 {    
    26.                     output[med-i]=input[n-1-k];    
    27.                     output[med+i]=input[n-2-k];    
    28.                     k=k+2;    
    29.                         
    30.                 }    
    31.             }    
    32.             else    
    33.             {    
    34.                     
    35.                 for(i=0;i<n;i++)    
    36.                     printf("%2d",input[i]);    
    37.                 printf("\n");    
    38.                 med=n/2;    
    39.                 output[med]=input[n-1];    
    40.                 for(i=1;i<=med-1;i++)    
    41.                 {    
    42.                     output[med-i]=input[n-1-k];    
    43.                     output[med+i]=input[n-2-k];    
    44.                     k=k+2;      
    45.                 }    
    46.                 output[0]=input[0];                 
    47.             }       
    48.             for(i=0;i<n;i++)    
    49.                     printf("%2d",output[i]);    
    50.                 printf("\n");    
    51. }    
    52.     
    53.     
    54. int main()    
    55. {    
    56.     int a[6]={3,6,1,9,7,8};    
    57.     int b[6]={0};    
    58.     for(int i=0;i<6;i++)    
    59.         printf("%2d",a[i]);    
    60.     printf("\n");    
    61.     sort(a,6,b);    
    62.     return 0;    
    63. }    


    运行结果

    3 6 1 9 7 8
    1 3 6 7 8 9
    1 6 8 9 7 3

    3、操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中,系统任务的优先级 < 50,用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务,应予以剔除。现有一任务队列task[],长度为n,task中的元素值表示任务的优先级,数值越小,优先级越高。函数scheduler实现如下功能,将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 user_task[] 数组中(数组中元素的值是任务在task[] 数组中的下标),并且优先级高的任务排在前面,数组元素为-1表示结束。

          例如:task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}    system_task[] = {0, 3, 1, 7, -1}    user_task[] = {4, 8, 2, 6, -1}

                 函数接口    void scheduler(int task[], int n, int system_task[], int user_task[])

     

    1. #include<stdio.h>     
    2. #include<string.h>     
    3. #include<malloc.h>     
    4. #include<iostream.h>     
    5.     
    6. void scheduler1(int task[], int n, int system_task[], int user_task[])    
    7. {    
    8.     int i;    
    9.     int j=0;    
    10.     int *p,*pp,*p_user,*pp_user;    
    11.     int index=0;    
    12.     int count,count2;    
    13.     int min=0;    
    14.     int k=0;    
    15.     p=(int*)malloc(sizeof(int)*n);    
    16.     for(i=0;i<n;i++)    
    17.         p[i]=0;    
    18.     pp=(int*)malloc(sizeof(int)*n);    
    19.     for(i=0;i<n;i++)    
    20.         pp[i]=0;    
    21.     p_user=(int*)malloc(sizeof(int)*n);    
    22.     for(i=0;i<n;i++)    
    23.         p_user[i]=0;    
    24.     pp_user=(int*)malloc(sizeof(int)*n);    
    25.     for(i=0;i<n;i++)    
    26.         pp_user[i]=0;    
    27.         
    28.     for(i=0;i<n;i++)    
    29.     {    
    30.         if(task[i]<50)    
    31.         {    
    32.             {    
    33.                 system_task[j]=task[i];    
    34.                 pp[j]=i;    
    35.                 j++;    
    36.             }    
    37.             count=j;    
    38.         }    
    39.             
    40.         else if(task[i]<=255)    
    41.         {    
    42.             
    43.             {    
    44.                 user_task[k]=task[i];    
    45.                 pp_user[k]=i;    
    46.                 k++;    
    47.             }    
    48.             count2=k;    
    49.         }    
    50.         else task[i]=task[i];    
    51.         
    52.     }    
    53.         
    54.     for(i=0;i<count;i++)    
    55.         printf("%3d",system_task[i]);    
    56.     printf("\n");    
    57.         
    58.         
    59.     for(i=0;i<count;i++)    
    60.     {    
    61.         min=system_task[0];    
    62.         for(j=1;j<count;j++)    
    63.         {    
    64.                 
    65.             if(system_task[j]<min)    
    66.             {    
    67.                 min=system_task[j];     
    68.                 p[i]=j;         
    69.             }    
    70.                 
    71.         }    
    72.         system_task[p[i]]=51;    
    73.     }    
    74.         
    75.     pp[count]=-1;    
    76.     for(i=0;i<count;i++)    
    77.         printf("%3d",pp[p[i]]);     
    78.     printf("%3d\n",pp[count]);    
    79.         
    80.         
    81.     /***********************************************************/    
    82.         
    83.     for(i=0;i<count2;i++)    
    84.         printf("%4d",user_task[i]);    
    85.     printf("\n");    
    86.         
    87.     for(i=0;i<count2;i++)    
    88.     {    
    89.         min=user_task[0];    
    90.         for(j=1;j<count2;j++)    
    91.         {    
    92.                 
    93.             if(user_task[j]<min)    
    94.             {    
    95.                 min=user_task[j];       
    96.                 p_user[i]=j;            
    97.             }    
    98.                 
    99.         }    
    100.         user_task[p_user[i]]=256;    
    101.     }    
    102.         
    103.     pp_user[count2]=-1;    
    104.     for(i=0;i<count2;i++)    
    105.         printf("%4d",pp_user[p_user[i]]);       
    106.     printf("%3d\n",pp_user[count2]);    
    107.         
    108.         
    109. }    
    110.     
    111.     
    112.     
    113. int main()    
    114. {    
    115.     int task[9]={0, 30, 155, 1, 80, 300,170, 40, 99};    
    116.     int system_task[9]={0};    
    117.     int user_task[9]={0};    
    118.     scheduler1(task,9,system_task,user_task);    
    119.     return 0;    
    120. }    


     

    运行结果:

     0 30  1 40
     0  3  1  7 -1
    155  80 170  99
      4   8   2   6 -1

    展开全文
  • 面试过华为和字节跳动的都知道这两家公司很喜欢与牛客网合作,但牛客网的东西真的垃圾,华为使用牛客网的上机代码测试系统,字节跳动使用牛客网的视频会议(这里推荐腾讯的会议app,比牛客网稳定太多了) ...
  • 华为上机考试-2016-8-29

    千次阅读 2016-08-29 18:37:03
  • 题目:不用库函数求某数的立方根。 三种方法:pow函数、二分法、牛顿迭代法 方法一:pow()函数 方法二:二分法 方法三:牛顿迭代法 参考文章: 求解一个数的立方根(想不懂都难) ......
  • 2012届华为上机考试题目与参考答案

    千次阅读 2011-09-09 22:50:48
    题目一共三道,都比较简单,主要还是注重基础知识的考察。 答案是自己编写的,不一定正确,仅供参考。欢迎大家提出宝贵的意见~~ 1、选秀节目打分,分为专家评委和大众评委,score[] 数组里面存储每个评委打的分数...
  • 1、删除重复字符串(哈希数组的应用) 给定一个字符串,将字符串中所有和前面重复多余的字符删除,其余字符保留,输出处理后的字符串。需要保证字符出现的先后顺序,并且区分大小写。 #include ...
  • //增加难度,并返回最大值和次大值得个数 #include #include #include #include using namespace std; struct word_frequency { int max;...int equal(const char * st1,const char * st2) ... if (strcmp(s
  • //统计一串字符串中出现次数最多和次多的单词 #include #include #include int compare(const char * st1,const char * st2) {  if (strcmp(st1,st2)==0) ...void PickWord(const char* p
  • 华为上机试题

    2016-01-07 14:28:14
    主要是华为上机考试和刷题目的一些试题源代码,亲测有效。
  • 华为JAVA上机考试整理 2018,里面包含了很多常用的算法,字符,数组等的操作,对网络上的各大资源都进行了整合。
  • 华为北京地区上机考试题2012

    千次阅读 2012-09-23 20:21:26
    今天早上突然接到通知上午10在北航主楼F333参加华为上机考试,我应聘了华为的软件开发。 正巧今天全国计算机等级考试也在那里举行。 上机题使用了普通的在线评价系统,有点像ZOJ等系统,不过题目很简单。 ...
  • 华为2016上机考试第一题老师想知道从某某同学当中,分数最高的是多少,现在请你编程模拟老师的询问。当然,老师有时候需要更新某位同学的成绩. 输入描述: 输入包括多组测试数据。 每组输入第一行是两个正整数N和M...
  • 2012届华为校园招聘上机考试题目,附答案!!
  • 华为校招软件上机考试题目解析

    千次阅读 2016-08-11 16:47:10
    华为校招软件上机考试,技术岗需要软件上机考试。总共三道题。 题目 分数 可以提交次数 回文数字判断 100 5 字符串排序 200 5 整数排序 300 5 第一题 回文数字判断描述: 有这样一类数字,他们顺着看和倒...
  • 2016年华为校招上机考试试题答案

    万次阅读 2016-04-06 10:02:35
     华为上机考试试题:   题目1: 输入字符串,提取字符串串中大写字母,注意字符串中可能含有空格等其他字符。  样例输入: 9,AUStralia  样例输出: AUS  参考答案: package huawei; import ...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 207
精华内容 82
关键字:

华为上机考试