参考来源: Trony的博客 http://www.cnblogs.com/Trony/archive/2012/10/01/2709959.html
lanyan822博客http://blog.csdn.net/lanyan822/article/details/7983832
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)
<pre name="code" class="cpp">#include "stdafx.h"
#include <iostream>
using namespace std;
int cal_score(int score[], int judge_type[], int n);
int cal_score1(int score[], int judge_type[], int n);
int _tmain(int argc, _TCHAR* argv[])
{
int Score[4]={5,3,4,3};
int Type[4]={1,1,2,2};
cout<<cal_score(Score,Type,4)<<endl;
system("pause");
return 0;
}
int cal_score(int score[], int judge_type[], int n)
{
int iExpertScore=0,iExpertNum=0;
int iPeopleScore=0,iPeopleNum=0;
float fExpertAverage=0.0;
float fPeopleAverage=0.0;
int iResult=0;
//处理边界条件
if((score==NULL)||(judge_type==NULL)||(n<=0))
{
return 0;
}
for(int i=0; i<n;i++)
{
if(judge_type[i]==1)//专家评委
{
iExpertScore+=score[i];
iExpertNum+=1;
}
else if(judge_type[i]==2)//大众评委
{
iPeopleScore+=score[i];
iPeopleNum+=1;
}
}
if(iPeopleNum==0)//如果没有大众评委
{
fExpertAverage=iExpertScore/(float)iExpertNum;
iResult=(int)(fExpertAverage*10+5);
iResult=iResult/10;
}
else
{
fExpertAverage=iExpertScore/(float)iExpertNum;
fPeopleAverage=iPeopleScore/(float)iPeopleNum;
float t=(0.6*fExpertAverage+0.4*fPeopleAverage);
iResult=t*10+5;
iResult=iResult/10;
}
return iResult;
}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[])
#include "stdafx.h"
#include<iostream>
using namespace std;
void sort(int input[], int n, int output[]);
int _tmain(int argc, _TCHAR* argv[])
{
int input[] = {3, 6, 1, 9, 7,8};
int output[] = {3, 7, 9, 6, 1,8};
int m=sizeof(input)/sizeof(int);
sort(input,m,output);
for(int i=0;i<m;i++)
{
cout<<output[i]<<" ";
}
system("pause");
return 0;
}
void sort(int input[], int n, int output[])
{
int temp=0;
bool Change=false;
//边界条件
if((input==NULL)||(output==NULL)||(n<=0))
return;
//排序 由小到大
for(int i=0;i<n;i++)
{
Change=false;
for(int j=n-1;j>=i;j--)
{
if(input[j]<input[j-1])
{
Change=true;
temp=input[j];
input[j]=input[j-1];
input[j-1]=temp;
}
}
if(!Change)
break;
}
int center=n/2;
output[center]=input[n-1];
int k=n-2;
int offset=1;
while(k>=0)
{
output[center-offset]=input[k--];
if(k<0)
{
break;
}
output[center+offset]=input[k--];
offset++;
}
}
操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 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 "stdafx.h"
#include <iostream>
using namespace std;
void scheduler(int task[], int n, int system_task[], int user_task[]);
void Swap(int* a,int* b);
int _tmain(int argc, _TCHAR* argv[])
{
int task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99} ;
int system_task[5] = {0};
int user_task[5] = {0};
int m=sizeof(task)/sizeof(int);
scheduler(task,m,system_task,user_task);
for(int i=0;i<5;i++)
{
cout<<system_task[i]<<" ";
}
cout<<endl;
for(int i=0;i<5;i++)
{
cout<<user_task[i]<<" ";
}
system("pause");
return 0;
}
void scheduler(int task[], int n, int system_task[], int user_task[])
{
//处理边界问题
if((task==NULL)||(n<=0)||(system_task==NULL)||(user_task==NULL))
{
return ;
}
int iSystemTaskNum=0;
int iUserTaskNum=0;
for(int i=0;i<n;i++)
{
if((task[i]>=0)&&(task[i]<50)) //系统任务
{
system_task[iSystemTaskNum++]=i;
}
else if((task[i]>=50)&&(task[i]<=250)) //用户任务
{
user_task[iUserTaskNum++]=i;
}
else //非法任务
{
}
}
int temp;
//按优先级由高到低排序
for(int i=0;i<iSystemTaskNum;i++)
{
int min=task[system_task[i]];
int index=i;
for(int j=iSystemTaskNum-1;j>=i;j--)
{
if(task[system_task[j]]<min)
{
min=task[system_task[j]];
index=j;
}
}
if(i!=index)
{
Swap(&system_task[i],&system_task[index]);
}
}
for(int i=0;i<iUserTaskNum;i++)
{
int min=task[user_task[i]];
int index=i;
for(int j=iUserTaskNum-1;j>=i;j--)
{
if(task[user_task[j]]<min)
{
min=task[user_task[j]];
index=j;
}
}
if(i!=index)
{
Swap(&user_task[i],&user_task[index]);
}
}
system_task[iSystemTaskNum]=-1;
user_task[iUserTaskNum]=-1;
}
void Swap(int* a,int* b)
{
int tp;
tp=*a;
*a=*b;
*b=tp;
}
4.
比较两个数组，要求从数组最后一个元素开始逐个元素向前比较，如果2个数组长度不等，则只比较较短长度数组个数元素。请编程实现上述比较，并返回比较中发现的不相等元素的个数
比如：
数组{1,3,5}和数组{77,21,1,3,5}按题述要求比较，不相等元素个数为0
数组{1,3,5}和数组{77,21,1,3,5,7}按题述要求比较，不相等元素个数为3
要求实现函数：
int array_compare(int len1, int array1[], int len2, int array2[])
#include "stdafx.h"
#include <iostream>
#include <assert.h>
using namespace std;
int array_compare(int len1, int array1[], int len2, int array2[]);
int _tmain(int argc, _TCHAR* argv[])
{
int array1[] = {1,3,5};
int len1 = 3;
int array2[] = {77,21,1,3,5,7};
int len2 = 6;
cout<<array_compare(len1,array1,len2,array2)<<endl;
system("pause");
return 0;
}
int array_compare(int len1, int array1[], int len2, int array2[])
{
//边界
if((len1<=0)||(array1==NULL)||(len2<=0)||(array2==NULL))
{
return -1;
}
int iNum=0;
int n;
if(len1<len2)
{
n=len1-1;
while(n>=0)
{
if(array1[n]!=array2[len2-len1+n])
{
iNum++;
}
n--;
}
}
else
{
n=len2-1;
while(n>=0)
{
if(array1[len1-len2+n]!=array2[n])
{
iNum++;
}
n--;
}
}
return iNum;
}
5.约瑟夫问题: 输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替 换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程 实现上述计数过程，同时输出数值出列的顺序
比如：输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）
第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数
第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
最后一轮计数出列数字为4，计数过程完成。
输出数值出列顺序为：2,3,1,4。
#include "stdafx.h"
#include <iostream>
using namespace std;
void array_iterate(int len, int input_array[], int m, int output_array[]);
int _tmain(int argc, _TCHAR* argv[])
{
int input_array[] = {3,1,2,4};
int len = 4;
int m=7;
int output_array[4] = {-1};
array_iterate(len,input_array,m,output_array);
for(int i=0;i<len;i++)
{
cout<<output_array[i]<<" ";
}
system("pause");
return 0;
}
void array_iterate(int len, int input_array[], int m, int output_array[])
{
//边界条件
if((len<=0)||(input_array==NULL)||(m<=0)||(output_array==NULL))
{
return;
}
int n=len;
int pos=0;//计数起点位置序号
int i=0;
while(n>1)
{
int tp=pos+m%n;
if(tp>n-1) //偏移后序号超过数组大小
{
pos=tp%n-1;
}
else
{
pos=tp-1;
}
m=input_array[pos];
output_array[i++]=input_array[pos];
for(int j=pos;j<n-1;j++)
{
input_array[j]=input_array[j+1];
}
n--;
}
output_array[i++]=input_array[0];
}6.简单四则运算
问题描述：输入一个只包含个位数字的简单四则运算表达式字符串，计算该表达式的值
注：
3.1、表达式只含 +, -, *, / 四则运算符，不含括号
3.2、表达式数值只包含个位整数(0-9)，且不会出现0作为除数的情况
3.3、要考虑加减乘除按通常四则运算规定的计算优先级
3.4、除法用整数除法，即仅保留除法运算结果的整数部分。比如8/3=2。输入表达式保证无0作为除数情况发生
3.5、输入字符串一定是符合题意合法的表达式，其中只包括数字字符和四则运算符字符，除此之外不含其它任何字符，不会出现计算溢出情况
要求实现函数：int calculate(int len, char *expStr)
示例:
1）输入：char *expStr = “1+4*5-8/3”
函数返回：19
#include "stdafx.h"
#include <iostream>
#include <ctype.h>
using namespace std;
int calculate(int len, char *expStr);
int _tmain(int argc, _TCHAR* argv[])
{
char *expStr = "1+4*5-8/3";
char *expStr1 = "8/3*3";
cout<<calculate(5,expStr1)<<endl;
system("pause");
return 0;
}
int calculate(int len, char *expStr)
{
int iOperateNum=0;
int iNumberNum=0;
for(int i=0;i<len;i++)
{
if(isdigit(expStr[i]))
{
iNumberNum++;
}
else
{
iOperateNum++;
}
}
char* OperateSign=new char[iOperateNum-1]; //+ -栈
int* Number=new int[iNumberNum-1];//操作数
iNumberNum=0;
iOperateNum=0;
//相当于入栈
for(int i=0;i<len;i++)
{
if(isdigit(expStr[i]))
{
Number[iNumberNum++]=expStr[i]-'0';
}
else if((expStr[i]=='+')||(expStr[i]=='-'))
{
OperateSign[iOperateNum++]=expStr[i];
}
else if(expStr[i]=='*')
{
Number[iNumberNum-1]*=expStr[i+1]-'0';
i++; //跳过*号后面的数字
}
else if(expStr[i]=='/')
{
int m=expStr[i+1]-'0';
if(m!=0) //被除数不为0
{
Number[iNumberNum-1]/=m;
i++; //跳过*号后面的数字
}
else
{
return -1;
}
}
}
iNumberNum--;
iOperateNum--;
for(int i=iOperateNum;i>=0;i--)
{
if(OperateSign[i]=='+')
{
iNumberNum--;
Number[iNumberNum]+=Number[iNumberNum+1];
}
else if(OperateSign[i]=='-')
{
iNumberNum--;
Number[iNumberNum]-=Number[iNumberNum+1];
}
}
return Number[0];
}7.
识别字符串中的整数并转换为数字形式（40分）
问题描述：
识别输入字符串中所有的整数，统计整数个数并将这些字符串形式的整数转换为数字形式整数。
要求实现函数：
void take_num(const char *strIn, int *n, unsigned int *outArray)
示例
输入：strIn = "ab00cd+123fght456-25 3.005fgh"
输出：n = 6
#include "stdafx.h"
#include <iostream>
#include <ctype.h>
#include <math.h>
using namespace std;
#define Max 100
bool isExist(int a,unsigned int *outArray);
void take_num(const char *strIn, int *n, unsigned int *outArray);
int _tmain(int argc, _TCHAR* argv[])
{
char* strIn = "ab00cd+123fght456-25 3.005fgh";
unsigned int* outArray = new unsigned int[Max];
int m=-1;
take_num(strIn,&m,outArray);
cout<<m<<endl;
for(int i=0;i<m;i++)
{
cout<<outArray[i]<<" ";
}
system("pause");
return 0;
}
void take_num(const char *strIn, int *n, unsigned int *outArray)
{
int Len =strlen(strIn);
int iNum=0;
int* Number=new int[Max];
int iOut=0;
for(int i=0;i<Len;i++)
{
if(isdigit(strIn[i])) //如果是数字
{
Number[iNum++]=strIn[i]-'0';
}
else
{
if(iNum!=0) //如果有数字
{
int temp=0;
for(int j=0;j<iNum;j++)
{
temp+=Number[j]*(int)pow(10.0,iNum-j-1);
}
//查重
if(isExist(temp,outArray))
{
}
else
{
outArray[iOut++]=temp;
}
iNum=0;
}
}
}
*n=iOut;
}
bool isExist(int a,unsigned int *outArray)
{
if(outArray==NULL)
{
return false;
}
int n=_msize(outArray)/sizeof(outArray);///就能得到数组元素个数
for(int i=0;i<n;i++)
{
if(outArray[i]==a)
{
return true;
}
}
return false;
}
8. 问题描述：
将输入的字符串（字符串仅包含小写字母‘a’到‘z’），按照如下规则，循环转换后输出：a->b,b->c,…,y->z,z->a；若输入的字符串连续出现两个字母相同时，后一个字母需要连续转换2次。例如：aa 转换为 bc，zz 转换为 ab；当连续相同字母超过两个时，第三个出现的字母按第一次出现算。
要求实现函数：
void convert(char *input,char* output)
【输入】 char *input , 输入的字符串
【输出】 char *output ，输出的字符串
【返回】 无
#include "stdafx.h"
#include <iostream>
using namespace std;
void convert(char *input,char* output);
int _tmain(int argc, _TCHAR* argv[])
{
char* input="abbbcd" ;
char* output=new char[strlen(input)];
convert(input,output);
for(int i=0;i<strlen(input);i++)
{
cout<<output[i]<<" ";
}
system("pause");
return 0;
}
void convert(char *input,char* output)
{
//边界处理
if((input==NULL)||(output==NULL))
{
return;
}
int Len=strlen(input);
char Pre[2]={'\0','\0'}; //Pre[0] 上上次字符 Pre[1]上次字符
for(int i=0;i<Len;i++)
{
if(input[i]!=Pre[1]) //当前字符不等于上次字符
{
output[i]=(input[i]-'a'+1)%26+'a';
Pre[0]=Pre[1];
Pre[1]=input[i];
}
else //连续2个字符一样
{
if(input[i]!=Pre[0]) //如果当前字符等于上上次字符 连续3个字符一样
{
output[i]=(input[i]-'a'+2)%26+'a';
Pre[0]=Pre[1];
Pre[1]=input[i];
}
else
{
output[i]=(input[i]-'a'+1)%26+'a';
Pre[0]=Pre[1];
Pre[1]=input[i];
}
}
}
}9. 问题描述：
在给定字符串中找出单词（ “单词”由大写字母和小写字母字符构成，其他非字母字符视为单词的间隔，如空格、问号、数字等等；另外单个字母不算单词）；找到单词后，按照长度进行降序排序，（排序时如果长度相同，则按出现的顺序进行排列），然后输出到一个新的字符串中；如果某个单词重复出现多次，则只输出一次；如果整个输入的字符串中没有找到单词，请输出空串。输出的单词之间使用一个“空格”隔开，最后一个单词后不加空格。
要求实现函数：
void my_word(charinput[], char output[])
【输入】 char input[], 输入的字符串
【输出】 char output[]，输出的字符串
【返回】 无
示例
输入：charinput[]="some local buses, some1234123drivers" ，
输出：charoutput[]="drivers local buses some"
输入：charinput[]="%A^123 t 3453i*()" ，
输出：charoutput[]=""
#include "stdafx.h"
#include <iostream>
#include <string.h>
using namespace std;
#define WordMaxLen 100 //设单词最大长度为100
#define Max 20
void my_word(char input[], char output[]);
bool IsExist(char P[][Max],int n);
void StringConnect(char* dest,char source);
void SwapPointer(char *p,char* q);
int _tmain(int argc, _TCHAR* argv[])
{
char input[]="some local buses, some1234123drivers" ;
//char input[]="%A^123 t 3453i*()" ;
char output[WordMaxLen]="";
my_word(input,output);
cout<<output<<endl;
system("pause");
return 0;
}
void my_word(char input[], char output[])
{
if(input==NULL||output==NULL)
{
return;
}
char P[WordMaxLen][Max]={""}; //存储单词数组
for(int i=0;i<WordMaxLen;i++)
{
for (int j=0;j<Max;j++)
{
P[i][j]='\0';
}
}
int OutNum=0;
int Length=strlen(input);
for(int i=0;i<Length;i++)
{
if(((input[i]>='a')&&(input[i]<='z'))||((input[i]>='A')&&(input[i]<='Z'))) //如果当前字符为字母
{
StringConnect(P[OutNum],input[i]);
}
else
{
int nn=strlen(P[OutNum]);
if(nn>1) //如果Word[]有字母，且字母数大于1 则算一个单词，否则不算
{
//查重
if(IsExist(P,OutNum))
{
for(int k=0;k<Max;k++)
{
P[OutNum][k]='\0';
}
}
else
{
OutNum++;
}
}
else
{
for(int k=0;k<Max;k++)
{
P[OutNum][k]='\0';
}
}
}
}
//按单词长度进行排列
int n=0;
int OutLen=0; //总字符长度
while(1)
{
if(strlen(P[n])>0)
{
OutLen+=strlen(P[n]);
n++;
}
else
{
break;
}
}
char *tp=NULL;
for(int i=1;i<n;i++)
{
for(int j=n-1;j>=i;j--)
{
if(strlen(P[j])>strlen(P[j-1]))
{
SwapPointer(P[j],P[j-1]);
}
}
}
//赋值给output
char ss[WordMaxLen]="";
for(int i=0;i<n;i++)
{
if(i!=n-1)
{
strcat(ss,P[i]);
strcat(ss," ");
}
else
{
strcat(ss,P[i]);
}
}
for(int i=0;i<OutLen;i++)
{
output[i]=ss[i];
}
}
bool IsExist(char P[][Max],int n)
{
for(int i=0;i<n-1;i++)
{
if(P[i]==P[n-1])
{
return true;
}
}
return false;
}
void StringConnect(char* dest,char source)
{
while(*dest!='\0')
{
dest++;
}
*dest=source;
}
void SwapPointer(char *p,char*q)
{
char temp;
int n1=strlen(p);
int n2=strlen(q);
if(n1>n2)
{
for(int i=0;i<n2;i++)
{
temp=p[i];
p[i]=q[i];
q[i]=temp;
}
for(int i=n2;i<n1;i++)
{
q[i]=p[i];
p[i]='\0';
}
}
else
{
for(int i=0;i<n1;i++)
{
temp=p[i];
p[i]=q[i];
q[i]=temp;
}
for(int i=n1;i<n2;i++)
{
p[i]=q[i];
q[i]='\0';
}
}
}
用string思想要简单一些.
#include<iostream>
#include<string>
using namespace std;
#define Max 100
void my_word(char input[], char output[]); //提取字符串中的单词,并按长度由大到小输出
bool IsLetter(char s); //判断一个字符是否为字母
bool IsExist(string tp[],int n,string s); //查重函数
int main()
{
char input[]="some local buses, some1234123drivers";
char output[50]="";
my_word(input,output);
cout<<output<<endl;
system("pause");
return 0;
}
void my_word(char input[], char output[])
{
string sinput(input);
int n=sinput.length();//输入字符串的长度
string tp[Max]={""};
int wordnum=0;
int num=0;
bool flag=false;
for(int i=0;i<n;i++)
{
if(true==IsLetter(sinput[i]))
{
wordnum++;
if(n-1==i)
{
string ss=sinput.substr(i-wordnum+1,wordnum);
if(!IsExist(tp,num,ss))
{
tp[num++]=ss;
}
}
}
else
{
if((i>1)&&(true==IsLetter(sinput[i-1]))) //如果上一次为字母
{
if(wordnum>1)
{
string ss=sinput.substr(i-wordnum,wordnum);
if(!IsExist(tp,num,ss))
{
tp[num++]=ss;
}
}
wordnum=0;
}
}
}
for(int i=0;i<num;i++)
{
for(int j=num-1;j>i;j--)
{
if(tp[j].length()>tp[j-1].length())
{
tp[j].swap(tp[j-1]);
}
}
}
string soutput="";
for(int i=0;i<num;i++)
{
if(0!=i)
{
soutput.append(" ");
}
soutput.append(tp[i]);
}
for(int i=0;i<soutput.length();i++)
output[i]=soutput[i];
}
bool IsLetter(char s)
{
if((s>='a')&&(s<='z'))
{
return true;
}
else if((s>='A')&&(s<='Z'))
{
return true;
}
else
{
return false;
}
}
bool IsExist(string tp[],int n,string s) //查重函数
{
for(int i=0;i<n;i++)
{
if(s==tp[i])
{
return true;
}
}
return false;
}10.
一、题目描述（60分）：
通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串过滤程序，若字符串中出现多个相同的字符，将非首次出现的字符过滤掉。
比如字符串“abacacde”过滤结果为“abcde”。
要求实现函数：void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr);
【输入】 pInputStr： 输入字符串
lInputLen： 输入字符串长度
【输出】 pOutputStr： 输出字符串，空间已经开辟好，与输入字符串等长；
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例
输入：“deefd” 输出：“def”
输入：“afafafaf” 输出：“af”
输入：“pppppppp” 输出：“p”
void stringFilter(const char *pInputStr, long lInputLen, char *pOutputStr)
{
bool temp[26]={false}; //a-z是否已出现
int num=0;
for(int i=0;i<lInputLen;i++)
{
if(false==temp[pInputStr[i]-'a']) //如果当前字母以前没出现过
{
temp[pInputStr[i]-'a']=true;
pOutputStr[num++]=pInputStr[i];
}
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
