C语言编程与算法（另）

最新推荐文章于 2023-02-13 17:38:22 发布
最新推荐文章于 2023-02-13 17:38:22 发布
阅读量798 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43831728/article/details/101281132
版权

21.编写一个程序，可以一直接收键盘字符，如果是小写字符就输出对应的大写字符，如果接收的是大写字符，就输出对应的小写字符，如果是数字不输出。

#include<stdio.h>
int main()
{
	int ch = 0;
	while ((ch = getchar()) != EOF)
	{
		if (ch >= 'a' && ch <= 'z')
		{
			putchar(ch - 32);
		}
		else if (ch >= 'A' && ch <= 'Z')
		{
			putchar(ch + 32);
		}
		else if (ch >= '0' && ch <= '9')
		{
			continue;
		}
		else
		{
			putchar(ch);
		}
	}
	return 0;
}

2.实现一个函数，打印乘法口诀表，口诀表的行数和列数自己指定， 输入9，输出9 *9乘法口诀表，输入12，输出12 * 12的乘法口诀表

#include<stdio.h>
int main()
{
	int input = 0;
	int i = 0;
	int j = 0;
	scanf("%d", &input);
	for (i = 1; i <= input; i++)
	{
		for (j = 1; j <= i ;j++)
		{
			printf("%d*%d=%2d ", i, j, i * j);
		}
		printf("\n");
	}
	return 0;
}

3.写要给函数，实现N的K次方，使用递归来实现

#include<stdio.h>
double Pow(int n, int k)
{
	if (k == 0)
	{
		return 1;
	}
	else if (k >=1)
	{
		return n * Pow(n, k - 1);
	}
	else
	{
		return 1.0 / ((Pow(n, -k)));
	}
}
int main()
{
	int n = 0;
	int k = 0;
	double ret = 0;
	scanf("%d %d", &n, &k);
	ret = Pow(n, k);
	printf("%lf", ret);
	return 0;
}

4.写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和， 例如，调用DigitSum(1729)，则应该返回1 + 7 + 2 + 9，它的和是19

#include<stdio.h>
int Digitsum(int n)
{
	if (n > 9)
	{
		return Digitsum(n / 10) + n % 10;
	}
	else
	{
		return n;
	}
}
int main()
{
	//TDD------测试驱动开发
	unsigned int n = 0;
	int sum = 0;
	scanf("%u", &n);
	sum = Digitsum(n);
	printf("%d", sum);
	return 0;
}

5.模拟实现strlen(用递归）

//用递归
#include<stdio.h>
int my_strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}
int main()
{
	int len = my_strlen("abc");
	printf("%d", len);
	return 0;
}

//用非递归
#include<stdio.h>
int my_strlen(const char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	int len = my_strlen("abcdef");
	printf("%d", len);
	return 0;
}

6.编写一个函数 reverse_string(char * string)（递归实现）
实现：将参数字符串中的字符反向排列。
要求：不能使用C函数库中的字符串操作函数。

#include<stdio.h>
#include<stdio.h>
int my_strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + my_strlen(str + 1);
}

void reverse_string(char arr[])
{
	int left = 0;
	int right = my_strlen(arr) - 1;
	while (left < right)
	{
		int temp = arr[left];
		arr[left] = arr[right];
		arr[right] = temp;
		left++;
		right--;
	}
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen("abcdef");
	reverse_string(arr);
	printf("%s\n", arr);
	return 0;
}

7.用递归和非递归求解斐波那契数列

//递归
#include<stdio.h>
int fib(int n)
{
	if (n == 0)
	{
		return 0;
	}
	if (n == 1)
	{
		return 1;
	}
	else
	{
		return fib(n - 1) + fib(n - 2);
	}
}
int main()
{
	int n = 0;
	int ret = 0;
	scanf("%d", &n);
	ret = fib(n);
	printf("%d", ret);
	return 0;
}

递归的改进版

int Fib(int first, int second, int n)
{
	if (n <= 2)
	{
		return n - 1;
	}
	else if (n == 3)
	{
		return first + second;
	}
	else
	{
		return Fib(second, first + second, n - 1);
	}

}
int main()
{
	int n;
	scanf("%d", &n);
	int ret = Fib(0, 1, n);
	printf("%d", ret);
	return 0;
}

//非递归
#include<stdio.h>
int main()
{
	int n = 0;
	(void)scanf("%d", &n);
	int a = 1;
	int b = 1;
	int c = 0;
	while (n >= 3)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	printf("%d", b);
	return 0;
}


//非递归
int Fib(int n)
{
	if (n == 1)
	{
		return 0;
	}
	if (n == 2)
	{
		return 1;
	}
	int f1 = 0;
	int f2 = 1;
	int c = 0;
	for (int i = 3; i <= n; i++)
	{
		c = f1 + f2;
		f1 = f2;
		f2 = c;
	}
	return c;
}
int main()
{
	int n;
	scanf("%d", &n);
	int ret = Fib(n);
	printf("%d", ret);
	return 0;
}

8.指针求字符串长度

#include<stdio.h>
int my_strlen(char* str)
{
	char* cp = str;
	while (*cp != '\0')
	{
		cp++;
	}
	return cp-str;
}
int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d", len);
	return 0;
}

9.输入一个数，求阶乘的和

#include<stdio.h>
int main()
{
	int i = 0;
	int j = 0;
	int n = 0;
	int ret = 1;
	int sum = 0;
	(void)scanf("%d", &n);
	for (i = 1; i <= n; i++)
	{
		ret = 1;
		for (j = 1; j <= i; j++)
		{
			ret = ret * j;
		}
	}
	sum = sum + ret;
	printf("%d", sum);
	return 0;
}

10.写一个函数返回参数二进制中1的个数(补码中的个数)

#include<stdio.h>
int count_one_bit(int n)
{
	int i = 0;
	int count = 0;
	for (i = 0; i < 32; i++)
	{
		if (((n >> i) & 1 )== 1)
		{
			count++;
		}
	}
	return count;
}
int main()
{
	int n = 0;
	int ret = 0;
	(void)scanf("%d", &n);
	ret = count_one_bit(n);
	printf("%d", ret);
	return 0;
}

11.获取一个二进制序列中的偶数位和奇数位，分别输出二进制序列

#include<stdio.h>
int main()
{
	int n = 0;
	(void)scanf("%d", &n);
	int i = 0;
	for (i = 31; i >= 1; i -= 2)
	{
		printf("%d", (n >> i) & 1);
	}
	printf("\n");
	for (i = 30; i >= 0; i -= 2)
	{
		printf("%d", (n >> i) & 1);
	}
}

12.输出一个整数的每一位

#include<stdio.h>
int print(int n)
{
	if (n > 9)
		print(n / 10);
	printf("%d ", n % 10);
	return n;
}
int main()
{
	int n = 0;
	(void)scanf("%d", &n);
	print(n);
	return 0;
}

13.位运算

/*
编程实现：
两个int（32位）整数m和n的二进制表达式中
有多少个为不同
思路：用异或，两个整数的32个比特位通过循环是可以得到的
然后通过异或，异或的规则是：相同为0，相异为1；
所以可以计算所有1的个数，就可以得出，两个数字有多少个比特位是不一样的了
*/
#include<stdio.h>
int count_one_bit(int n)
{
	int count = 0;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		if (((n >> i) & 1) == 1)
		{
			count++;
		}
	}
	return count;
}
int main()
{
	int m = 1999;
	int n = 2299;
	int temp = m ^ n;
	int ret = 0;
	ret = count_one_bit(temp);
	printf("%d", ret);
	return 0;
}

14.长文字类型题目

/*
五位运动员参加了10m台跳水比赛，有人让他们预测比赛结果
A选手说，B第二，我第三；
B选手说：我第二，E第四；
C选手说：我第一，D第二；
D选手说：C最后，我第三；
E选手说：我第四,A第一；
比赛结束后，每位选手都说对了一半，请编程确定比赛的名次
思路：
A-E都可能是第一名到第五名的一种，每个人都有可能
那么我就把所有的情况都罗列出来
看那种满足所有人都说对一半的情况
那么就把所有的情况都列举出来
*/
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	int c = 0;
	int d = 0;
	int e = 0;
	//列出所有可能的情况
	for (a = 1; a <= 5; a++)
	{
		for (b = 1; b <= 5; b++)
		{
			for (c = 1; c <= 5; c++)
			{
				for (d = 1; d <= 5; d++)
				{
					for (e = 1; e <= 5; e++)
					{
						//然后用代码表示每个人所说的话
						if (((b == 2) + (a == 3) == 1) &&
							((b == 2) + (e == 4) == 1) &&
							((c == 1) + (d == 2) == 1) &&
							((c == 5) + (d == 3) == 1) &&
							((e == 4) + (a == 1) == 1))
						{
							if (a * b * c * d * e == 120)
							{
								printf("a=%d b=%d c=%d d=%d e=%d\n", a, b, c, d, e);
							}
						}
					}
				}
			}
		}
	}
	return 0;
}

15.长文字类型题目

/*
日本某地发生一件谋杀案，警察通过排查确定杀人凶手
必为四个嫌犯中的一个，以下为四个嫌犯的供词：
A说：不是我
B说：是C；
C说：是D；
D说，C再胡说
已知现在三个人说的是真话，一个人说的是假话
现咋请根据这些信息，写一个程序来确定发到底谁是凶手
*/
#include<stdio.h>
int main()
{
	char killer = 0;
	for (killer = 'a'; killer < 'd'; killer++)
	{
		if ((killer != 'a') + (killer == 'c') + (killer == 'd') + (killer != 'd') == 3)
		{
			printf("killer = %c ", killer);
		}
	}
	return 0;
}

16.打印杨辉三角

17.36匹马，6个跑道，没有计时器，让这36匹马上跑道跑，确定以下前三名，最少跑多少次
最少要跑八次
在这里插入图片描述
18.判断是大端还是小端
大端：指数据的低位保存在内存的高地址中，而数据的高位保存在内存的低地址中
小端：指书库的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中

#include<stdio.h>
int main()
{
	int a = 1;
	char* p = (char*)&a;
	if (*p == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

#include<stdio.h>
int check_system()
{
	union Un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;//拿出了i四个字节中的第一个字节
}
int main()
{
	int ret = check_system();
	if (ret == 1)
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}
	return 0;
}

19.问输出结果是什么

#include<stdio.h>
int main()
{
	char a = -1;
	signed char b = -1;
	unsigned char c = -1;
	printf("%d %d %d", a, b, c);
	return 0;
}
打印结果为 -1 -1 255

20.在屏幕上打印杨辉三角

#include<stdio.h>
#define N 7
void YangHui(int a[N][N], int n);
void main()
{
	int i, j, n, b[N][N];
	printf("Input n:");
	(void)scanf("%d", &n);
	YangHui(b, n);
	for (i = 0; i < n; i++)
	{
		for (j = 0; j <= i; j++)
		{
			printf("%4d", b[i][j]);
		}
		printf("\n");
	}
}
void YangHui(int a[N][N], int n)
{
	int i, j;
	for (i = 0; i < n; i++)
	{
		a[i][0] = 1;
		a[i][i] = 1;
	}
	for (i = 2; i < n; i++)
	{
		for (j = 1; j < i; j++)
			a[i][j] = a[i - 1][j - 1] + a[i - 1][j];
	}
}

21.不使用（a+b)/2,求两个数的平均值

#include<stdio.h>
int main()
{
	int left = 0;
	int right = 0;
	(void)scanf("%d %d", &left, &right);
	printf("%d",left + (right - left) / 2);
	return 0;
}

22.数组指针

#include<stdio.h>
void print(int(*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (*p)[i]);
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(&arr, sz);
	return 0;
}

23.打印二维数组

#include<stdio.h>
void print(int arr[2][4], int x, int y)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < x; i++)
	{
		for (j = 0; j < y; j++)
		{
			printf("%d", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[2][4] = { 1,2,3,4,5,6,7,8 };
	print(arr, 2, 4);
	return 0;
}

24.数组笔试题

#include<stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%zd\n", sizeof(a));//16  a作为数组名，单独放在sizeof内部，表示的是整个数组，所以大小为4*4=16
	printf("%zd\n", sizeof(a + 0));//4  a+0，此时a代表数组首元素地址，首元素地址+0还是首元素的地址，是地址就是四个字节
	printf("%zd\n", sizeof(*a));//4  a是数组名，表示首元素的地址，*a就是解引用就是首元素，首元素是1，是整形，那么就是4个字节
	printf("%zd\n", sizeof(a + 1));//4  a+1和a+0道理是一样的，a+1就为下标为1的元素的地址，也就是第二个元素的地址
	printf("%zd\n", sizeof(a[1]));//4  下标为1的大小，第二个元素的大小
	printf("%zd\n", sizeof(&a));//4   这个地方的a代表真个数组 &a取出的就是整个数组的地址，那他也是地址，如果是地址的话，那么就是四个字节,所有的指针/地址都是4/8个字节，与平台是32位或者64位有关，与类型没有任何的关系
	printf("%zd\n", sizeof(*&a));  //16  &a取出整个数组的地址，然后解引用，得到了整个数组的大小，那么就是16，先取地址，再去解引用
	printf("%zd\n", sizeof(&a + 1));//4    把整个数组全部跳过
	printf("%zd\n", sizeof(&a[0]));//4  第一个元素的地址
	printf("%zd\n", sizeof(&a[0]+1));//4  下标为1元素的地址
	return 0;
}

字符数组

#include<stdio.h>
int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));//6  看数组的大小，数组中没有放置\0,就一定是6
	printf("%d\n", sizeof(arr+0));//4首元素的地址，只要是地址，那么就是四个字节
	printf("%d\n", sizeof(*arr));//1
	printf("%d\n", sizeof(arr[1]));//1
	printf("%d\n", sizeof(&arr));//4
	printf("%d\n", sizeof(&arr+1));//4
	printf("%d\n", sizeof(&arr[0])+1);//4
}

//#include<stdio.h>
//int main()
//{
	//求长度关注的是\0问题
	//strlen希望传递的是地址，参数是const char *
	//char arr[] = { 'a','b','c','d','e','f' };
	//printf("%d\n", strlen(arr));//随机值
	//printf("%d\n", strlen(arr+0));//随机值
	//printf("%d\n", strlen(*arr));//传进去的是字符a
	//printf("%d\n", strlen(arr[1]));
	//printf("%d\n", strlen(&arr));
	//printf("%d\n", strlen(&arr+1));
	//printf("%d\n", strlen(&arr[0]+1));
//}

#include<stdio.h>
int main()
{
	const char* p = "abcdef";
	printf("%zd\n", sizeof(p));//4
	printf("%zd\n", sizeof(p+1));//4
	printf("%zd\n", sizeof(*p));//1
	printf("%zd\n", sizeof(p[0]));//1
	printf("%zd\n", sizeof(&p));//4
	printf("%zd\n", sizeof(&p+1));//4
	printf("%zd\n", sizeof(&p[0]+1));//4
	return 0;
}

#include<stdio.h>
int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));//6
	printf("%d\n", strlen(arr+0));//6
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));//6
	printf("%d\n", strlen(&arr+1));
	printf("%d\n", strlen(&arr[0])+1);
	return 0;
}

#include<stdio.h>
int main()
{
	const char* p = "abcdef";
	printf("%zd\n", strlen(p));  //6
	printf("%zd\n", strlen(p + 1));   //5
	printf("%zd\n", strlen(*p));//error
	printf("%zd\n", strlen(p[0]));//error
	printf("%zd\n", strlen(&p));//随机值
	printf("%zd\n", strlen(&p + 1));//随机值
	printf("%zd\n", strlen(&p[0] + 1));//随机值
	return 0;
}

二维数组

#include<stdio.h>
int main()
{
	int a[3][4] = { 0 };
	printf("%zd\n", sizeof(a));  //48
	printf("%zd\n", sizeof(a[0][0])); //4
	printf("%zd\n", sizeof(a[0])); //16
	printf("%zd\n", sizeof(a[0]+1)); //4
	printf("%zd\n", sizeof(*a[0] + 1));// 4 第二个元素是整形，所以是4
	printf("%zd\n", sizeof(a+1)); //4  第二行的地址也是地址
	printf("%zd\n", sizeof(*(a+1)));//16 第二行的地址解引用，找到了第二行的元素，所以是16
	printf("%zd\n", sizeof(&a[0]+1)); //4 取出第一行的地址，加1，得到第二行的地址，与a+1相同
	printf("%zd\n", sizeof(*(&a[0] + 1)));  //16  第二行的地址进行解引用操作
	printf("%zd\n", sizeof(*a));//  16 首元素地址解引用，得到第一行元素 ，*a=a[0]
	printf("%zd\n", sizeof(a[3])); //16  只是算一下第四行的大小，与第一行道理是一样的，只是看一下大小而已，并没有非法访问空间
	return 0;
}

#include<stdio.h>
int main()
{
	int a[5] = { 1,2,3,4,5 };
	int* ptr = (int*)(&a + 1);
	printf("%d %d", *(a + 1), *(ptr - 1)); 
	return 0;
}
//打印的结果为2和5
（&a+1）得到整个数组的地址，+1跳过整个数组，来到五的后面，强制类型转换成int *，但是值并没有发生改变，所以*（ptr-1）得到的就是5的地址在解引用，那么就顺理成章的得到5了。

26.编写函数：
unsigned int reverse_bit(unsigned int value)
这个函数的返回值是value的二进制位模式从左到右
翻转后的值
如：
在32位机器上25这个值包含下列各位
00000000000000000000000000011001
翻转后：（2550136832）
10011000000000000000000000000000
程序结果返回 2550136832

/*
返回的应该是无符号的整形
写成unsigned int 因为不希望翻转后的最高位是符号位，希望他是有效位
所以写成unsigned int 类型的

思路：(n>>i)&1可以得到二进制位的每一位，然后再去乘以权重，也就是pow（2，31-i）
也就是相当于最后一位和第一位交换位置，就会得到最终的结果
*/
#include<stdio.h>
#include<math.h>
unsigned int reverse_bit(unsigned int n)
{
	unsigned int temp = 0;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		temp += ((n >> i) & 1) * pow(2, 31 - i);
	}
	return temp;
}
int main()
{
	unsigned int num = 0;
	unsigned int ret = 0;
	(void)scanf("%d", &num);
	ret = reverse_bit(num);
	printf("%u", ret);
	return 0;
}


//另一种方法：
#include<stdio.h>
#include<math.h>
unsigned int reverse_bit(unsigned int n)
{
	unsigned int temp = 0;
	int i = 0;
	for (i = 0; i < 32; i++)
	{
		temp += ((n >> i) & 1) * 1<<(31-i);
	}
	return temp;
}
int main()
{
	unsigned int num = 0;
	unsigned int ret = 0;
	(void)scanf("%d", &num);
	ret = reverse_bit(num);
	printf("%u", ret);
	return 0;
}

27.整个字符串的逆置

#include<stdio.h>
int my_strlen(char* str1)
{
	if (*str1 == '\0')
		return 0;
	else
	{
		return 1 + my_strlen(str1 + 1);
	}
}
void my_reverse(char* str)
{
	int i = 0;
	int len = my_strlen(str);
	for (i = 0; i < len / 2; i++)
	{
		char temp = str[i];
		str[i] = str[len - 1 - i];
		str[len - 1 - i] = temp;
	}
}
int main()
{
	char arr[] = "student a am i";
	printf("没有倒置过的字符串为%s", arr);
	my_reverse(arr);
	printf("\n");
	printf("倒置过的字符串为%s",arr);
	return 0;
}

整个字符串的逆置

#include<stdio.h>
int my_strlen(char* str1)
{
	char* temp = str1;
	while (*temp != '\0')
	{
		temp++;
	}
	return temp - str1;
}
void my_reverse(char* str)
{
	int i = 0;
	int len = my_strlen(str);
	for (i = 0; i < len / 2; i++)
	{
		char temp = str[i];
		str[i] = str[len - 1 - i];
		str[len - 1 - i] = temp;
	}
}
int main()
{
	char arr[] = "student a am i";
	printf("没有倒置过的字符串为%s", arr);
	my_reverse(arr);
	printf("\n");
	printf("倒置过的字符串为%s",arr);
	return 0;
}

通过指针实现字符串的逆置

#include<stdio.h>
int my_strlen(char* str)
{
	if (*str == '\0')
	{
		return 0;
	}
	else
	{
		return 1 + my_strlen(str + 1);
	}
}
void reverse(char* left, char* right)
{
	while (left < right)
	{
		char temp = *left;
		*left = *right;
		*right = temp;
		left++;
		right--;
	}
}
int main()
{
	char arr[] = "student a am i";
	int len = my_strlen(arr);
	reverse(arr,arr+len-1);
	printf("%s", arr);
	return 0;
}

调整数组使奇数全部位于偶数前面
题目：输入一个整数数组，实现一个函数
来调整该数组中数字的顺序使得数组中所有奇数
位于数组的前半部分，所有偶数位于数组的后半部分
思路：在左边找偶数，再右边找奇数
定义一个left，再定义一个right，如果找到了两个都符合要求的数，那就将他们交换
这样子，前面就都是奇数，后面就都是偶数了

#include<stdio.h>
int main()
{
	int i = 0;
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int left = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int right = sz - 1;
	while (left < right)
	{
		while ((left<right)&&arr[left] % 2 == 1)
		{
			left++;
		}
		while ((left < right) && arr[right] % 2 == 0)
		{
			right--;
		}
		if (left < right)
		{
			int temp = arr[left];
			arr[left] = arr[right];
			arr[right] = temp;
		}
		left++;
		right--;
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

杨氏矩阵
有一个二维数组
数组的每行从左到右是递增的，每列从上到下是递增的
在这样的数组中查找一个数字是否存在
时间复杂度小于O（N)------>（意思就是不能使用遍历的方法
使用遍历的方法的话时间复杂度就不能达到题目所给的要求）
思路：对角线方法—>比较一次,要么去掉一行，要么去掉一列

#include<stdio.h>
int Find(int arr[3][3], int row, int col, int k)
{
	int x = 0;
	int y = 2;
	while (x < row && &y>0)
	{
		if (arr[x][y] < k)
		{
			x--;
		}
		else if (arr[x][y] > k)
		{
			y--;
		}
		else    //刚好相等的情况
		{
			return 1;
		}
	}
	return 0;
}
int main()
{
	int arr[3][3];
	int ret = Find(arr, 3, 3, 7);
	if (ret == 1)
	{
		printf("找到了\n");
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

30.递归版本的斐波那契数列

long long fib(long long first, long long second, long long n)
{
	if (n < 3)
		return 1;
	if (n == 3)
	{
		return fib(second, first + second, n - 1);
	}
}

在这里插入图片描述
在这里插入图片描述

yyyyeahhhhhh
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言编程经典算法100例.doc
01-14
C语言编程经典算法100例
编译原理实验（二）—— 预测分析算法的设计与实现（C语言实现）
wowhhhgd的Blog
01-12 7210
大家好，下面介绍的是我当时上编译原理所做的实验，主要内容就是根据已有的文法，构造文法的first集和follow集，然后再根据构造好的first集和follow集构造预测分析表，最后，设置一个栈，然后利用栈和预测分析表来对输入串进行分析，判断输入串是否是该文法的一个合适的语法范畴。用的是最基本的C语言写的，如有不足，欢迎大家批评指正！ 一、实验目的 通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。 二、实验内容 输入文法及待分析的输入串，输出其预测分析过程及结
数值分析多种算法C语言代码－推荐
梓文阳光ZOOM（Target工作室）
12-17 3706
1、离散傅立叶变换与反变换/************************************************************************ * 离散傅立叶变换与反变换 * 输入: x--要变换的数据的实部 * y--要变换的数据的虚部 *       a--变换结果的实部 *       b--变换结果的虚部 *       n--数据长度 *    sign
用C语言写一个预测算法的程序
weixin_35749545的博客
02-13 107
如果你想让喜欢的女孩知道你喜欢她，你可以考虑直接告诉她。这可能会有点恐怖，但是这是最直接的方法。当然，也有其他的选择。你可以通过你的行为和语言来向她表明你的感情。例如，你可以多参加她参加的活动，和她聊天时多关注她的感受和兴趣，并且经常给她送小礼物或者关心她的状态。这些都可以让她察觉到你的关心和喜欢。另外，你也可以借机向共同的朋友或者家人表达你的喜欢，让他们帮助你传达信息。总之，重要的是要坦诚相待，...
while（N--）解析
qq_45858803的博客
11-16 1731
while（） # include<stdio.h> int main() { int N; scanf("%d",&N); while(N--) { printf("%d ",N); } return 0; } # include<stdio.h> int main() { int N; scanf("%d",&N); N=N+1; while(N--) { printf("%d ",N); } return 0; } 由上
卡尔曼滤波算法及C语言实现
小凡的专栏
03-29 5万+
kalman filter最为核心的内容是体现它最优化估计和递归特点的5条公式。 下面利用C语言编程实现Kalman Filter Algorithm，代码如下： #include "stdio.h" #include "stdlib.h" #include "math.h" double frand() { return 2 * ((rand() / (double)RAND_MAX)
C语言实训——算法与编程实验
05-31
信息安全C语言实训，统计字母的使用频率、进制转换、四则远算、开头字母大小写、数位排序。算法与编程实验。
常用编程算法及C语言实例
09-23
介绍１２种常用编程算法冒泡排序、选择排序、插入排序、快速排序、二分法、深度优先搜索、广度优先搜索、递归算法、哈希算法等等，以及C语言实例。
C语言编程：掌握冒泡排序算法.txt
最新发布
02-28
冒泡法排序c语言程序
AES-CMAC c语言实现编程
04-14
亲测好用
决策树预测天气c语言操作方法,基于ID3算法的决策树研究与天气预测实现
weixin_29081163的博客
05-25 2756
目录一、初识决策树二、理论基础三、ID3算法四、问题实现五、运行结果分析六、References一、初识决策树决策树( Decision Tree )又称为判定树，是对数据进行分类的一种树结构，并通过分类达到预测的目的。决策树分为分类树和回归树两种，分类树是对离散变量做决策树，回归树是对连续变量做决策树。构造决策树是采用自上而下的递归构造方法。决策树构造的结果是一棵二叉或多叉树，它的输入是一组带有...
卡尔曼(Kalman)滤波算法原理、C语言实现及实际应用
热门推荐
Beyonderwei的博客
05-17 7万+
文章目录卡尔曼滤波一、滤波效果展示二、简介三、组成1. 预测状态方程（1）目的：（2）方程：（3）备注2. 预测协方差方程（1）目的（2）方程（3）备注3. 卡尔曼增益方程（1）目的（2）方程（3）备注4. 跟新最优值方程（卡尔曼滤波的输出）（1）目的（2）方程（3）备注5. 更新协方差方程（1）目的（2）方程（3）备注四、C 程序代码实现1. 参数列表2. 代码实现（一维数据滤波）五、发送波形到...
用c语言实现EM算法,EM算法
weixin_39598568的博客
05-24 296
缘起最近室友都找实习。面试时，常被问到的是，一些基础的机器学习知识和最新的深度学习模型，比如 逻辑回归、正则项、f1的计算、类别不平衡的处理、LSTM、Attention、Transformer、word2vec、glove、ELMo、BERT等等。因此，我打算系统地、扎实地将这些知识学习一遍，同时将学习的笔记写成博客，以供自己以后查看。如果不幸帮助了别人，还可以收获一些虚荣:-)。对吧~万事开头...
【算法】数组常见算法
weixin_52811588的博客
08-29 606
数组的常见算法，使用C语言实现了移除元素，删除有序数组中的重复项，合并有序数组，旋转数组，供大家参考
目标检测算法C语言,【目标检测 深度学习】3.Yolo系列算法原理
weixin_28871743的博客
05-24 1081
1.YoloV11.1综述同时预测多个box位置和类别端到端的目标检测和识别速度更快实现回归功能的CNN并不需要复杂的设计过程hijack选用整图训练模型，更好地区分目标和背景区域1.2算法原理 图像被分成S×S个格子，对于每一个格子包含GT物体中心的格子负责检测相应的物体，如上图狗所在中心落在某一个格子上，则这个格子负责预测狗。每个格子预测B(超参数)个检测框及其置信度(x,y,w,h,c)，以...
【人工智能】利用C语言实现KNN算法进行手写数字识别
RToax
05-14 9357
KNN算法称为邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属...
算术编码压缩算法c语言实现,[牛羚的压缩算法tutorial]-[chapter-2]-概率预测模型与算术编码器...
weixin_39656435的博客
05-20 122
该楼层疑似违规已被系统折叠隐藏此楼查看此楼这里给出具体的区间变换公式(假设原区间为a..b，0和1的概率分别为p和1-p)：左边区间：a..[(b-a)*p]右边区间：[(b-a)*p+1]..b使用这两个公式替换掉上面代码中的等分区间部分，就得到了算术编码的算法，下面我们给出一个完整的算术编码的源代码，里面世包含了一个上下文长度为3字节的0-1概率预测模型：(为了代码编...
用c语言实现感知器算法,python实现感知器算法（批处理）
weixin_28867883的博客
05-23 268
本文实例为大家分享了Python感知器算法实现的具体代码，供大家参考，具体内容如下先创建感知器类：用于二分类# -*- coding: utf-8 -*-import numpy as npclass Perceptron(object):"""感知器：用于二分类参照改写 https://blog.csdn.net/simple_the_best/article/details/54619495属...
模型预测控制的缺点_模型预测控制MPC的通俗解释
weixin_39988677的博客
11-22 4315
模型预测控制(Model Predictive Control，MPC)是在满足特定限制条件的前提下，控制过程的一种控制方式。若是针对简单系统的控制，多半不需要用到复杂的MPC算法，使用PID控制器即可，如下图所示；当系统有较大的响应延迟或是高阶系统时，其控制特性会复杂到超过PID控制器可控制的程度，而MPC的模型恰恰是用来呈现复杂系统的特性。PID控制器PID控制介绍：比例、积分、微分为避免在刚...
c语言编程dijkstra算法
12-12
以下是使用C语言实现Dijkstra算法的代码，其中邻接矩阵存储了图中各个节点之间的距离，n为节点数： ```c #include #include #define INF 0Xfffffff void dijkstra(int n, int e[][100], int start, int dis[], ...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值