一些笔试题笔记1

最新推荐文章于 2021-01-14 11:06:32 发布

二零一四Tenc

最新推荐文章于 2021-01-14 11:06:32 发布

阅读量1k

点赞数

分类专栏：笔试面试文章标签：递归线程应用程序

本文链接：https://blog.csdn.net/zpxly/article/details/11632293

版权

笔试面试专栏收录该内容

9 篇文章 0 订阅

订阅专栏

总结一些常见的笔试题：

最小公约数和最大公倍数：

这个其实很简单，记住概念就可以了，我们利用辗转相除法计算：

最大公约数：（摘自百度百科）

一般地，如果求a和b的最大公约数（a>b），那么

当时，得 $\left(a,b\right)=b$ ，这里表示b整除a，而 $b\nmid a$ 表示b不能整除，当 $b\nmid a$ 时，设余数为，根据整除的性质，有 $\left(a,b\right)=\left(b,r_1\right)$ ；当时，得

$\left(b,r_1\right)=r_1$ ，当 $r_1\nmid b$ 时，设余数为，于是 $\left(b,r_1\right)=\left(r_1,r_2\right)$

最小公倍数=两数的乘积/最大公约（因）数

#include <stdio.h>
void func1(int a, int b)//非递归实现
{
	int max, min, temp;
	if(a > b) {max = a; min = b;}
	else 	  {max = b; min = a;}

	while( min != 0)
	{
		temp = min;
		min = max%min;
		max = temp;
	}
	printf("最大公约数 %d\n",max);
	printf("最小公倍数 %d\n",(a*b)/max);
}

int func2(int a, int b)//递归实现
{
	if(a == 0)
		return b;
	else if(b == 0)
		return a;
	int max, min;
	if(a > b) {max = a; min = b;}
	else 	  {max = b; min = a;}

	max = func2(min, max%min);
	return max;
}
void main()
{
	int x , y, ret;
	printf("please input two num:\n");
	scanf("%d %d",&x, &y);
	func1(x,y);
	ret = func2(x,y);
	printf("最大公约数 %d\n",ret);
	printf("最小公倍数 %d\n",(x*y)/ret);

}

2.字符串翻转问题

这个太简单了，就不多说了

#include <stdio.h>
#include <string.h>
void turn(char *s)
{
	int len = strlen(s), mid = len/2, i = 0;
	while(i < mid)//此处不能相等
	{
		char temp = s[len-1-i];
		s[len-1-i] = s[i];
		s[i] = temp;
		i++;
	}
}
int main()
{
	printf("please input a string\n");
	char s[20];
	gets(s);
	turn(s);
	printf("after turn, the string is:%s\n", s);
	return 0;
}

3.判断小端还是大端

使用联合体，取低字节

int main()
{
	union{
		int x;
		char c;
	}u;
	u.x = 1;
	if(u.c == 1)
		printf("little endian\n");
	else
		printf("big endian\n");
	return 0;
}

4.给定一个字符串，翻转一些位数

例如：给定abcdefg,翻转后变为：efgabcd，这个也不难，先全部翻转过来，再翻转一定的位数，再把这些位数后面的翻转

#include <stdio.h>
#include <string.h>

void turn(char *s, int n)
{
	int len = n, mid = len/2, i = 0;
	while(i < mid)
	{
		char temp = s[len-1-i];
		s[len-1-i] = s[i];
		s[i] = temp;
		i++;
	}
}
int main()
{
	char s[] = "abcdefg";
	turn(s, strlen(s));
	printf("after turn: %s\n",s);
	turn(s, 3);
	printf("after turn: %s\n",s);
	turn(s+3,strlen(s)-3);
	printf("after turn: %s\n",s);
	return 0;
}

5.两个线程交替输出1-10个数

考察线程的基本知识，要能写出来

#include <pthread.h>
#include <stdio.h>

struct X
{
	int data;
	pthread_mutex_t lock;
}x = {10,PTHREAD_MUTEX_INITIALIZER};

void *func1(void *arg)
{
	pthread_mutex_lock(&x.lock);
	while(x.data >= 1)
	{
		printf("int the thread1: %d\n",x.data);
		x.data--;
		sleep(1);
	}
	pthread_mutex_unlock(&x.lock);
}

void *func2(void *arg)
{
	pthread_mutex_lock(&x.lock);
	while(x.data >= 1)
	{
		printf("int the thread2: %d\n",x.data);
		x.data--;
		sleep(1);
	}
	pthread_mutex_unlock(&x.lock);
}

void main()
{
	pthread_t ptid[2];
	int *ret, j;
	pthread_create(&ptid[0], NULL, func1, NULL);
	pthread_create(&ptid[1], NULL, func2, NULL);
	for(j = 0; j < 2; j++)
		pthread_join(ptid[j], (void**)&ret);//等待线程的退出
}

注意头文件<pthread.h>和编译链接项 -pthread

6.宏定义交换两个数

有多种写法

#include <stdio.h>

#define SWAP(x, y) (x = x+y, y = x-y, x = x-y)
#define swap(x, y) (x = x^y, y = x^y, x = x^y)//不会产生大数字溢出问题

//带有换行的
#define Swap(x, y)\
	x = x+y;\
	y = x-y;\
	x = x-y
	
void main()
{
	int x = 3, y = 5;
	//SWAP(x, y);
	//Swap(x, y);
	swap(x ,y);
	printf("x:%d  y:%d\n",x, y);
}

7.全排列的实现

全排列是一个比较复杂的算法，例如“123”的全排列，我们可以枚举出来是123,132,231,213,321,312,我们发现，每一个数都会排在开头，那么这是不是递归的思想，

我们把每一个数放到开头，剩下的数再全排列一下，这样就是拿出1,全排列23,拿出2,全排列13,拿出3,全排列12，这样一分析就简单了

但是有一个问题，例如：如果有这样的数：1223那怎么办呢？我们这样想，在把第2个2拿到第一个位置的时候，我们发现这个2前面已经有个2了，这样就重复了呀，

怎么办呢？（好多2啊-_-!），这里我们就不把第二个2拿到第一个位置就是了，我们写了一个 is_swap函数在每次把数拿到第一个位置的时候判断了一下

#include <stdio.h>
#include <string.h>

void swap(char *s, char *t)
{
	char temp = *s;
	*s = *t;
	*t = temp;
}

int is_swap(char *s, int begin, int end)
{
	int i;
	for(i = begin; i < end; i++)
	{
		if(s[i] == s[end])
			return 0;
	}
	return 1;
}

void all_rang(char *s, int m, int n)
{
	int i, j;
	if(m == n)
	{
		static int i = 1;
		printf("第%d个全排列是：%s\n", i++, s);
		return;
	}

	for(j = m; j <= n; j++)
	{
		if(is_swap(s, m, j))
		{
			swap(s+m,s+j);
			all_rang(s, m+1, n);
			swap(s+m, s+j);
		}
	}

}
void main()
{
	char s[10] = "1223";
	all_rang(s, 0, strlen(s)-1);
}

关于二维数组的总结：

#include <stdio.h>

void main()
{
    int a[4][4] = 
    {   
        {1,2,3,4},
        {50,60,70,80},
        {900,1000,1100,1200},
        {13000,14000,15000,16000}
    };  

    int (*p1)[4] = a;
    int (*p2)[4] = &a[0];
    int (*p3)[4] = &a[0][0];
    printf("%d  %d\n",*(*p1+7), *(*(p2+1)-4));//这里是这种写法

    int *p6 = a;
    int *p5 = &a[0];
    int *p4 = &a[0][0];
    printf("%d\n",*(p4+7));//这里是这种写法

    //int *(p7)[4][4] = a;
  //int *(p8)[4][4] = &a[0];
    //int *(p9)[4][4] = &a[0][0];
    //printf("%d\n",*(p7+7));
}

这个在笔试中常考，记住只有两种写法，并且指针的运算在这两种写法上的区别

二零一四Tenc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
一些笔试题笔记1

总结一些常见的笔试题：最小公约数和最大公倍数：这个其实很简单，记住概念就可以了，我们利用辗转相除法计算：最大公约数：（摘自百度百科）一般地，如果求a和b的最大公约数（a>b），那么当时，得，这里表示b整除a，而表示b不能整除，当时，设余数为，根据整除的性质，有；当时，得，当时，设余数为，于是最小公倍数=两数的乘积/最大公约（因）数#include void
复制链接

扫一扫