2012届华为校园招聘上机考试题目(9月6日下午1点场)

    昨天去参加了华为的校园招聘上机考试,题目一共三道,都比较简单,不要求算法效率,也不要求对所给数据的合法性作检测,主要还是注重基础知识的考察,和大家分享一下,希望对接下来的同学有所帮助。

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

查看评论
53楼 yang875890916 57分钟前发表 [回复] [引用] [举报]
测试1:
#include <stdio.h>
int cal_score(int score[], int judge_type[], int n);
void main()
{
int score[10]={70,80,90,99,98,97,96,88,79,90};
int judge_type[10]={1,2,2,1,2,2,2,1,2,2};
printf("%d\n",(int)cal_score(score,judge_type,10));
}
int cal_score(int score[], int judge_type[], int n)
{
int i,zc=0;
int zs=0,ds=0;
for(i=0;i<n;i++)
{
if(judge_type ==1)
{
zs+=score;
zc++;
}
if(judge_type==2)
ds+=score;
}
int zps=(int)(zs/zc);
int dps=(int)(ds/(n-zc));
return (zps*0.6+dps*0.4);
}
52楼 yang875890916 58分钟前发表 [回复] [引用] [举报]
测试2:
#include <stdio.h>
#define CNT 6
void sort(int input[], int n, int output[]);
void main()
{
int input[CNT]={3, 6, 1, 9, 7, 8,};
int output[CNT];
sort(input,CNT,output);
for(int i=0;i<CNT;i++)
printf("%d,",output );
printf("\n");
}
void sort(int input[], int n, int output[])
{
int mid=n/2;
int tmp;
int i,j;
for(i=n-1;i>0;i--)
for(j=0;j<i;j++)
{
if(input[j]<input[j+1])
{
tmp=input[j];
input[j]=input[j+1];
input[j+1]=tmp;
}
}
output[mid]=input[0];
for(i=1;i<=mid;i++)
{
output[mid-i]=input[2*i-1];
output[mid+i]=input[2*i];
}
}
51楼 yang875890916 1小时前发表 [回复] [引用] [举报]
测试3:#include <stdio.h>
#define CNT 9
void scheduler(int task[], int n, int system_task[], int user_task[]);
void main()
{
int task[CNT] = {0, 30, 155, 1, 80, 300, 170, 40, 99};
int system_task[CNT];
int user_task[CNT];
scheduler(task,CNT,system_task,user_task);
}
void scheduler(int task[], int n, int system_task[], int user_task[])
{
int i,j=0,k=0;
for(i=0;i<n;i++)
{
if(task <50)
{
system_task[j]=i;
j++;
}
if(task>=50 && task<=255)
{
user_task[k]=i;
k++;
}
}
int jj=j;
int tmp;
for(i=0;i<jj-1;i++)
for(j=i+1;j<jj;j++)
if(task[system_task]>task[system_task[j]])
{
tmp=system_task;
system_task=system_task[j];
system_task[j]=tmp;
}
for(i=0;i<k-1;i++)
for(j=i+1;j<k;j++)
if(task[user_task]>task[user_task[j]])
{
tmp=user_task;
user_task=user_task[j];
user_task[j]=tmp;
}
system_task[jj]=-1;
user_task[k]=-1;
for(i=0;i<=jj;i++)
printf("%d,",system_task);
printf("\n");
for(i=0;i<=k;i++)
printf("%d,",user_task);
printf("\n");
}
50楼 huzinuli 4小时前发表 [回复] [引用] [举报]
good chance!
49楼 zhenshangzhengren 6小时前发表 [回复] [引用] [举报]
3 5 8 9 7 4 2
运行的的二题答案,自己写的方法太长了了,也许是几的程序不怎么过硬,老是写不出最少的代码。
48楼 commandow 昨天 21:46发表 [回复] [引用] [举报]
第二题将input数组排序。将得到的结果从大到小从output的中间节点开结插入,然后从中间节点向两边扩张,从左到右按大小排列顺序一次填两数,位置在m-i, m+i(i代表距中间节点的位置)。直到填满整个output数组。
47楼 commandow 昨天 21:38发表 [回复] [引用] [举报]
采用N次遍历,每次遍历找最小值,找到后,如果小于50,则加入system_task队列。如果大于50小于255则加入user_task,加入后把该位置上的值设置256。继续查找如果找到的最小值大于255则终止查找。。。。
46楼 lovejjy091207 昨天 20:58发表 [回复] [引用] [举报]
辛苦了。。。
45楼 ehuashao 昨天 17:47发表 [回复] [引用] [举报]
学习力 不错
44楼 sun32732 昨天 16:03发表 [回复] [引用] [举报]
其实题目不难,但是麻烦各位看一下程序运行效率
43楼 BigNuts 昨天 15:47发表 [回复] [引用] [举报]
哎呀 忘光光了,用C#行不.....
42楼 tianyeyinci 昨天 15:27发表 [回复] [引用] [举报]
楼主第三题用数组保存它的优先级和下标很巧妙呀!赞!
41楼 Veiky_c 昨天 14:18发表 [回复] [引用] [举报]
mark!
40楼 dm569263708 昨天 12:50发表 [回复] [引用] [举报]
如果就这几个题目会做就可以进去就好了
39楼 cgmeco 昨天 12:24发表 [回复] [引用] [举报]
对于第三问题,最简单的办法,设定一下struct;
struct task_node{
int task_priority,
int position
}
设定一个 struct task_node task_list[]; 把任务列表中的任务优先级记录在staruct 的task_priority中,把位置记录在position中。
然后对task-list进行排序。对于0~49的,把位置只接存入system_task中, 50~255的,把节点位置号存入user_task中。
即可。
不知,大家意见如何?
38楼 xunuohan2008 昨天 12:21发表 [回复] [引用] [举报]
完了,进不了华为咯
37楼 crazyhzc 昨天 10:49发表 [回复] [引用] [举报]
接上
  1. void scheduler(int task[], int n, int system_task[], int user_task[])  
  2. {  
  3.     int temp1 = 0;  
  4.     int temp2 = 0;  
  5.     for(int i = 0;i<n;i++)  
  6.     {  
  7.         if(50 > task[i])  
  8.             system_task[temp1++] = i*1000+task[i];    //低两位是系统任务优先级,第四位是对应的task数组下标   
  9.         else if(255 >= task[i])  
  10.             user_task[temp2++] = i*1000+task[i];     //低三位是用户任务优先级,第四位是对应的task数组下标   
  11.     }  
  12.     system_task[temp1] = -1;                          
  13.     user_task[temp2] = -1;  
  14.   
  15.     bubbleSort(system_task,temp1);                 //按低两位的优先级进行冒泡排序   
  16.     adjust(system_task,temp1);                     //把数组system_task中的值调整为对应的task数组的下标   
  17.     bubbleSort(user_task,temp2);                   //按低三位的优先级进行冒泡排序   
  18.     adjust(user_task,temp2);                       //把数组user_task中的值调整为对应的task数组的下标   
  19.     print(system_task,temp1+1);                      
  20.     print(user_task,temp2+1);                       
  21. }  
  22.   
  23. int _tmain(int argc, _TCHAR* argv[])  
  24. {  
  25.     int task[] =  {0, 30, 155, 1, 80, 300, 170, 40, 99};  
  26.     int system_task[9],user_task[9];  
  27.     scheduler(task,9,system_task,user_task);  
  28.     return 0;  
  29. }  
void scheduler(int task[], int n, int system_task[], int user_task[]) { int temp1 = 0; int temp2 = 0; for(int i = 0;i<n;i++) { if(50 > task[i]) system_task[temp1++] = i*1000+task[i]; //低两位是系统任务优先级,第四位是对应的task数组下标 else if(255 >= task[i]) user_task[temp2++] = i*1000+task[i]; //低三位是用户任务优先级,第四位是对应的task数组下标 } system_task[temp1] = -1; user_task[temp2] = -1; bubbleSort(system_task,temp1); //按低两位的优先级进行冒泡排序 adjust(system_task,temp1); //把数组system_task中的值调整为对应的task数组的下标 bubbleSort(user_task,temp2); //按低三位的优先级进行冒泡排序 adjust(user_task,temp2); //把数组user_task中的值调整为对应的task数组的下标 print(system_task,temp1+1); print(user_task,temp2+1); } int _tmain(int argc, _TCHAR* argv[]) { int task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}; int system_task[9],user_task[9]; scheduler(task,9,system_task,user_task); return 0; }
36楼 crazyhzc 昨天 10:47发表 [回复] [引用] [举报]
第三题
  1. #include "stdafx.h"   
  2.   
  3. /*冒泡排序*/  
  4. void bubbleSort(int list[],int n)  
  5. {  
  6.     int exchange = 1;  
  7.     for(int i = 0;i<n&&exchange;i++)  
  8.     {  
  9.         exchange = 0;  
  10.         for(int k = 0;k < n-i-1;k++)  
  11.         {  
  12.             if(list[k]%1000 > list[k+1]%1000)  
  13.             {  
  14.                 list[k] = list[k]^list[k+1];  
  15.                 list[k+1] = list[k]^list[k+1];  
  16.                 list[k] = list[k]^list[k+1];  
  17.                 exchange = 1;  
  18.             }  
  19.         }  
  20.     }  
  21. }  
  22.   
  23. /*调整数组中元素的值为对应的task数组中的下标*/  
  24. void adjust(int list[],int n)  
  25. {  
  26.     for(int i = 0;i < n;i++)  
  27.         list[i] = list[i]/1000;  
  28. }  
  29.   
  30. /*打印输出*/  
  31. void print(int list[],int n)  
  32. {  
  33.     for(int i = 0;i < n;i++)  
  34.         printf("%d ",list[i]);  
  35.     printf("\n");  
  36. }  
#include "stdafx.h" /*冒泡排序*/ void bubbleSort(int list[],int n) { int exchange = 1; for(int i = 0;i<n&&exchange;i++) { exchange = 0; for(int k = 0;k < n-i-1;k++) { if(list[k]%1000 > list[k+1]%1000) { list[k] = list[k]^list[k+1]; list[k+1] = list[k]^list[k+1]; list[k] = list[k]^list[k+1]; exchange = 1; } } } } /*调整数组中元素的值为对应的task数组中的下标*/ void adjust(int list[],int n) { for(int i = 0;i < n;i++) list[i] = list[i]/1000; } /*打印输出*/ void print(int list[],int n) { for(int i = 0;i < n;i++) printf("%d ",list[i]); printf("\n"); }
Re: ji_hengshan 昨天 13:12发表 [回复] [引用] [举报]
回复crazyhzc:数组不是不能动态分配空间吗?system_task[]应该是固定长度的吧?
Re: crazyhzc 昨天 13:43发表 [回复] [引用] [举报]
回复ji_hengshan:对的,没用动态分配,定义system_task[]的时候和task[]的长度是一样的
35楼 crazyhzc 昨天 10:44发表 [回复] [引用] [举报]
第二题
  1. #include "stdafx.h"   
  2.   
  3. /*冒泡排序*/  
  4. void bubbleSort(int list[],int n)  
  5. {  
  6.     int exchange = 1;  
  7.     for(int i = 0;i<n&&exchange;i++)  
  8.     {  
  9.         exchange = 0;  
  10.         for(int k = 0;k < n-i-1;k++)  
  11.         {  
  12.             if(list[k] < list[k+1])  
  13.             {  
  14.                 list[k] = list[k]^list[k+1];  
  15.                 list[k+1] = list[k]^list[k+1];  
  16.                 list[k] = list[k]^list[k+1];  
  17.                 exchange = 1;  
  18.             }  
  19.         }  
  20.     }  
  21. }  
  22.   
  23. void sort(int input[], int n, int output[])  
  24. {  
  25.     int i;  
  26.     for(i = 0;i<(n+1)/2;i++)  
  27.     {  
  28.         output[n/2+i] = input[2*i];  
  29.         output[n/2-(i+1)] = input[2*i+1];  
  30.     }  
  31.     output[n/2+i] = input[2*i];  
  32.     if(i == n/2)  
  33.         output[0] = input[n-1];  
  34. }  
  35.   
  36. int _tmain(int argc, _TCHAR* argv[])  
  37. {  
  38.     int input[5] = {3,6,1,9,7};  
  39.     int output[5] = {0,0,0,0,0};  
  40.     //先从大到小排序,然后按规律放入输出数组中   
  41.     bubbleSort(input,5);              
  42.     sort(input,5,output);  
  43.     for(int i = 0;i<5;i++)  
  44.         printf("%d ",output[i]);  
  45.     return 0;  
  46. }  
#include "stdafx.h" /*冒泡排序*/ void bubbleSort(int list[],int n) { int exchange = 1; for(int i = 0;i<n&&exchange;i++) { exchange = 0; for(int k = 0;k < n-i-1;k++) { if(list[k] < list[k+1]) { list[k] = list[k]^list[k+1]; list[k+1] = list[k]^list[k+1]; list[k] = list[k]^list[k+1]; exchange = 1; } } } } void sort(int input[], int n, int output[]) { int i; for(i = 0;i<(n+1)/2;i++) { output[n/2+i] = input[2*i]; output[n/2-(i+1)] = input[2*i+1]; } output[n/2+i] = input[2*i]; if(i == n/2) output[0] = input[n-1]; } int _tmain(int argc, _TCHAR* argv[]) { int input[5] = {3,6,1,9,7}; int output[5] = {0,0,0,0,0}; //先从大到小排序,然后按规律放入输出数组中 bubbleSort(input,5); sort(input,5,output); for(int i = 0;i<5;i++) printf("%d ",output[i]); return 0; }
34楼 crazyhzc 昨天 10:43发表 [回复] [引用] [举报]
第一题
  1. #include "stdafx.h"   
  2.   
  3. int cal_score(int score[], int judge_type[], int n)  
  4. {  
  5.     int pronum = 0;     //记录专家评委的个数   
  6.     int proscore = 0;   //记录专家评委的总评分   
  7.     int peoscore = 0;   //记录大众评委的总评分   
  8.     for(int i = 0;i<n;i++)  
  9.     {  
  10.         if(1 == judge_type[i])  
  11.         {  
  12.             proscore += score[i];  
  13.             pronum++;  
  14.         }  
  15.         else  
  16.             peoscore +=score[i];  
  17.     }  
  18.     if(n != pronum)  
  19.         return (0.6*proscore+0.4*peoscore);  
  20.     else  
  21.         return proscore;  
  22. }  
  23.   
  24. int _tmain(int argc, _TCHAR* argv[])  
  25. {  
  26.     int judge_type[6] = {1,1,1,1,1,1};  
  27.     int score[6] = {3,4,3,2,5,3};  
  28.     int result = cal_score(score,judge_type,6);  
  29.     printf("%d\n",result);  
  30.     return 0;  
  31. }  
#include "stdafx.h" int cal_score(int score[], int judge_type[], int n) { int pronum = 0; //记录专家评委的个数 int proscore = 0; //记录专家评委的总评分 int peoscore = 0; //记录大众评委的总评分 for(int i = 0;i<n;i++) { if(1 == judge_type[i]) { proscore += score[i]; pronum++; } else peoscore +=score[i]; } if(n != pronum) return (0.6*proscore+0.4*peoscore); else return proscore; } int _tmain(int argc, _TCHAR* argv[]) { int judge_type[6] = {1,1,1,1,1,1}; int score[6] = {3,4,3,2,5,3}; int result = cal_score(score,judge_type,6); printf("%d\n",result); return 0; }
Re: lemon_ggx 昨天 11:25发表 [回复] [引用] [举报]
回复crazyhzc:忘记算平均分了……
Re: crazyhzc 昨天 13:45发表 [回复] [引用] [举报]
回复lemon_ggx:汗,的确!
33楼 crazyhzc 昨天 10:43发表 [回复] [引用] [举报]
花了些时间做了一下,思想基本上都是把复杂的问题简单化再做。
第一题标比较简单,就不说了。
第二题先把原数组从大到小排序,然后按规律放入输出数组中。
第三题先把task数组中的系统任务和用户任务分开,分别放入system_task和user_task数组中,不过数组中的元素的值不是放的优先级,比如task[1]=30,那么数组system_task中放的值就是1000*1+30=1030;task[2]=155,那么数组user_task中放的值就是1000*2+155=2155。
算法的效率也许不高,代码贴出来希望大家指教下。
32楼 huangkele8 昨天 09:51发表 [回复] [引用] [举报]
辛苦了!好人啊。
31楼 kevinmartin 昨天 08:36发表 [回复] [引用] [举报]
我对第一题的算法:

curAvg = (curScore - curAvg) / curNum + curAvg

这个算法至少可以保证不出现溢出错误。(前提是输入数据本身不存在溢出情况,并且平均值基本上小于溢出值的1/2)。基本上我们可以保证溢出值是平均值的100倍以上,比如平均值按照100算,我们可以定义float。

这个算法的一个缺点就是可能产生误差,因为curScore是float存储的,比如9.3636363636363636,必然有被丢弃的部分。每次计算都会累计误差。但根据统计学的原理,这个误差不会无限放大,因为有正负,误差会在一定范围内浮动。

为了减少误差,可以用double。
Re: liuqiqi677 昨天 09:09发表 [回复] [引用] [举报]
回复kevinmartin:兄弟说的是,第一题要考虑全面确实不简单,还有可能除数为0的情况,这也是容易忽略的。
30楼 kevinmartin 昨天 08:31发表 [回复] [引用] [举报]
怎么没有人关心第一题?难道都认为第一题太简单了?
不考虑输入数据的合法性,不代表你可以随便用。

大众评委太多了怎么办?超出数据范围怎么办?这些不可能不考虑。
29楼 zhangla12 昨天 23:12发表 [回复] [引用] [举报]
我们上机的时候就写了个单链表逆序就完了
28楼 highfly4008 昨天 22:06发表 [回复] [引用] [举报]
这是我用插入排序写的程序(题三)
void scheduler(int task[], int n, int system_task[], int user_task[])
{
for(int i = 0,iS = 0,iU = 0; i < n; i++)
{
if(task < 50)
{
for(int j = iS-1; j >= 0 && (task[system_task[j]] > task); j--) //插入排序法
{
system_task[j+1] = system_task[j];
}
system_task[j+1] = i;
iS++;
}
else if(task <= 255)
{
for(int j = iU-1; j >= 0 && (task[user_task[j]] > task); j--) //插入排序法
{
user_task[j+1] = user_task[j];
}
user_task[j+1] = i;
iU++;
}
}
system_task[iS] = -1;
user_task[iU] = -1;
}
27楼 maxiao001 昨天 20:26发表 [回复] [引用] [举报]
lz
weida
26楼 liuqiqi677 昨天 17:43发表 [回复] [引用] [举报]
void scheduler(int task[], int n, int system_task[], int user_task[])
{
int sys_cnt = 0; // 系统任务计数
int user_cnt = 0; // 用户任务计数

for (int i = 0; i < n; i++)
{
if (task < 50) // 系统任务
{
system_task[sys_cnt] = i;
int temp1 = sys_cnt++;
while (temp1 > 0 && task[system_task[temp1]] < task[system_task[temp1-1]]) // 交换排序思想
{
swap(system_task[temp1], system_task[temp1-1]);
temp1--;
}

}
else if (task >= 50 && task <= 255) // 用户任务
{
user_task[user_cnt] = i;
int temp2 = user_cnt++;
while (temp2 > 0 && task[user_task[temp2]] < task[user_task[temp2-1]])
{
swap(user_task[temp2], user_task[temp2-1]);
temp2--;
}
}
}
system_task[sys_cnt] = -1;
user_task[user_cnt] = -1;
}
25楼 liuqiqi677 昨天 17:42发表 [回复] [引用] [举报]
下面是我的做法,应一些同学的要求,贴出来和大家交流一下^_^。考试注意事项上说不用考虑数据的合法性,所以我就没有进行数据合法性和合理性的验证了,第一题略。格式不太好看,还请大家见谅~~。
void swap(int &x, int &y)
{
int temp = x;
x = y;
y = temp;
}

void sort(int input[], int n, int output[])
{
for (int i = 0; i < n-1; i++) // 冒泡排序,从大到小
{
for (int j = 0; j < n-1-i; j++)
{
if (input[j] < input[j+1])
{
swap(input[j], input[j+1]);
}
}
}

int mid = n/2; // 计算中间位置
int left = mid-1; // 左下标
int right = mid+1; // 右下标
int cnt = 0;
output[mid] = input[cnt++];
while (cnt < n)
{
if (cnt < n)
{
output[left--] = input[cnt++];
}
if (cnt < n)
{
output[right++] = input[cnt++];
}
}
}
24楼 dennis82828 前天 16:19发表 [回复] [引用] [举报]
不知道第三题难在哪里?题目有限制不能用额外的存储空间?如果没有,先排序task[] 里的任务到sortTask[], 然后。。。还有困难不?
Re: ls3936252 前天 16:22发表 [回复] [引用] [举报]
回复dennis82828:你排序啦task角标的顺序不就乱啦
Re: lemon_ggx 昨天 10:46发表 [回复] [引用] [举报]
回复ls3936252:定义数组task_script[]存放task[]的下标即可,排序时对应数组元素同时交换即可。
Re: dennis82828 前天 16:27发表 [回复] [引用] [举报]
回复ls3936252: 我的意思是,我把task[] 里的元素复制到sortTask[], 然后排序sortTask[]而保留task[] 可以不?
23楼 dennis82828 前天 16:08发表 [回复] [引用] [举报]
都比较简单。
第二题:采用冒泡排序法,取每趟沉底地元素,然后将其摆到相应的位置,怎样在排序中,就解决了问题。
22楼 qqliang1314 前天 15:59发表 [回复] [引用] [举报]
貌似第三个有点难度
21楼 soulmate119 前天 15:49发表 [回复] [引用] [举报]
电子科大?
Re: liuqiqi677 昨天 16:40发表 [回复] [引用] [举报]
回复soulmate119:川大
20楼 ls3936252 前天 15:33发表 [回复] [引用] [举报]
有人写第3题吗 把码发上来看看啊
Re: liuqiqi677 昨天 20:32发表 [回复] [引用] [举报]
回复ls3936252:我发了一份我写的哈,多多指教~~
19楼 ZT_King 前天 13:31发表 [回复] [引用] [举报]
第二题,LZ题目跟示例有歧义
void usort(int *source, int n){
int mid = n/2;
int i,j,l;
for (i = 0; i < mid; i++){
int min1 = source ;
int min2 = source[n-i-1];
for (j = i; j < n-i; j++){//这两个for交换顺序即可得到不一样的排列
if(min1 > source[j]) {
min1 = source[j];
source[j] = source;
source = min1;
}
}
for (l = n-i-2; l >= i+1; l--){
if(min2 > source[l]){
min2 = source[l];
source[l] = source[n-i-1];
source[n-i-1] = min2;
}
}
}
}
Re: liuqiqi677 前天 15:04发表 [回复] [引用] [举报]
回复ZT_King:给的原题目还要隐晦一点,没有示例基本上看不懂怎么排。这是我按自己的理解回忆的,可能因为已经形成定式思维了,没有注意到。不过看了例子应该能理解。另外,能不能麻烦点明一下哪里有歧义?我好改一下,谢谢了哈。
18楼 beneathRM 前天 12:48发表 [回复] [引用] [举报]
三道题要求多长时间做完?
Re: liuqiqi677 前天 13:22发表 [回复] [引用] [举报]
回复beneathRM:2小时
17楼 flying1206 前天 11:20发表 [回复] [引用] [举报]
lz是报的哪个部门啊?所有部门都得上机考程序么?ps,lz是哪里啊?
Re: liuqiqi677 前天 11:35发表 [回复] [引用] [举报]
回复flying1206:我报的是软件研发,只有软研的要上机。我是川大的。
16楼 baitiandeye 前天 10:40发表 [回复] [引用] [举报]
我有两个问题想问楼主:1)所有学生的考题都一样吗?
2)java的编程环境是什么?
Re: liuqiqi677 前天 10:48发表 [回复] [引用] [举报]
回复baitiandeye:同一时间考试的所有人的题都是一样的。c用的是vc6.0,java用的是eclipse,但哪一个版本我就不清楚了,当时也没有注意。
15楼 linjiaming_2010 前天 10:39发表 [回复] [引用] [举报]
辛苦了
14楼 hslike8317 前天 09:28发表 [回复] [引用] [举报]
//不要求算法效率,也不要求对所给数据的合法性作检测

笨的,他不要求就是看你自己的编程风格,看你真正写过程序没。
Re: liuqiqi677 前天 09:52发表 [回复] [引用] [举报]
回复hslike8317:呵呵,谢谢提醒,恍然大悟。今后要注意了。
13楼 steven_welcome 前天 09:27发表 [回复] [引用] [举报]
个人感觉都不是很难,除了第2个较为复杂些!
12楼 qq77095729 前天 09:19发表 [回复] [引用] [举报]
希望给一个 保准的 答案,我也学习一下,我是不会,
Re: liuqiqi677 昨天 17:46发表 [回复] [引用] [举报]
回复qq77095729:我把第二和第三题的代码贴出来了,没有进行数据合法性验证,凑合一下,呵呵。
Re: liuqiqi677 前天 10:49发表 [回复] [引用] [举报]
回复qq77095729:晚些时候发你一份哈,白天比较忙。^_^
11楼 qq77095729 前天 09:19发表 [回复] [引用] [举报]
这个用 java 可以处理吧
Re: liuqiqi677 前天 09:22发表 [回复] [引用] [举报]
回复qq77095729:可以,有c\c++ 和 java 两种语言供选择
10楼 blogyuantg 前天 08:42发表 [回复] [引用] [举报]
谢谢楼主分享,哈哈!俺每次都因为四级没过进不去!
9楼 homlinlee 前天 23:36发表 [回复] [引用] [举报]
谢谢楼主
8楼 laopo8023 前天 23:18发表 [回复] [引用] [举报]
不难,呵呵,顶下
7楼 jxayxym 前天 22:55发表 [回复] [引用] [举报]
学习了.
6楼 gaosong822 前天 22:44发表 [回复] [引用] [举报]
楼主辛苦了,学习一下。
5楼 zhangliguangliyan 前天 21:31发表 [回复] [引用] [举报]
辛苦啦。。如果不限定开发语言的话,用C#很容易了。。。
Re: liuqiqi677 前天 21:48发表 [回复] [引用] [举报]
回复zhangliguangliyan:华为上机考试只有c\c++ 和 java 两种语言
4楼 w1002533989 前天 21:27发表 [回复] [引用] [举报]
兄弟,上机考试多长时间?
Re: liuqiqi677 前天 21:47发表 [回复] [引用] [举报]
回复w1002533989:2小时
3楼 laijinyan 前天 18:42发表 [回复] [引用] [举报]
辛苦了
谢谢
2楼 w419675647 前天 17:47发表 [回复] [引用] [举报]
第二个费了一会神。
先排序input。然后依次从OUTPUT的特殊顺序放置。做两指针,同时指向OUPUT的中间,一前一后轮流移动指针放东西。轮流的方式可以采用标志,也可以通过判断指针所指的内容是否为空来判断。前提是OUTPUT初始化过。
Re: felix9 前天 11:54发表 [回复] [引用] [举报]
回复w419675647:我的思路是用数组下标定位。
在input的排序过程中依次取出最大值,同时将这个值传入output。
n/2+1+((i/2)+1)*(i%2==0?-1:1)
Re: liuqiqi677 前天 19:20发表 [回复] [引用] [举报]
回复w419675647:呵呵,我基本上也是这么做的。只是我每次向output写值的时候,都判断一次目前剩下的数是否大于0,就没有判空了。当然前提是他说的不用考虑测试用例的合法性。
1楼 yaoxiangz 3天前 10:35发表 [回复] [引用] [举报]
呵呵 辛苦了。
  • 0
    点赞
  • 1
    收藏
  • 4
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论 4
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值