1. 首页
    2. 文档
    3. 企业

    2014华为校园招聘机试整理及本人华为面试经历


    整理网２０１４华机试题十网页资料时道题均进行验证题目进行更修正希者帮助

    1．第题题目概输入整型数组求数组数数例输入1234输出5输入数时候数数该数例输入1输出2外数组长度超50
    #include
    main()
    {
    int num[50]{0}
    int in

    printf(请输入整型数组长度(1~50)：)
    scanf(d&n)

    printf(请输入整型数组元素：)
    for (i0i {
    scanf(d&num[i])
    }

    int min_numnum[0]
    int max_numnum[0]
    for(int j0j {
    if(max_num max_numnum[j]
    else if(min_num>num[j])
    min_numnum[j]
    }
    int summin_num+max_num
    printf(数组中值：d＼nsum)
    return 0
    }

    2．求两长长整型数输出例输入1233333333333333 3111111111111111111111111输出
    #include
    #include
    #include
    main()
    {
    char *num1*num2 两长长整型数
    char *sum
    int temp
    int len_num1len_num2 两长长整型数长度
    int len_maxlen_min
    num1(char*)malloc(sizeof(char))
    num2(char*)malloc(sizeof(char))
    printf(输入两长长整型数：)
    scanf(snum1)
    printf(输入两长长整型数：)
    scanf(snum2)
    len_num1strlen(num1)
    len_num2strlen(num2)
    len_max(len_num1>len_num2) len_num1len_num2
    len_min(len_num1 int len_max1len_max
    sum(char*)malloc(sizeof(char)*len_max)
    memset(sum0x00len_max+1)切忌初始化
    for(len_num1>0&&len_num2>0len_num1len_num2)
    {
    sum[len_max]((num1[len_num11]＇0＇)+(num2[len_num21]＇0＇))
    }
    if(len_num1>0)
    {
    sum[len_max]num1[len_num1 1 ]＇0＇
    len_num1
    }
    if(len_num2>0)
    {
    sum[len_max]num1[len_num2 1]＇0＇
    len_num2
    }
    for(int jlen_max1j>0j) 实现进位操作
    {
    tempsum[j]＇0＇
    if(sum[j]>10)
    {
    sum[j1]+sum[j]10
    sum[j]10
    }
    }
    char *outsum(char*)malloc(sizeof(char)*len_max1)
    j0
    while(sum[j]0) 跳出头部0元素
    j++
    for(int m0m outsum[m]sum[j]+＇0＇
    outsum[m]＇＼0＇
    printf(输出两长长整型数s＼noutsum)
    return 0
    }

    3通键盘输入串写字母(a~z)组成字符串请编写字符串滤程序字符串中出现相字符非首次出现字符滤掉
    字符串abacacde滤结果abcde
    求实现函数：
    void stringFilter(const char *pInputStr long lInputLen char *pOutputStr)
    输入 pInputStr： 输入字符串
    lInputLen： 输入字符串长度
    输出 pOutputStr： 输出字符串空间已开辟输入字符串等长
    #include
    #include
    #include
    void stringFilter(const char *p_str long len char *p_outstr)
    {
    int array[256]{0}
    const char *tmp p_str
    for(int j0j {
    if(array[tmp[j]]0)
    *p_outstr++ tmp[j]
    array[tmp[j]]++
    }
    *p_outstr ＇＼0＇
    }

    void main()
    {
    char *str cccddecc
    int len strlen(str)
    char * outstr (char *)malloc(len*sizeof(char))
    stringFilter(strlenoutstr)
    printf(s＼noutstr)
    free(outstr)
    outstr NULL
    }

    4通键盘输入串写字母(a~z)组成字符串请编写字符串压缩程序字符串中连续出席重复字母进行压缩输出压缩字符串
    压缩规：
    1 仅压缩连续重复出现字符字符串abcbc连续重复字符压缩字符串abcbc
    2 压缩字段格式字符重复次数+字符例：字符串xxxyyyyyyz压缩成3x6yz

    求实现函数：
    void stringZip(const char *pInputStr long lInputLen char *pOutputStr)

    输入 pInputStr： 输入字符串
    lInputLen： 输入字符串长度
    输出 pOutputStr： 输出字符串空间已开辟输入字符串等长
    #include
    #include
    #include

    void stringZip(const char *p_str long len char *p_outstr)
    {
    int count1
    for(int i0i {
    if(p_str[i]p_str[i+1])
    {
    count++
    }
    else
    {
    if(count>1)
    {
    *p_outstr++ count +＇0＇
    *p_outstr++ p_str[i]
    }
    else
    {
    *p_outstr++ p_str[i]
    }
    count 1注意位置
    }
    }
    *p_outstr ＇＼0＇
    }

    void main()
    {
    char *str cccddecc
    printf(压缩前字符串：s＼nstr)
    int len strlen(str)
    char * outstr (char*)malloc(len*sizeof(char))
    stringZip(strlenoutstr)
    printf(压缩字符串：s＼noutstr)
    free(outstr)
    outstr NULL
    }
    5通键盘输入100正整数加减运算式请编写程序输出运算结果字符串
    输入字符串格式：操作数1 运算符 操作数2操作数运算符间空格隔开

    补充说明：
    1 操作数正整数需考虑计算结果溢出情况
    2 输入算式格式错误输出结果0

    求实现函数：
    void arithmetic(const char *pInputStr long lInputLen char *pOutputStr)

    输入 pInputStr： 输入字符串
    lInputLen： 输入字符串长度
    输出 pOutputStr： 输出字符串空间已开辟输入字符串等长
    #include
    #include
    #include
    void arithmetic(const char *input long len char *output)
    {
    char s1[10]
    char s2[10]
    char s3[10]
    int cnt 0
    int len_inputstrlen(input)
    for(int i0i {
    if(input[i]＇ ＇)
    cnt++
    }

    if(cnt2)
    {
    *output++ ＇0＇
    *output ＇＼0＇
    return
    }

    sscanf(inputs s ss1s2s3)
    if(strlen(s2)1||(s2[0]＇+＇&&s2[0]＇＇))
    {
    *output++ ＇0＇
    *output ＇＼0＇
    return

    }

    int len_s1strlen(s1)
    for(i0i {
    if(s1[i]<＇0＇||s1[i]>＇9＇)
    {
    *output++ ＇0＇
    *output ＇＼0＇
    return
    }
    }

    int len_s3strlen(s3)
    for(i0i {
    if(s3[i]<＇0＇||s3[i]>＇9＇)
    {
    *output++ ＇0＇
    *output ＇＼0＇
    return
    }
    }

    int x atoi(s1)
    int y atoi(s3)
    if(s2[0]＇+＇)
    {
    int result x+y
    itoa(resultoutput10)
    }
    else if(s2[0]＇＇)
    {
    int result xy
    itoa(resultoutput10)
    }
    else
    {
    *output++ ＇0＇
    *output ＇＼0＇
    return

    }

    }
    void main()
    {
    char str[] {10 23}
    char outstr[10]
    int len strlen(str)
    arithmetic(strlenoutstr)
    printf(s＼nstr)
    printf(s＼noutstr)
    }

    6组（n）围成圈某开始数第三出列接着开始数终输出终出列
    （约瑟夫环数学应问题：已知n（编号123n分表示）围坐张圆桌周围编号k开始报数数m出列1开始报数数m出列规律重复直圆桌周围全部出列）
    #include
    #include
    #include
    #include

    typedef struct Node
    {
    int data
    struct Node *next
    }LinkList

    LinkList *create(int n)
    {
    LinkList *p*q*head
    int i1
    p(LinkList*)malloc(sizeof(LinkList))
    p>datai
    headp

    for(i1i {
    q(LinkList*)malloc(sizeof(LinkList))
    q>datai+1
    p>nextq
    pq
    }
    p>nexthead 链表尾连接链表头形成循环链表
    return head
    free(p)
    pNULL
    free(q)
    qNULL
    }

    void deletefun(LinkList *Lint m)
    {
    LinkList *p*q*temp
    int i
    pL

    while(p>nextp)
    {
    for(i1i {
    qp
    pp>next
    }
    printf(5dp>data)
    tempp
    q>nextp>next
    pp>next
    free(temp)
    }
    printf(5d＼np>data)
    }

    int main()
    {
    int n7m3
    LinkList *head1
    head1create(n)
    deletefun(head1m)
    return 0
    }
    7输入串字符包含010找出中数字数字（止）输出剩余数字数 输入 3345677
    #include
    #include
    #include

    void main()
    {
    char str[100]
    printf(输入组字符串：＼n)
    scanf(s&str)

    int lenstrlen(str)
    int array[100]
    int count0
    for(int i0i {
    if(str[i]>＇0＇&&str[i]<＇9＇)
    array[count++]str[i]＇0＇

    }
    array[count]＇＼0＇
    int resultcount
    int minarray[0]
    int maxarray[0]
    for(int j0j {
    if(max maxarray[j]
    else if(min>array[j])
    minarray[j]
    }
    for(int k0k {
    if(array[k]min)
    result
    if(array[k]max)
    result
    }
    printf(d＼nresult)
    }
    8输入组身高170190间（5身高）较身高差选出身高差两身高身高差相选均身高高两身高输出
    输入 170 181 173 186 190 输出 170 173
    #include
    #include
    #define N 5

    int main()
    {
    int Height[N]
    int dmin
    int H1H2
    int ijtemp

    printf(请输入组身高170190间数（5）＼n)
    for(int k0k scanf(d&Height[k])
    printf(＼n)

    for(i0i for(j1jHeight[j]j++)
    {
    tempHeight[j1]
    Height[j1]Height[j]
    Height[j]temp
    }

    H1Height[0]
    H2Height[1]
    dminH2H1
    for(int m2m {
    if(Height[m]Height[m1] {
    H1Height[m1]
    H2Height[m]
    dminHeight[m]Height[m1]
    }
    }
    printf(身高差两身高＼n)
    printf(dd＼nH1H2)
    return 0
    }
    9 删子串原串中相子串删掉少返回子串数
    #include
    #include
    #include
    #include
    int delete_sub_str(const char *strconst char *sub_strchar *result)
    {
    assert(str NULL && sub_str NULL)
    const char *p*q
    char *t*temp
    p str
    q sub_str
    t result
    int ncount 0
    n strlen(q)
    temp (char *)malloc(n+1)
    memset(temp0x00n+1)
    while(*p)
    {
    memcpy(temppn)
    if(strcmp(tempq) 0 )
    {
    count++
    memset(temp0x00n+1)
    p p + n
    }
    else
    {
    *t *p
    p++
    t++
    memset(temp0x00n+1)
    }
    }
    free(temp)
    return count
    }
    void main()
    {
    char s[100] {＼0’}
    int num delete_sub_str(123abc12de234fg1hi34j123k123s)
    printf(The number of sub_str is d＼r＼nnum)
    printf(The result string is s＼r＼ns)
    }
    10 求编程实现述高精度十进制加法求实现函数：
    void add (const char *num1 const char *num2 char *result)
    输入num1：字符串形式操作数1果操作数负num1[0]符号位＇＇
    num2：字符串形式操作数2果操作数负num2[0]符号位＇＇
    输出result：保存加法计算结果字符串果结果负result[0]符号位
    #include
    #include
    #include

    void move(char *str int length) 移字母前符号
    {
    if(str[0] ＇＇)
    return
    int i
    for(i 0 i < length1 i++)
    str[i] str[i+1]
    str[i] ＇＼0＇
    }

    int remove_zero(char *result int length)
    {
    int count 0
    for(int i length1 i > 0 i) 开始移0直遇非0数字初位置0予判断
    {
    if(result[i] ＇0＇)
    {
    result[i] ＇＼0＇
    count++
    }else
    return lengthcount
    }
    return length count
    }

    void reverse(char *result int length) 字符串倒转
    {
    char temp
    for(int i 0 i < (length1)2 i++)
    {
    temp result[i]
    result[i] result[length1i]
    result[length1i] temp
    }
    }

    int real_add(char *str1 char *str2 char *result const bool flag)
    {
    int len1 strlen(str1)
    int len2 strlen(str2)
    int n1 n2 another 0 another表示进位
    int cur_rs 0 表示result前位数
    int i j
    int curSum
    for(i len11 j len21 i > 0 && j > 0 i j)
    {
    n1 str1[i] ＇0＇
    n2 str2[j] ＇0＇
    curSum n1 + n2 + another
    result[cur_rs++] curSum 10 + ＇0＇
    another curSum 10
    }

    if(j < 0)
    {
    while(i > 0) 遍历str1剩余位
    {
    n1 str1[i] ＇0＇
    curSum n1 + another
    result[cur_rs++] curSum 10 + ＇0＇
    another curSum 10
    }
    if(another 0) 果进位未加
    result[cur_rs++] another + ＇0＇
    }
    else
    {
    while(j > 0)
    {
    n2 str2[j] ＇0＇
    curSum n2 + another
    result[cur_rs++] curSum 10 + ＇0＇
    another curSum 10
    }
    if(another 0)
    result[cur_rs++] another + ＇0＇
    }

    result[cur_rs] ＇＼0＇

    cur_rs remove_zero(result cur_rs)
    if(flag)
    {
    result[cur_rs++] ＇＇
    result[cur_rs] ＇＼0＇
    }
    reverse(result strlen(result))
    return cur_rs
    }


    int real_minus(char *str1 char *str2 char *result) str1减str2
    {
    char big[100] small[100]
    int big_len sml_len

    int len1 strlen(str1)
    int len2 strlen(str2)
    bool flag false 标记str2否str1

    if(len1 < len2)
    flag true
    else if(len1 len2)
    {
    if(strcmp(str1 str2) 0)
    {
    result[0] ＇0＇
    result[1] ＇＼0＇
    return 1
    }else if(strcmp(str1str2) < 0)
    flag true
    }

    if(flag) str1str2交换确保str1指值中较者通flag确定前面加号
    {
    char *temp str1
    str1 str2
    str2 temp
    len1 strlen(str1)
    len2 strlen(str2)
    }

    int n1 n2 another 0 another表示否位
    int i j
    int cur_rs 0
    int curMinus

    for(i len11 j len21 i>0 && j>0 ij)
    {
    n1 str1[i] ＇0＇
    n2 str2[j] ＇0＇
    if(n1 > n2+another)
    {
    result[cur_rs++] (n1n2another) +＇0＇
    another 0
    }
    else
    {
    result[cur_rs++] (n1+10n2another) + ＇0＇
    another 1
    }
    }

    while(i > 0)
    {
    n1 str1[i] ＇0＇
    if(another 0)
    {
    n1 another
    another 0
    }
    result[cur_rs++] n1 + ＇0＇
    }

    result[cur_rs] ＇＼0＇
    cur_rs remove_zero(result cur_rs)
    if(flag)
    {
    result[cur_rs++] ＇＇
    result[cur_rs] ＇＼0＇
    }
    reverse(result cur_rs)

    return cur_rs
    }

    void addi(const char *num1 const char *num2 char *result)
    {
    int len1 strlen(num1)
    int len2 strlen(num2)
    int rs_len
    if(len1 || len2)
    return
    char str1[100] str2[100]
    strncpy(str1 num1 len1)
    str1[len1] ＇＼0＇
    strncpy(str2 num2 len2)
    str2[len2] ＇＼0＇

    if(str1[0] ＇＇ && str2[0] ＇＇)
    {
    move(str1 len1)
    move(str2 len2)
    rs_len real_add(str1 str2 result false)
    }else if(str1[0] ＇＇)
    {
    move(str1 len1)
    rs_len real_minus(str2 str1 result)
    }
    else if(str2[0] ＇＇)
    {
    move(str2 len2)
    rs_len real_minus(str1 str2 result)
    }else
    rs_len real_add(str1 str2 result true)
    }

    int main(int argc char *argv[])
    int main()
    {
    char num1[100]num2[100]
    printf(请输入两整型数：＼n)
    scanf(ssnum1num2)

    char result[100]
    memset(result 0 100)
    addi(num1num2 result)
    printf(s＼n result)

    return 0
    }
    11 描述：10学生考完期末考试评卷完成A老师需划出格线求：
    (1) 格线10倍数
    (2) 保证少60学生格
    (3) 果学生高60分格线60分
    输入：输入10整数取值0~100
    输出：输出格线10倍数
    #include

    void bubblesort(int arr[])
    {
    int ijtemp
    for(i0i<10i++)
    for(j0j<9i&&arr[j]>arr[j+1]j++)
    {
    temparr[j]
    arr[j]arr[j+1]
    arr[j+1]temp
    }
    }

    int GetPassLine(int a[])
    {
    bubblesort(a)
    if(a[0]>60)
    return 60
    else
    return (((int)a[4]10)*10)
    }

    main()
    {
    int a[10]{0}
    int result
    printf(请机输入10成绩（0100）：＼n)
    scanf(dddddddddd&a[0]&a[1]&a[2]&a[3]&a[4]&a[5]&a[6]&a[7]&a[8]&a[9])
    printf(＼n)
    resultGetPassLine(a)
    printf(格线d＼nresult)
    return 1
    }

    12 描述：条长廊里次装n(1 ≤ n ≤ 65535)盏电灯头尾编号123…n1n盏电灯拉线开关控制开始电灯全部关着
    n学生长廊穿第学生号码1倍数电灯开关拉接着第二学生号码2倍数电灯开关拉接着第三学生号码3倍数电灯开关拉继续第n学生号码n倍数电灯开关拉n学生规定走完长廊里电灯盏亮着注：电灯数学生数致
    输入：电灯数量
    输出：亮着电灯数量
    样例输入：3
    样例输出：1

    #include
    #define Max_Bubl_Num 65535

    int GetLightLampNum(int n)
    {
    int BublNum[Max_Bubl_Num]{0} 0表示灯灭1表示灯亮
    unsigned int ij
    unsigned int count0
    for(i1i for(jij {
    BublNum[j1]+1
    BublNum[j1]BublNum[j1]2
    }

    for(int k0k {
    if(BublNum[k]1)
    count++
    }
    return count
    }
    int main()
    {
    int nresult
    printf(请输入灯数量（165535）＼n)
    scanf(d&n)
    resultGetLightLampNum(n)
    printf(亮灯数量d＼nresult)
    return 0
    }
    13 描述：已知2条铁线路中A环线B东西线路线路双站点名分两条线交叉换点T1T2表示编写程序意输入两站点名称输出坐铁少需车站数量（含输入起点终点换站点计算次）
    铁线A（环线）车站：A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
    铁线B（直线）车站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
    输入：输入两站名
    输出：输出少站数含输入起点终点换站点计算次
    输入样例：A1 A3
    输出样例：3
    #include
    #include
    #include
    #include
    using namespace std

    #define MAX 35
    #define SUBWAY_A 20
    #define SUBWAY_B 15
    typedef struct node{
    int adjvex
    struct node *next
    }edgenode
    typedef struct{
    char name[10]
    bool flag
    edgenode *link
    }vexnode

    const char subway_name1[SUBWAY_A][10]{A1A2A3A4A5A6A7A8A9T1A10A11A12A13T2A14A15A16A17A18}
    const char subway_name2[SUBWAY_B][10]{B1B2B3B4B5B6B7B8B9B10B11B12B13B14B15}
    void creat(vexnode ga[]){
    int i
    edgenode *p
    for(i0i ga[i]linkNULL
    ga[i]flagtrue
    if(i else strcpy(ga[i]namesubway_name2[i20])
    }
    A铁建邻接表
    for(i1i p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexi1
    p>nextNULL
    ga[i]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexi+1
    p>nextNULL
    ga[i]link>nextp
    if(i9){
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+4
    p>nextNULL
    ga[i]link>next>nextp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+5
    p>nextNULL
    ga[i]link>next>next>nextp
    }
    else if(i14){
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+9
    p>nextNULL
    ga[i]link>next>nextp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+10
    p>nextNULL
    ga[i]link>next>next>nextp
    }
    }
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A1
    p>nextNULL
    ga[0]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvex1
    p>nextNULL
    ga[0]link>nextp

    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A2
    p>nextNULL
    ga[SUBWAY_A1]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvex0
    p>nextNULL
    ga[SUBWAY_A1]link>nextp

    B铁建邻接表
    for(i1i if(i4||i5||i9||i10) continue
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+i1
    p>nextNULL
    ga[i+SUBWAY_A]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+i+1
    p>nextNULL
    ga[i+SUBWAY_A]link>nextp
    }
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+3
    p>nextNULL
    ga[SUBWAY_A+4]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvex9
    p>nextNULL
    ga[SUBWAY_A+4]link>nextp

    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvex9
    p>nextNULL
    ga[SUBWAY_A+5]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+6
    p>nextNULL
    ga[SUBWAY_A+5]link>nextp

    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+8
    p>nextNULL
    ga[SUBWAY_A+9]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvex14
    p>nextNULL
    ga[SUBWAY_A+9]link>nextp

    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvex14
    p>nextNULL
    ga[SUBWAY_A+10]linkp
    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+11
    p>nextNULL
    ga[SUBWAY_A+10]link>nextp

    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+1
    p>nextNULL
    ga[SUBWAY_A]linkp

    p(edgenode*)malloc(sizeof(edgenode))
    p>adjvexSUBWAY_A+SUBWAY_B2
    p>nextNULL
    ga[SUBWAY_A+SUBWAY_B1]linkp
    印邻接节点
    for(i0i printf(sga[i]name)
    edgenode *s
    sga[i]link
    while(sNULL){
    printf(>sga[s>adjvex]name)
    ss>next
    }
    printf(＼n)
    }

    }
    int main(){
    vexnode ga[MAX]
    creat(ga)
    int i
    char str[2][10]
    while(scanf(ssstr[0]str[1])EOF){
    int temp0
    for(i0i ga[i]flagtrue
    if(strcmp(str[0]ga[i]name)) tempi
    }
    queueq
    qpush(ga[temp])
    ga[temp]flagfalse
    int count0
    int start0
    int end1
    bool find_flagfalse
    while(qempty()){
    if(find_flag) break
    count++
    printf(************************＼n)
    printf(第d层搜索：count)
    int temp_endend
    while(start printf(s qfront()name)
    if(strcmp(qfront()namestr[1])){
    find_flagtrue
    break
    }
    edgenode *s
    sqfront()link
    while(sNULL){
    if(ga[s>adjvex]flag){
    qpush(ga[s>adjvex])
    ga[s>adjvex]flagfalse
    end++
    printf(s ga[s>adjvex]name)
    }
    ss>next
    }
    qpop()
    start++
    }
    printf(＼n)
    }
    printf(d＼ncount)
    }
    return 0
    }
    14 字串转换
    问题描述：
    输入字符串（字符串仅包含写字母a’z’）规循环转换输出：a>bb>c…y>zz>a输入字符串连续出现两字母相时字母需连续转换2次例：aa 转换 bczz 转换 ab连续相字母超两时第三出现字母第次出现算
    求实现函数：
    void convert(char *inputchar* output)
    输入 char *input 输入字符串
    输出 char *output 输出字符串
    返回
    #include
    #include
    #include

    void convert(char *inputchar* output)
    {
    if(inputNULL)
    return
    char temp＇＼0＇
    int len_inputstrlen(input)
    int i
    int flag0

    for(i0i {
    if(input[i]temp)
    {
    output[i](input[i]＇a＇+1)26+＇a＇
    tempinput[i]
    flag1
    }
    else
    {
    if(flag1)
    {
    output[i](input[i]＇a＇+2)26+＇a＇
    tempinput[i]
    flag0
    }
    else
    {
    output[i](input[i]＇a＇+1)26+＇a＇
    tempinput[i]
    flag1
    }
    }
    }
    output[i]＇＼0＇
    }

    void main()
    {
    char *inputxyz
    char output[256]
    scanf(sinput)
    convert(inputoutput)
    printf(s＼noutput)
    }
    15 定字符串中找出单词（ 单词写字母写字母字符构成非字母字符视单词间隔空格问号数字等等外单字母算单词）找单词长度进行降序排序（排序时果长度相出现序进行排列）然输出新字符串中果某单词重复出现次输出次果整输入字符串中没找单词请输出空串输出单词间空格隔开单词加空格
    求实现函数：
    void my_word(charinput[] char output[])
    输入 char input[] 输入字符串
    输出 char output[]输出字符串
    返回
    #include
    #include
    #include

    void my_word(char input[]char output[])
    {
    char *p
    char *temp
    char *word[10]
    int len_inputstrlen(input)
    int ij
    char except[]
    char *blank
    i0
    for (i0i {
    if (input[i]<＇A＇ || (input[i]>＇Z＇&&input[i]<＇a＇) || input[i]>＇z＇)
    {
    input[i]＇＇
    }
    }

    j0
    *保存取出单词*
    p strtok(inputexcept)
    while(NULLp)
    {
    word[j++]p
    p strtok(NULLexcept)
    }
    for(i0i<5i++)
    printf(sword[i])
    *单词长度降序排序泡法*
    for (i0i<5i++)
    {
    for (j1j<5ij++)
    {
    if(strlen(word[j1]) {
    tempword[j]
    word[j]word[j1]
    word[j1]temp
    }
    }

    }
    *删相单词*
    for (i0i<5i++)
    {
    for(ji+1j<5j++)
    {
    if(strcmp(word[i]word[j])0)
    word[j]＼0
    }
    }
    *单词连接起输出*
    for (j0j<5j++)
    {
    if (0j)
    {
    strncpy(outputword[j]strlen(word[j])+1)
    }
    else
    {
    strcat(outputblank)
    strcat(outputword[j])
    }
    }
    return
    }
    int main()
    {

    char input[] some local buses some1234123drivers
    printf(筛选前字符串s＼ninput)
    char output[30]
    my_word(inputoutput)
    printf(筛选字符串soutput)
    printf(＼n)
    return 0
    }
    １６ 数组中数字两两相找出该数字：
    int findUnique(int* a int len)
    {
    int i 1
    int temp a[0]
    for( i < len i++)
    {
    temp temp ^ a[i]
    }
    printf(d temp)
    }
    17 题目二：数组中数字两两相两找出两：

    #include

    int a[] {11243325}

    int findXorSum(int* a int len)
    {
    int i 0
    int temp 0
    for( i < len i++)
    {
    temp temp ^ a[i]
    }
    return temp
    }

    int findFirstBit1(int n)
    {
    int count 1
    while(( n & 1))
    {
    n n>>1
    count++
    }
    return count
    }

    int isBit1(int a int count)
    {
    a a >> count1
    return (a & 1)
    }

    void findTwoUnique(int* a int len)
    {
    int i 0
    int m 0 n 0
    int temp findXorSum(a len)
    int count findFirstBit1(temp)
    for( i < len i++)
    {
    if(isBit1(a[i]count))
    {
    m m ^ a[i]
    }
    else
    {
    n n ^ a[i]
    }
    }
    printf(d d m n)
    }

    int main()
    {
    findTwoUnique(a8)
    }
    18 链表翻转出链表数k链表1→2→3→4→5→6k2翻转2→1→4→3→6→5k3翻转3→2→1→6→5→4k4翻转4→3→2→1→5→6程序实现
    思想：采遍历链表分成lengthk组组进行逆转逆转时逆转尾头连接起
    #include stdafxh
    #include stdioh
    #include stdlibh
    #include

    typedef struct Node{
    int value
    Node* next
    }LinkList

    void Converse(LinkList* pPreLinkList* pCur)
    { 链表逆转
    LinkList* p NULL
    LinkList* pNext NULL
    p pPre>next
    LinkList* p1 NULL
    if(pCurNULL)
    pNext pCur>next

    while( ppNext)
    {
    p1 p>next
    p>next pPre
    pPre p
    p p1
    }
    }

    int main()
    {
    int count 0 ki0j0flag 1length0groups 0
    scanf(d&k)
    LinkList* pPre (LinkList*)malloc(sizeof(LinkList))
    LinkList* pCur (LinkList*)malloc(sizeof(LinkList))
    LinkList* pNext (LinkList*)malloc(sizeof(LinkList))
    LinkList* head NULL
    LinkList* pTempTail NULL 指逆转尾部
    LinkList* pTempHead NULL

    pCur>value 1
    pPre pCur 创建初始链表
    for(i2i<6i++) {
    LinkList* node (LinkList*)malloc(sizeof(LinkList))
    node>value i
    pCur>next node
    pCur node
    }
    pCur>next NULL定置NULLc++中new须置NULL

    pCur pPre
    while(pCurNULL)
    {
    length++
    pCur pCur>next
    }
    i0
    groups lengthk 分成K段
    pCur pPre
    while(i {
    count 0
    while(count {
    pCur pCur>next
    count++
    }

    if(i {
    pNext pCur>next
    pTempHead pCur *没做翻转前头部变成翻转尾部*
    if(flag 0)
    {
    pTempTail>next pTempHead
    }
    pTempTail pPre
    Converse(pPrepCur)
    pTempTail pPre
    if(flag1)
    {
    head pCur
    flag 0
    }
    pCur pNext
    }
    else
    {
    pTempTail>next pNext
    }
    pPre pCur
    i++
    }


    pCur head

    while(j j++
    printf(dpCur>value)
    pCur pCur>next
    }
    printf(＼n)
    system(pause)
    return 0
    }
    19 链表相邻元素翻转a>b>c>d>e>fg翻转变：b>a>d>c>f>e>g
    #include
    #include
    #include

    typedef struct node{
    char val
    struct node* pNext
    }Node

    Node* CreateList(int n)
    void Traverslist(Node* pHead)
    Node* TransNeighbor(Node* pHead)

    int main(){
    Node* pHead CreateList(7)
    printf(before transform＼n)
    Traverslist(pHead)
    TransNeighbor(pHead)
    printf(＼nafter transform＼n)
    Traverslist(pHead)
    getchar()
    return 1
    }
    创建新链表
    Node* CreateList(int n){
    Node* pHead (Node*)malloc(sizeof(Node))
    Node* pTail pHead
    pTail>pNextNULL
    int i
    for(i0 i < n i++){
    Node* pNew (Node*)malloc(sizeof(Node))
    pNew>val ＇a＇+i
    pTail>pNext pNew
    pNew>pNext NULL
    pTail pNew

    }
    return pHead
    }

    void Traverslist(Node* pHead){
    Node* p pHead>pNext
    int isFirst 0
    while(p NULL)
    {
    if(isFirst0)
    {
    printf(cp>val)
    isFirst1
    }else{
    printf(>cp>val)
    }
    p p>pNext
    }
    return
    }

    Node* TransNeighbor(Node* pHead){
    Node* p pHead>pNext
    while(p>pNextNULL && p>pNext>pNextNULL)
    {
    char value p>val
    p>valp>pNext>val
    p>pNext>valvalue
    pp>pNext>pNext
    }
    return pHead
    }
    20 输入串字符串中普通字符括号组成（包括（’）’[’＇]＇）求验证括号否匹配果匹配输出0否输出1
    #include
    #include
    #define MAX 100
    int main()
    {
    char a[100]c[](((1+2))
    int i0j0
    int flag0
    while(c[i]NULL&&flag0)
    {
    switch(c[i])
    {
    case(＇(＇)
    case(＇[＇)
    a[j++]c[i]break
    case(＇)＇)
    if(a[j1]＇(＇)
    {
    a[j1]＇＼0＇
    j
    }
    else
    flag1
    break
    case(＇]＇)
    if(a[j1]＇[＇)
    {
    a[j1]＇＼0＇
    j
    }
    else
    flag1
    break

    }
    i++
    }
    if(j0) flag1
    printf(d＼nflag)
    return 0
    }
    方法2：#include
    #include
    #include 分配存头文件
    #define m 20
    typedef char ElemType
    typedef struct
    {
    ElemType stack[m]
    int top
    }stacknode
    stacknode *sp
    Init(stacknode *st)
    {
    st>top0
    return 0
    }
    void Push(stacknode *stElemType x)
    {
    if(st>topm)
    printf(The stack is overflow＼n)
    else
    {
    st>topst>top+1
    st>stack[st>top]x
    }
    }
    void Pop(stacknode *st)
    {
    st>topst>top1
    }
    main()
    {
    char s[m](()
    int i
    printf(Creat a stack＼n)
    sp (stacknode *)malloc(sizeof(stacknode)) 添加语句
    Init(sp)
    printf(Input a expression＼n)
    gets(s)
    for(i0i {
    if(s[i]＇(＇)
    Push(sps[i])
    if(s[i]＇)＇)
    Pop(sp)
    }
    if(sp>top0)
    printf(左右括号匹配＼n)
    else
    printf(左右括号匹配＼n)
    return 0
    }
    ２１．第行中含第二行中23数输出排序
    2输入行数字：123 423 5645 875 186523
    输入第二行：23
    第行中含第二行中23数输出排序
    结果：123 423 186523
    #include
    #define M 20

    int main()
    {
    int a[M]
    int ijstemp
    int sort[M]t0
    char c＇ ＇
    i0
    while(c＇＼n＇)
    {
    scanf(dc&temp&c)
    a[i++]temp
    }
    scanf(d&s)
    for(j0j {
    tempa[j]
    if(temp100s)
    {
    sort[t++]a[j]
    }
    else
    temp10
    }
    for(i0i for(j0j {
    if(sort[j]>sort[j+1])
    {
    tempsort[j+1]
    sort[j+1]sort[j]
    sort[j]temp
    }
    }
    for(i0i printf(d sort[i])
    printf(＼n)
    return 0
    }
    ２２输入m字符串 整数n 字符串M化成N单位段足位数0补齐
     n8 m9 
    123456789划分：12345678
    90000000
    123化 ：12300000
    #include
    #include

    int main()
    {
    char c[200]{＇＼0＇}
    scanf(s&c)
    int nij
    int lenstrlen(c)
    scanf(d&n)
    for(i1i {
    jin
    printf(cc[i1])
    if(j0)
    printf(＼n)
    }
    if(j0)
    for(ij+1i printf(0)
    return 0
    }
    ２３ 电话号码 one two nine zero
    翻译成1  2 9 0
    中间会double
    例输入：OneTwoThree
    输出：123
    输入：OneTwoDoubleTwo
    输出：1222
    输入：1Two2 输出：ERROR
    输入：DoubleDoubleTwo 输出：ERROR
    空格非法字符两Double相连Double位单词 错误
    #include
    #include
    #include
    int main()
    {
    char a[11][11]{zeroonetwothreefourfivesixseveneightninedouble}
    char temp[11] c＇ ＇
    int ijfd0
    while(c＇＼n＇)
    {
    scanf(sc&temp&c)
    f0
    for(j0j<11j++)
    {
    if(strcmp(tempa[j])&&j<10)
    {
    printf(dj)
    f1
    if(d1)
    {
    printf(dj)
    d0
    }
    }
    else if(strcmp(tempa[j])&&j10)
    {
    d1
    f1
    }
    }
    if(f0)
    break
    }
    if(d1||f0)
    printf(error＼n)
    printf(＼n)
    return 0
    }
    ２４．整数倒序输出剔重复数
    输入整数123365441750然位开始倒输出果0输出输出数字带重复数字面输出456321571果负数输入175输出571
    #include
    #include
    #include
    #include

    int main()
    {
    char *input(char*)malloc(sizeof(char))
    scanf(sinput)
    int a[10]{0}iflag0flag10
    int lenstrlen(input)
    if(input[0]＇＇)
    {
    flag1
    for(i0i input[i]input[i+1]
    }
    int len1strlen(input)
    int n[50]temp
    int count0
    for(i0i {
    tempinput[i]＇0＇
    if(a[temp]0)
    {
    n[count++]temp
    a[temp]1
    }
    }
    n[count]＇＼0＇
    if(flag1)
    printf()

    for(int iicount1ii>0ii)
    {
    if(n[ii]0||flag10)
    {
    printf(dn[ii])
    flag11
    }
    }
    printf(＼n)
    return 0
    }


    ２５．编程时候if条件里面()括号常出现匹配情况导致编译请编写程序检测输入行
    if语句中圆括号否匹配正确时输出语句中出现左括号右括号数量if((a1)&&(b1))正确if((a1))&&(b1))错误注意if语句外面少括号提示：堆栈做
    输入：if((a1)&&(b1))
    输出：RIGTH 3 3
    输入：if((a1))&&(b1))
    输出：WRONG 3 4
    #include
    #include
    int main()
    {
    char s[800]{＇＼0＇}
    scanf(s&s)
    char s[]if(())
    int lenstrlen(s)
    int ileft0right0
    int a[50]k0flag1
    for(i0i {
    if(s[i]＇(＇)
    {
    left++
    a[k]1
    k++
    }
    else if(s[i]＇)＇)
    {
    right++
    if(a[k1]1&&k>0)
    {
    a[k1]0
    k
    }
    else
    flag0
    }
    if((i2&&s[i]＇(＇)||(ilen1&&s[i]＇)＇))
    flag0
    }
    if(a[0]0&&flag0)
    printf(RIGHT)
    else
    printf(WRONG)
    printf(d d＼nleftright)
    return 0
    }
    约瑟夫问题
    输入机数组成数列（数列中数均0整数长度已知）初始计数值m数列首位置开始计数计数m数列该位置数值换计数值m数列该位置数值出列然位置新开始计数直数列数值出列止果计数达数列尾段返回数列首位置继续计数请编程实现述计数程时输出数值出列序
    ：输入机数列：3124初始计数值m7数列首位置开始计数（数值3位置）
    第轮计数出列数字2计数值更新m2出列数列314数值4位置新开始计数
    第二轮计数出列数字3计数值更新m3出列数列14数值1位置开始计数
    第三轮计数出列数字1计数值更新m1出列数列4数值4位置开始计数
    轮计数出列数字4计数程完成
    输出数值出列序：2314
    求实现函数：
    void array_iterate(int len int input_array[] int m int output_array[])
    输入 int len：输入数列长度
    int intput_array[]：输入初始数列
    int m：初始计数值
    输出 int output_array[]：输出数值出列序
    返回
    示例
    输入：int input_array[] {3124}int len 4 m7
    输出：output_array[] {2314}
    解题思路：
    次出列数值需minput_arrayoutput_array输出位置outPos起始位置startPos进行更新
    输出位置outPos计算关键通分析知outPos(startPos+m1)num
    代码实现：
    view plaincopy to clipboardprint
    #include
    void print_array(int len int array[])
    {
    for(int i0 i printf(d array[i])
    printf(＼n)
    }
    input_arraya[0]a[len1]
    void array_iterate(int len int input_array[] int m int output_array[])
    {
    int startPos0
    int outPos
    int nIterlen1
    int numlen
    for( nIter>0 nIter)
    {
    outPos(m+startPos1)num
    minput_array[outPos]
    startPosoutPos
    printf(outPos is d new m is d＼n outPos m)
    output_array[lennIter1]input_array[outPos]
    for(int ioutPos i input_array[i]input_array[i+1]
    num
    print_array(num input_array)
    }
    }
    void main()
    {
    int input_array[]{3124}
    int output_array[4]{0}
    array_iterate(4 input_array 7 output_array)
    print_array(4 output_array)
    }
    27统计数字出现次数次数统计出
    举例：
    输入：323324423343
    输出：36

    #include
    #include
    #include
    int main()
    {
    char *num323324423343
    int a[10]{0}
    int lenstrlen(num)
    int ijtempcount0maxnum0
    printf(d＼nlen)

    for(i0i {
    tempnum[i]＇0＇
    a[temp]++
    }
    int temp1a[0]
    for(j0j<10j++)
    {
    if(a[j]0)
    {
    count++
    temp1(temp1>a[j])temp1a[j]
    printf(d d＼na[j]j)
    }
    }
    printf(数字出现次数d＼ncount)
    printf(次数d＼ntemp1)
    return 0
    }
    28 字符串首字母转换成写
    举例：
    输入：this is a book
    返回：This Is A Book

    #include
    #include
    #include
    int main()
    {
    char input[]this is a book
    char output[256]{＇＼0＇}
    int ilen
    lenstrlen(input)
    printf(变换前字符串s＼ninput)
    for(i0i {
    if(input[0]＇ ＇)
    input[0]32
    if(input[i]＇ ＇)
    input[i+1]32
    output[i]input[i]
    }
    printf(变换字符串s＼noutput)
    }
    29 子串分离 
    题目描述：   
    通键盘输入意字符串序列字符串包含子串子串空格分隔请编写
    程序动分离出子串’’分隔补充’’子
    串存储  
    果输入abc def gh i        d结果abcdefghid 
    求实现函数：   
    void DivideString(const char *pInputStr long lInputLen char *pOutputStr) 
    输入  pInputStr：  输入字符串 
             lInputLen：  输入字符串长度                   
    输出  pOutputStr：  输出字符串空间已开辟输入字符串等长 
     
    #include
    #include
    #include
    #include
    void DivideString(const char *pInputStr long lInputLen char *pOutputStr)
    {

    int cnt
    const char *ppInputStr
    while(*pNULL)
    {
    if(*p＇ ＇)
    { cnt 0
    *pOutputStr++ *p++
    }
    else
    { cnt++
    p++
    if(cnt1)
    *pOutputStr++ ＇＇

    }
    }
    *pOutputStr++ ＇＇
    *pOutputStr ＇＼0＇
    }

    void main()
    {
    char *str abc def gh i d
    long len strlen(str)
    char *outstr (char*)malloc(sizeof(str))
    char outstr[100]
    DivideString(strlenoutstr)
    printf(soutstr)
    printf(＼n)
    }


    9月份华面试没通知参加10月份华软件面试：
    10月18号午西工投简历然通知22号机试利四天时间网年贴出华机试题进行整理道题重新整理编写遍网贴出答案代码变量考虑周全进行改正保证道题运行错误（机试题均含考题目算泄密哈…………）
    23号通知面试：9点15准时面试点然面技术面面试官蔼首先介绍然找项目头尾讲遍务听懂项目期间遇问题解决方式项目中感受收获什差讲时（时面试算长吧）然说次面试没问软件方面东西LZ听出问题说科班出身时直编程通信方面书籍相信进入公司学力……时面试官接话说知道学力强然出等通知然等性格测试
    纠结性格测试差做时建议做36分钟没准确时间限定时快吃午饭倒数第二批进测试确出……差10秒吧通知先吃午饭（华午餐错服务态度）
    午二面（终面）终面传说中ＨＲ研发感觉研发部门理点网介绍骗……介绍介绍具体项目然问啥问题想问开始问：您会面试感觉样笑说问题面试期间方便回答面试相关问题重新问问网说华工作非常累非常忙真实情况（感觉问题非常棒＾＾勾起面试官美回忆扯差１５分钟）然引加班工作忙累法进入华愿景然回等通知欣喜２４号午收通知２５号签约早果断签
    科普通二物理专业出身读研转目标识华直工作中佳选择９月份现１０月底四五ｏｆｆｅｒ拒直等华呵呵现愿认力出众软件公司勉强通笔试死面试特面阿里时候面试官重光老师（ｉ应该样写呵呵）针见血指出足非常中肯建议找工作中起非常帮助非常感谢写吧

    文档香网(httpswwwxiangdangnet)户传

    《香当网》用户分享的内容，不代表《香当网》观点或立场，请自行判断内容的真实性和可靠性！
    该内容是文档的文本内容，更好的格式请下载文档

    下载文档到电脑，查找使用更方便

    文档的实际排版效果，会与网站的显示效果略有不同！！

    需要 2 积分 [ 获取积分 ]

    下载文档

    相关文档

    2014华为校园招聘上机题

    目录样题-初级题：从考试成绩中划出及格线 2样题-中级题：亮着电灯的盏数 2样题-高级题：地铁换乘 38.29去掉最大值、最小值之后剩下的个数 38.29从5个人中选取2个人作为礼仪 48.2...

    9年前   
    391    0

    2014华为校园招聘财经笔试-总结的100多道华为笔试原题-攒人品-发笔经

    昨天刚参加完华为的笔试和性格测试，现在忐忑的等待面试的消息，发笔试经验攒人品笔试分为三套题目，1、区域、BG、财经类是财务题目2、销售融资3、税务虽然楼主本科学的是国贸和金融但是岗位是区域财经...

    8年前   
    587    0

    2014华为校园招聘笔试题目java类

    一 单项选择题　　1.Java是从( )语言改进重新设计。　　A.Ada　　B.C++　　C.Pasacal　　D.BASIC　　答案：B　　2.下列语句哪一个正确( )　　A. Java程序...

    10年前   
    489    0

    2014华为校园招聘软件测试笔试题分

    华为软件测试笔试题主要分三部分：软件基础题、数据结构编程题、数据库题     其中软件基础题题型有：选择（约50题，多为软件工程知识：黑盒测试、软件测试流程等、数据库SQL语言、二叉树中序遍历...

    10年前   
    520    0

    2014华为校园招聘笔试算法题汇总

    华为2014笔试算法题汇总1.通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。比如字符串“abacacde”过...

    10年前   
    411    0

    2014华为校园招聘电子科大上机题目

    华为2014校园招聘的机试题目和2013年的完全一样。一、题目描述（60分）：通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出...

    9年前   
    448    0

    「华为」HRBP在华为的落地

    HRBP在华为怎么落地的？【李山林简介】华为蓝血十杰之一1996年10月加入华为从事软件开发。1999年到印度所，2000年建立北研质量部负责推行CMM；2001年在深圳研发质量部负责研发软件...

    9年前   
    724    0

    《华为的世界》读后感 华为的世界与华为的冬天

    华为的世界与华为的冬天 《华为的世界》读后感     很多年以前，当我还没有走上移动公司的管理岗位时，就读到过任正非那篇脍炙人口的《华为的冬天》，并为文章中精彩的论述和危机感所打动。那个时...

    11年前   
    10797    0

    奇虎360 2014校园招聘面试 一二面

    奇虎360 2014校园招聘面试 一二面面试时间：2013-10-29 下午4：45 到 晚上7点半面试地点：360大厦，酒仙桥路6号院2号楼面试职位：服务器端研发工程师面试形式：一对一，聊天...

    9年前   
    388    0

    GE AM 面试经历

    GE AM 面试经历　　发信人: yooyoo (悠悠游侠), 　　　　GE AM(Advanced Materials) 上周二通知我参加9月27日(本周一)的面试。还好，是在北京，于是决定...

    11年前   
    520    0

    华为校园招聘各类工程师通信基础面试题库以及答案

    华为各类工程师通信基础面试题库以及答案比较基础的题目，希望大家看了有所帮助牛人权当复习了吧1、语音信号数字化过程中，采用的是的量化方法是非均匀量化。2、PCM30/32路系统中，每个码的时间间...

    11年前   
    397    0

    毕马威面试招聘——2006校园招聘——员工待遇

    员工待遇 咨询人员有 70% 的工作时间都花在出差上。雇员们力图在本地完成业务，但由于客户位于世界各地，所以出差是不可避免的。咨询人员都非常年青，从事大项目的员工的年龄范围在 25-35 岁之...

    14年前   
    715    0

    华为基本法

      华为公司基本法 第一章 公司的宗旨 一、核心价值观 　　（追求） 　　第一条 华为的追求是在电子信息领域实现顾客的梦想，并依靠点点滴滴、锲而不舍的艰苦追求，使我们成为世界级领先企...

    9年前   
    7572    0

    华为离职信

    华为离职信　　同学们：　　it＇s my last day at hw!　　知道的与不知道的都请不要惊奇不要声张更不要宣传（谁都不要说啊），出于保密需要，请大家将就一下把我和我这件破事儿当空气...

    10年前   
    741    0

    华为员工手册

     公司简介 华为公司是一家专门从事系列程控交机及其配套产品生产、开发、销售的高新技术企业，崛起于改革开放前沿的深圳，积极投身于民族通信产业的大潮中，为使我国通信产业早日走向世界...

    10年前   
    865    0

    华为员工手册

    华为员工手册是一份重要的文件，它详细规定了华为员工的行为准则、职责、权益以及公司的各项管理制度。以下是一些手册中可能包含的关键内容：一、适用范围与定义本手册适用于华为全体员工，包括正式员工、临时...

    4周前   
    104    0

    华为基本法

    华为公司基本法第一章   公司的宗旨一、核心价值观    （追求）    第一条  华为的追求是在电子信息领域实现顾客的梦想，并依靠点点滴滴、锲而不舍的艰苦追求，使我们成为世界级领先企业。  ...

    12年前   
    658    0

    华为员工手册

    公司简介华为公司是一家专门从事系列程控交机及其配套产品生产、开发、销售的高新技术企业,崛起于改革开放前沿的深圳，积极投身于民族通信产业的大潮中，为使我国通信产业早日走向世界通舞台，贡献着自己的...

    4年前   
    1084    0

    《野性华为》读书心得

    读书心得 世上本无捷径，成功不是偶然。拜读《野性华为》以后，让我更加意识到团队的重要意义。企业的发展与团队建设息息相关，一个高效运转、团结一致企业才能在时代的浪潮中紧紧的抓住的发展的机遇。企...

    7年前   
    3597    0

    华为基本法

    　第一章 公司的宗旨一、核心价值观　　（追求）　　第一条 华为的追求是在电子信息领域实现顾客的梦想，并依靠点点滴滴、锲而不舍的艰苦追求，使我们成为世界级领先企业。　　为了使华为成为世界一流的设...

    10年前   
    480    0

    文档贡献者

    亲***问

    贡献于2014-07-20

    下载需要 2 积分 [ 获取积分 ]
    下载文档

    该用户的其他文档

    相关PPT

    相关PDF