2012年小米校园招聘实习生笔试编程题

小米笔试编程题

1. 删除一个字符串中多余的空格，即将字符串中连续的多个空格压缩为一个。

    方法一： 将字串拷贝到另一个数组，然后再拷贝到原来的字符数组，在拷贝的过程中跳过多余的空格（多个空格只拷贝一个）。缺点：需要辅助空间。

    方法二： 提供一个虚拟数组，和方法一类似，只是方法一中的辅助数组，就是字符串数组本身，用移动代替拷贝，从而避免了一些不必要的拷贝。

方法二的实现代码如下：

(1) 有问题的版本一：（有错误，知道看出来没）//未控制压缩后的字符串的结束。

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

void trimSpace(char* str);

int main(int argc, char* argv[])
{   

    char str[100] = "hello       world";

    printf("before trim: str=%s\n", str);
    trimSpace(str);
    printf("after trim: str=%s\n", str);


    return 0;
}




void trimSpace(char* str) {
    char *p;
    char *tail;

    p = str;
    tail = str;

    if(NULL!=p) {
        while(*p!='\0' ) {
            while(*p!= ' ') {
                if(tail!=p) {
                    *tail = *p;
                }

                p++;
                tail++;
            }

            if(*tail !=' ')    *tail = ' '; //仅保留一个空格；
            tail++;
            p++;
            while(*p == ' ') p++;         //跳过多余的空格；
        }
        
    }
}

更正完善版本二：

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

void trimSpace(char* str);

int main(int argc, char* argv[])
{
    char str[100] = {'a', ' ', ' ', ' ', 'b', ' ', ' ', ' ', '\0', 'e', 'f',};
    //char str[100] = "abc";
    printf("before trim: str=%s\n", str);
    trimSpace(str);
    printf("after trim: str=%s\n", str);


    return 0;
}




void trimSpace(char* str) {
    char *p;
    char *tail;

    p = str;
    tail = str;

    if(NULL!=p) {
        while(*p!='\0') {
            while(*p!= ' ') {
                if(tail!=p) {
                    *tail = *p;
                }

                if(*p == '\0') return ;  //判断字符串是否结束。

                p++;
                tail++;
            }

            if(*tail !=' ')    *tail = ' '; //仅保留一个空格；
            tail++;
            p++;
            while(*p == ' ') p++;         //跳过多余的空格；
        }

        if(*tail!='\0') *tail = '\0';  //控制压缩后的字符串的结束。
    }
}

扩展问题： 在字符串中删除， 指定的字符（不止一个）。思路类似。

二、编程题二： 归并排序.   只是，给函数接口，有点不优雅。 稍作改动即可实现。

 归并排序的实现参见： http://blog.csdn.net/wzb56/article/details/7338464

给出的mergeSort接口是，

void  mergeSort（int * unsort,  int n） {   }.

void mergeSort(int* unsort, int n) {
    int low;
    int mid;
    int high;
    
    low = 0;
    high = n-1;
    
    if(low<high) {
        mid = (low+high) >> 1;
        mergeSort(unsort, mid+1);
        mergeSort(unsort+mid+1, high-mid);
        
        merge(unsort, low, mid, high);        
    }    

}

下面给出mergeSort带有自动化测试版：

自动化测试的的头文件 sort_test.h：

#ifndef SORT_TEST_H
#define SORT_TEST_H

#include <stdlib.h>
#include <time.h>
#include <assert.h>

typedef void (*sortFunc)(int* array, int start, int end);

void sort_test(sortFunc sort, int n);

#endif /* SORT_TEST_H */

自动化测试的C文件：sort_test.c:

#include "sort_test.h"

static int * createArray(int len) {
    int i = 0;

    int * array = (int *) malloc(sizeof(int)*len);
    srand((unsigned) time(NULL));

    for(i=0; i<len; i++) {
        array[i] = rand();
    }

    return array;
}


static  void sort_test_one(sortFunc sort, int len) {
    int i;

    int * array = (int *) createArray(len);
    sort(array, 0, len-1);

    for(i=1; i<len; i++) {
        assert(array[i]>=array[i-1]);
    }

    free(array);

    return ;
}


void sort_test(sortFunc sort, int n) {
    int i;

    for(i=0; i<n; i++) {
        sort_test_one(sort, i);
    }

    return ;
}

mergeSort的实现文件，和测试文件， （本来函数声明和实现分别放在头文件和.c文件更优雅。）

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

#include "sort_test.h"
#define max 1000
int tmp[max];

void printArray(int* a, int len);
void merge(int* a, int low, int mid, int high);
void mergeSort(int *a, int low, int high);

int main(int argc, char* argv[])
{
    /*
    int a[10] = {5, 4, 3, 2, 1, 3, 3, 3, 4, 0};
    int len = 10;
    mergeSort(a, 0, len-1);
    printArray(a, len);
    */
    int len = max;
    sort_test(mergeSort, len);
    printf("-----successfully test mergeSort ------\n");

    return 0;
}

void printArray(int* a, int len) {
    int i;
    for(i=0; i<len; i++) {
        printf("%d\t", a[i]);
    }
    printf("\n");
}

void merge(int* a, int low, int mid, int high) {
    int i;
    int j;
    int k;

    for(i=low; i<=high; i++) {
        tmp[i] = a[i];
    }

    j=low;
    k=mid+1;
    for(i=low; i<=high && j<=mid && k<=high; ) {
        if(tmp[j]<=tmp[k]) {
            a[i++] = tmp[j++];
        }else{
            a[i++] = tmp[k++];
        }
    }

    while(j<=mid) a[i++] = tmp[j++];
    while(k<=high) a[i++] = tmp[k++];

}

void mergeSort(int* a, int low, int high) {
    int mid;

    if(low<high) {
        mid = (low+high) >> 1;
        mergeSort(a, low, mid);
        mergeSort(a, mid+1, high);
        merge(a, low, mid, high);
    }

}

/**for 小米***/
#if 0
void mergeSort(int* unsort, int n) {
    int low;
    int mid;
    int high;

    low = 0;
    high = n-1;

    if(low<high) {
        mid = (low+high) >> 1;
        mergeSort(unsort, mid+1);
        mergeSort(unsort+mid+1, high-mid);

        merge(unsort, low, mid, high);
    }

}

#endif

总结，小米的笔试主要考数据结构方面的问题。（考过研的不再话下喽！）