【c语言】c语言常见编程题总结（五）

//50.使用c语言编写函数：unsigned int reverse_bit(unsigned int value);
//这个函数的返回值是value的二进制位模式从左到右翻转后的值

/*方法一：通过位运算取出25的每一位二进制数，取出第一个数乘以2^31,第二个数乘以2^30，依次取出并计算出总和
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
typedef unsigned int unit;
int main()
{
unit reverse_bit(unit value);
int value=0;
int num=0;
scanf("%d",&value);
num=reverse_bit(value);
printf("%u\n",num);
return 0;
}
unit reverse_bit(unit value)
{
int i=0;
unit num=0;
for(i=0;i<32;i++)
{
num+=((value>>i)&1)*pow(2,31-i);
}
return num;
}
*/

/*方法二：通过位运算直接将取出的第一位左移31位，第二位左移30位，设置一个变量进行移位运算，经过循环每一位都进行左移
#include <stdio.h>
int main()
{
unsigned int reverse_bit(unsigned int value);
int value=0;
int num=0;
scanf("%d",&value);
num=reverse_bit(value);
printf("%u\n",num);
return 0;
}
unsigned int reverse_bit(unsigned int value)
{
unsigned int ret=0;
int i=0;
while(i<32)
{
ret<<=1;
ret|=(value>>i)&1;
i++;
}
return ret;
}
*/

/*49.有一个字符串是"student a am i",现编写代码将字符串转换为"i am a student" 要求：空间复杂度是O(1)
//可以先将整个字符串逆序"i ma a tneduts"
//再将每个单词逆序"i am a student"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
int main()
{
void reverse_str(char *left,char *right);
void reverse(char *str);
char str[]="strudent a am i";
reverse(str);
printf("%s\n",str);
return 0;
}
void reverse_str(char *left,char *right)
{
assert(left);
assert(right);
while(left<right)
{
char tmp =*left;
*left=*right;
*right=tmp;
left++;
right--;
}
}
void reverse(char *str)
{
char *pstart=str;
char *pend=str+strlen(str)-1;
char *pcur=NULL;
if((str==NULL)||(*str=='\0'))
{
return;
}
reverse_str(pstart,pend);
while(*str)
{
pcur=str;
while(*str!='\0'&&*str!=' ')
{
str++;
}
pend=str-1;
reverse_str(pcur,pend);
if(*str==' ')
str++;

}
}
*/

/*48.实现一个函数可以求任意多个整数的平均值(使用可变参数列表)
#include <stdio.h>
#include <stdarg.h>
float averge(int val,...)
{
va_list arg;
int count;
float sum=0.0;
va_start(arg,val);
for(count=0;count<val;count++)
{
sum+=va_arg(arg,int);
}
va_end(arg);
return  sum/ val;
}
int main()
{
float ret=averge(5,1,2,3,4,5);
printf("%f\n",ret);
return 0;
}
*/

/*47.1元钱一瓶汽水，喝完后两个空瓶换一瓶汽水，问：你有20元钱，最多可以喝到几瓶汽水？
#include <stdio.h>
int main()
{
int money=9;
int count=money;
while(1)
{
if(money%2!=0)
{
count=count+money;
break;
}
else
{
money=money/2;
count+=money;
}
}
printf("%d\n",count);
return 0;
}
*/

/*46.将一个数字字符串转换为对应的数字，不考虑溢出。（比如"12.34"转换为数字：12.34）功能类似atof，考虑异常输入
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
int main()
{
double my_atof(char *str);
double ret;
char arr[100];
scanf("%s",arr);
ret=my_atof(arr);
printf("%f\n",ret);
return 0;
}
double my_atof(char *str)
{
double ret=0.0;
int sign=1;
char *point;
while(*str!='\0')
{
if(isspace(*str))
{
str++;
}
else if(*str=='-')
{
sign=-1;
str++;
}
else if((*str=='+'))
{
str++;
}
else if(*str=='.')
{
point=str;
str++;
}
else if((*str>='0')&&(*str<='9'))
{
ret=ret*10.0+(*str-'0');
str++;
}
}
ret=sign*ret/pow(10,str-point-1);
return ret;
}
*/

/*45.(memset)实现内存的设置，功能类似memset，可以以字节为单位设置内存的值，不能使用任何库函数
#include <stdio.h>
#include <assert.h>
int main()
{
void *my_memset(void *s,int ch,int n);
char s1[10];
int i=0;
my_memset(s1,7,7);
for(i=0;i<10;i++)
{
printf("%d ",s1[i]);
}
printf("\n");
return 0;
}
void *my_memset(void *s,int ch,int n)
{
assert(s);
char *dst=(char*)s;
int i=0;
for(i=0;i<n;i++)
{
*(dst+i)=ch;
}
return s;
}
*/

/*44.(memmove)实现内存的移动，功能类似memmove，实现内存重叠拷贝，不能使用任何库函数
//memmove:
//(1)当源内存的首地址等于目标内存的首地址时，不进行任何拷贝；
//(2)当源内存的首地址大于目标内存的首地址时，实行正向拷贝;
//(3)当源内存的首地址小于目标内存的首地址时，实行反向拷贝;
#include <stdio.h>
#include <assert.h>
int main()
{
void *my_memmove(void *dst,const void *src,int count);
char p[]="hello-world";
char q[10];
my_memmove(p+1,p,6);
printf("%s\n",p);
my_memmove(q,p,6);
printf("%s\n",q);
return 0;
}
void *my_memmove(void *dst,const void *src,int n)
{
void *ret=dst;
char *p1=(char*)dst;
char *p2=(char*)src;
assert(dst);
assert(src);
if((p2<=p1)&&(p1<=p2+n))
{
p2=p2+n-1;
p1=p1+n-1;
while(n--)
{
*p1=*p2;
p1--;
p2--;
}
}
else
{
while(n--)
{
*p1=*p2;
p1++;
p2++;
}
*p1='\0';
}
return ret;
}
*/

/*43.(memcpy)实现内存的拷贝，功能类似memcpy，可以不实现内存重叠拷贝，不能使用任何库函数
#include <stdio.h>
#include <assert.h>
int main()
{
void *my_memcpy(void *dst,const void *src,int n);
char a[]="hello world";
char b[10];
my_memcpy(b,a,7);
printf("%s\n",b);
return 0;
}
void *my_memcpy(void *dst,const void *src,int n)
{
void *ret=dst;
char *p1=(char*)dst;
char *p2=(char*)src;
assert(dst);
assert(src);
while(n--)
{
*p1++=*p2++;
}
*p1='\0';
return ret;
}
*/

/*memcmp
#include <stdio.h>
#include <assert.h>
int main()
{
int my_memcmp(const void *dst,const void *src,int count);
int a[10]={1,2,3,4,5,6,7,8,9,0};
int b[]={1,1,3};
int ret=my_memcmp(a,b,5);
printf("%d\n",ret);
return 0;
}
int my_memcmp(const void *dst,const void *src,int count)
{
assert(dst);
assert(src);
while(*(char*)dst==*(char*)src)
{
dst=(char*)dst+1;
src=(char*)src+1;
count--;
if(count==0)
{
return 0;
}
}
if(*(char*)dst>*(char*)src)
{
return 1;
}
else
{
return -1;
}
}
*/

/*42.(strcmp)实现字符串的比较，功能类似strcmp，不能使用任何库函数
#include <stdio.h>
int main()
{
int my_strcmp(const char *dest,const char *src);
char s1[50],s2[50];
printf("input s1:");
scanf("%s",s1);
printf("input s2:");
scanf("%s",s2);
int ret=my_strcmp(s1,s2);
printf("%d\n",ret);
return 0;
}
int my_strcmp(const char *str1,const char *str2)
{
int i=0,j=0;
int result;
while((str1[i]==str2[j])&&(str1[i]!='\0'))
{
i++;
j++;
}
if(str1[i]=='\0'&&str2[j]=='\0')
{
result=0;
}
else
{
result=str1[i]-str2[j];
}
return result;
}
*/

/*41.(strcat)实现字符串的连接，功能类似strcat，不能使用任何库函数
#include <stdio.h>
int main()
{
char *my_strcat(char *dest,const char *src);
char s1[50],s2[50];
printf("input s1:");
scanf("%s",s1);
printf("input s2:");
scanf("%s",s2);
my_strcat(s1,s2);
printf("s1:%s\n",s1);
return 0;
}
char *my_strcat(char *dest,const char *src)
{
int i=0,j=0;
char *t=dest;
while(dest[i]!='\0')
{
i++;
}
while(src[j]!='\0')
{
dest[i++]=src[j++];
}
dest[i]='\0';
return t;
}
*/
/*40.(strcpy)实现字符串的拷贝，功能类似strcpy，不能使用任何库函数
#include <stdio.h>
#include <assert.h>
int main()
{
char *my_strcpy(char *dest,const char *src);
char s1[50],s2[50];
printf("input s2:");
scanf("%s",s2);
my_strcpy(s1,s2);
printf("s1:%s\n",s1);
return 0;
}
char *my_strcpy(char *dest,const char *src)
{
assert(dest);
assert(src);
char *t=dest;
while((*dest++=*src++)!='\0')
{
}
return t;
}
*/