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

怼烎@ 2022-09-26 11:53 164阅读 0赞

//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;
    }
    */