华为2012年机试（java版）

ixzehvtbuz

下面是2012年上机编程，题目比较简单，正好今年也要面试华为，就当考试前的练手了，好久没有编过程序了；题目： 
1、选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type == 1，表示专家评委，judge_type == 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[])
 

// 为了便于编译，我写到一个类中了，呵呵
package cn.heu.test.job.huawei;
public class Huawei1 {
public static void main(String[] args) {
int score[]={80,90,95};
int judge_type[]={1,2,1};
int result=new Huawei1().cal_score(score,judge_type,3);
System.out.println(result);
int ret[]={0,0,0,0,0,0,0,0,0};
int  input[] = {3, 6, 1, 9, 7, 8,4,7,10};
//new Huawei1().sort(input,9,ret);
new Huawei1().sort2(input,9,ret);
int task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99};
int system_task[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
int user_task[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
new Huawei1().scheduler(task,9,system_task,user_task);
}
public int cal_score(int score[], int judge_type[], int n){
int total_1=0,total_2=0;
int expertnum=0;
int fianlscore=0;
for(int i=0;i<n;i++){
if(judge_type==1) {
total_1+=score;
expertnum++;
}
if(judge_type==2) {
total_2+=score;
}
}
fianlscore=(int)((0.6*(total_1/expertnum)+0.4*(total_2/(n-expertnum))));
return fianlscore;
}
public  void sort(int input[], int n, int output[]){
// 首先对数组进行排序，从大到小，使用冒泡
for(int i=0;i<n;i++) {
for(int j=i+1;j<n;j++){
if(input[j]>input){
int tmp=input;
input=input[j];
input[j]=tmp;
}
}
}
output[n/2]=input[0];
// 左侧，考虑复杂了，其实可以更简单
for(int i=n/2-1,j=n/2-i;i>=0;i=i-1){
output=input[j];
j=j+2;
}
//右侧
for(int i=n/2+1,j=i-n/2+1;i<n;i=i+1){
output=input[j];
j=j+2;
}
for(int i=0;i<n;i++){
System.out.println(output);
}
}
//第二种方法
public void sort2(int input[],int n,int output[]){
for(int i=n-1;i>=0;i--)
for(int j=0;j<i;j++)
{
if(input[j]<input[j+1]){ //把小的放到后面
int tmp=input[j+1];
input[j+1]=input[j];
input[j]=tmp;
}
}
output[n/2]=input[0];
for(int i=1;i<=n/2;i++){
output[n/2-i]=input[2*i-1];
output[n/2+i]=input[2*i];
}

for(int i=0;i<n;i++){
System.out.println(output);
}
}
//调度，第三题
void scheduler(int task[], int n, int system_task[], int user_task[]){
int j=0;
int k=0;
for (int i=0;i<n;i++){
if(task<50){
system_task[j]=i;
j++;
}
if(task>=50&&task<=255){
user_task[k]=i;
k++;
}
}
// 排序，对task[system_task[]]排序，相当于对每一个system_task按照task映射排序
for(int i=0;i<j-1;i++){
for(int m=i+1;m<j;m++)
if(task[system_task]>task[system_task[m]]){//
int tmp=system_task;
system_task=system_task[m];
system_task[m]=tmp;
}
}
system_task[j]=-1;
for(int i=0;i<k-1;i++){
for(int m=i+1;m<k;m++)
if(task[user_task]>task[user_task[m]]){//
int tmp=user_task;
user_task=user_task[m];
user_task[m]=tmp;
}
}
user_task[k]=-1;
}
}