三道 华为 面试题

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)

   
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}
             函数接口   void sort(int input[], int n, int output[])

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[])

 

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


//打印数组
int print_arr(int *arr, int n)
{
    if(NULL == arr || 0 == n)
    {
        return 0;
    }

    for(int i=0; i<n; i++)
    {
        printf("%3d ",arr[i]);
        if(i%10 == 9)
        {
            printf("\n");
        }
    }
    printf("\n");
    return 1;
}
//第1题
int cal_score(int score[], int judge_type[], int n) 
{
    int result = 0;
    int sum1=0, sum2=0;
    int count1 = 0; 
    int count2 = 0;
    for(int i=0; i<n; i++)
    {
        if(judge_type[i] == 1)
        {
            sum1 += score[i];
            count1++;
        }
        else if(judge_type[i] == 2)
        {
            sum2 += score[i];
            count2++;
        }
    }

    if(count2 == 0)
    {
        result = int(sum1/count1);
    }
    else 
    {
        result = int((sum1/count1)*0.6 + (sum2/count2)*0.4);
    }
    return result;
}

//第2题
void sort(int input[], int n, int output[])
{
    int *arr = new int[n];
    memcpy(arr, input, n*sizeof(int));
    int i, j;
    for(i=0; i<n; i++)
    {
        for(j=i+1; j<n; j++)
        {
            if(arr[i] < arr[j])
            {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    print_arr(arr,n);

    int iLeft, iRight;
    int iFlag;
    if(n%2==0)
    {
        output[n/2] = arr[0];
        output[n/2-1] = arr[1];
        iLeft = n/2-2;
        iRight = n/2+1;
        iFlag = 2;
    }
    else 
    {
        output[n/2] = arr[0];
        iLeft = n/2-1;
        iRight = n/2+1;
        iFlag = 1;
    }

    while(iLeft >=0 && iRight<n)
    {
        output[iRight++] = arr[iFlag++] ;
        output[iLeft--]  = arr[iFlag++] ;
    }

    delete []arr;
}

//第3题
void scheduler(int task[], int n, int system_task[], int user_task[])
{
    int *arr = new int[n];
    int *arr2 = new int[n];
    memcpy(arr, task, n*sizeof(int));
    int i;
    for(i=0; i<n; i++)
    {
        arr2[i] = i;
    }
    puts("初始化数组");    
    print_arr(arr2, n);
    print_arr(arr, n);

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

            temp = arr2[flag];
            arr2[flag] = arr2[i];
            arr2[i] = temp;            
        }
        
    }
    
    puts("排序后数组");
    print_arr(arr2, n);
    print_arr(arr, n);

    int iSys=0, iUser=0;
    for(i=0; i<n; i++)
    {
        flag = arr2[i];
        if(task[flag]>=0 && task[flag]<50)
        {
            system_task[iSys++] = flag;
        }
        else if(task[flag] >= 50 && task[flag] <=255)
        {
            user_task[iUser++] = flag;
        }
    }
    system_task[iSys++] = -1;
    user_task[iUser++] = -1;


    delete []arr;
    delete []arr2;
}

int main()
{

    //第2题
//    int input[] = {3, 6, 1, 9, 7}; 
//    int output[5];      // = {3, 7, 9, 6, 1};   //反了。
/*
    int input[] = {3, 6, 1, 9, 7, 8};
    int output[6] ;
    int n = 6;
    //   output[] = {1, 6, 8, 9, 7, 3}
    print_arr(input, n);
    sort(input, n, output);
    print_arr(output, n);
*/
    //第3题
    //例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}    
    //system_task[] = {0, 3, 1, 7, -1}   
    //user_task[] = {4, 8, 2, 6, -1}
    int task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99};
    int system_task[5];
    int user_task[5];
    int len = sizeof(task)/sizeof(int);
    scheduler(task, len, system_task, user_task);

    print_arr(system_task,5);
    print_arr(user_task, 5);

//    printf("Hello\n");
    return 0;
}