qq_45973003

C语言题目逻辑实战总结

eg1:

已知有1,2,3,4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少
已知：1：三位数，2:1-4,3：各不相同，
输出：1：有多少个这样的三位数，2：依次输出
解题代码和思路

#include
#include 
#include 
#include 

/*
   question1： 已知有1,2,3,4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少
   已知：1：三位数 ，2:1-4,3：各不相同，
   输出：1：有多少个这样的三位数，2：依次输出

   思路：使用代码的方式将我们的代码表示出来
   解题的思路： 获取百位数，10位数，和个位数
   int a = 123; 获取百位数a/100 , 获取10位数a%100/10得到10位数

   1:一个采用分别表示的方法表示这三个数
   int b*100 + s*10 + g
   2: 使用循环的方式进行遍历 for循环，while循环，do while循环
   for(g = 1; g < 5; g++){
      
   }
*/
int main()
{
	int b, s, g;
	// 统计输出了多少个这样的三位数使用计数的方式进行统计，注意加法变量的初始化往往是从0开始的
	int count = 0;
	// 使用嵌套循环的方式进行遍历
	for (b = 1; b < 5; b++) {
		for (s = 1; s < 5; s++) {
			for (g = 1; g < 5; g++) {
				// 使用if语句进行判断，要求三个数都不相等输出三个数
				if (g != s && s != b && g != b ) {
					printf("%d,%d,%d\n", b, s, g);
					// 输出一次统计一次
					count++;
				}
			
			 

			}
		}
	}
	// 在所有的循环条件遍历玩的情况下输出统计的数值
	printf("count = %d\n", count);
	 
	return 0;

}

- [ ] eg2: 求取利润

题目：企业发放的奖金根据利润提成
#利润（I）低于或等于10万元时，奖金提成10%
#利润高于10万元，低于20万时，低于10万的部分按10%提成，高于10万部分可提成百分之7.5
#20万到40万之间时，高于20万元的部分，可提成百分之3
#60万到100万之间时，高于60万元部分按百分之1提成
从键盘输入当月利润I求应该发放的奖金总数

解题思路的代码
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include

eg2: 求取利润
题目：企业发放的奖金根据利润提成
#利润（I）低于或等于10万元时，奖金提成10%
#利润高于10万元，低于20万时，低于10万的部分按10%提成，高于10万部分可提成百分之7.5
#20万到40万之间时，高于20万元的部分，可提成百分之3
#60万到100万之间时，高于60万元部分按百分之1提成
从键盘输入当月利润I求应该发放的奖金总数

  使用if else的进行处理
  int a = 10;
  int b = 20;
  if (a > b) {
  	printf("a>b\n");
  }
  else if(a < b){
  	printf("a<=b\n");
  }
  else {
  	printf("a = b\n");
  }
  */

int main() {
	int profit = 0;
	int bonus = 0;
	int bonus1 = 100000 * 0.1;
	int bonus2 = 100000 * 0.1 + 100000 * 0.075;
	int bonus3 = 100000 * 0.1 + 100000 * 0.075 + 200000 * 0.05;
	int bonus4 = 100000 * 0.1 + 100000 * 0.075 + 200000 * 0.05 + 200000 * 0.03;
	int bonus5 = 100000 * 0.1 + 100000 * 0.075 + 200000 * 0.05 + 200000 * 0.03 +
		400000 * 0.015;
	//获取用户键盘输入
	printf("请输入当前业务利润：");
	scanf("%d:", &profit);
	// #利润（I）低于或等于10万元时，奖金提成10%
	if (profit <= 100000) {
		bonus = profit * 0.1;
	}
	else if (profit <= 200000) {
		bonus = bonus1 + (profit-100000) * 0.075;
	}
	else if (profit <= 400000) {
		bonus = bonus2 + (profit - 200000) * 0.05;
	}
	else if (profit <= 600000) {
		bonus = bonus3 + (profit - 400000) * 0.03;
	}
	else if (profit <= 1000000) {
		bonus = bonus4+ (profit - 600000) * 0.015;
	}
	else {
		bonus = bonus5 + (profit - 1000000) * 0.01;
	}
	printf("你获得的奖金为 = %d\n", bonus);
	return 0;
}

eg3：一个整数，他加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
解题思路代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
	eg3： 一个整数，他加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
	表示的意思是 
	x + 100 = n ^2; x + 100 + 168 = m^2;  ----------> x
	根据题目的意思：因为x可以推导数n 和 m 所以将x消去然后使用n 和 m  进行取值
	如: n ^2 - 100 = m ^2 - 268;m^2 - n ^2 = 168; (m + n) - (m - n) = 168; m + n = i; m - n = j ; i - j = 168;   
	2 <= i*j <= 168 / 2
*/

int main() {
	int j, n, m, x;
	for (int i = 2; i <= 168 / 2; i++) {
		if (168 % i == 0) {
			 j = 168 / i;
			 m = (i + j) / 2;
			 n = (i - j) / 2;
			 x = n * n - 100;
		}
	}
	printf("x = %d", x);


	return 0;

}

eg4: 输入某年某月某日，判断这一天是这一年的第几天
解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
   eg4: 输入某年某月某日，判断这一天是这一年的第几天
*/

int main() {
    // 获取用户键盘输入
	int day, month, year;
	int sum = 0;
	int leap = 0;
	printf("请输入当前的年月和日:");
	scanf("%d,%d,%d", &year, &month, &day);
	printf("year = %d , month = %d, day = %d\n", year, month, day);
	// 明显循环带选择的往往使用switch语句进行处理，根据某一个变量判断可取的值但是值也有限优先考虑switch语句
	

	switch (month) {
	case 1:
		printf("一月份\n");
		sum = 0; 
		break;
	case 2:
		printf("二月份\n"); 
		sum = 31;
		break;
	case 3:
		printf("三月份\n"); sum = 58; break;
	case 4:
		printf("四月份\n"); sum = 90; break;
	case 5:
		printf("五月份\n"); sum = 120; break;
	case 6:
		printf("六月份\n"); sum = 150;break;
	case 7:
		printf("七月份\n"); sum = 180; break;
	case 8:
		printf("八月份\n"); sum = 210; break;
	case 9:
		printf("九月份\n"); sum = 240; break;
	case 10:
		printf("十月份\n"); sum = 270; break;
	case 11:
		printf("十一月份\n"); sum = 300; break;
	case 12:
		printf("十二月份\n"); sum = 330; break;
	}
	// 判断是平年还是润年的代码
	if (year % 400 || (year % 4 == 0 && year % 100 != 0)) {
		leap = 1;
	}
	else {
		leap = 0;
	}
	if (leap == 1 && month > 2) {
		sum++;
	}
	sum = sum + day;
	printf("总天数是%d\n", sum);
	return 0;

}

eg5: 输入三个整数想，x,y,z，把这三个数从小到大输出
解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
   eg5: 输入三个整数想，x,y,z，把这三个数从小到大输出
   这个类型的题目还可以用冒泡排序进行处理
*/

int main() {
    // 先找出最小的数然后进行比较
	int a = 15;
	int b = 20;
	int c = 8;
	int sum = a + b + c;
	int min, max, middle;
	//printf("%d\n", a < b ? a : b);
	min = (a < b ? a : b) < c ? (a < b ? a : b) : c;
	max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
	middle = sum - (min + max);
	printf("Smallest %d\n", min);
	printf("Max %d\n", max);
	printf("Middle %d\n", middle);
	return 0;
}

eg6：使用*输出一个字母c
解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  eg6： 使用*输出一个字母c,注意要输出带弧度的图案可以使用二维数组进行输出
*/

int main() {
	int m = 5;
	for (int i = 0; i < 5; i++) {
		printf("*");
	}
	printf("\n");
	for (int i = 0; i < m - 1; i++) {
		printf("*\n");
	}
	for (int i = 0; i < 5; i++) {
		printf("*");
	}
	printf("\n");
	return 0;
}

eg7：输出99乘法表

解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  eg7：输出一个9*9的乘法口诀表
*/

int main() {
	int i = 0;
	int j = 0;

	for (i = 0; i < 9; i++) { // i表示输出的是第几行
		for (j = 0; j < i+ 1; j++) { // j表示第几行中输出的数
			printf("%d * %d = %-2d  ", i, j, i * j);
		}
		printf("\n");
	}
	
	return 0;

}

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  eg7：输出一个9*9的乘法口诀表
*/

int main() {
	int i = 10;
	int j = 0;

	for (i = 1; i <= 9; i++) { // i表示输出的是第几行
		for (j = 1;j <= i; j++) { // j表示第几行中输出的数
			printf("%d*%d=%-2d  ", i, j, i * j);
		}
		printf("\n");
	}
	
	return 0;

}

eg8：斐波那楔数列古典问题（兔子生崽）：
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？（输出前40个月即可）
程序分析：兔子的规律为数列1, 1, 2, 3, 5, 8, 13, 21…，即下个月是上两个月之和（从第三个月开始）。

解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
   eg8：斐波那楔数列古典问题（兔子生崽）：
   有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔
   子，假如兔子都不死，问每个月的兔子总数为多少？（输出前40个月即可）
   程序分析：兔子的规律为数列1, 1, 2, 3, 5, 8, 13, 21....，即下个月是上两个月之和（从第三个月开始）。

   数学模型 ----> 程序
*/

int main() {
	int a = 1;
	int b = 1;
	for (int i = 1; i <= 10; i++) {
		 a = a + b;
		 b = b + a;
		printf("%d,%d", a, b);
	}



	return 0;
}

eg9:判断101-200之间的素数
1：质数，素数
大于1的整数中，只能被1和这个数本身整除的数
2：如何判断是否是素数
3：一次枚举出每个数
解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
    eg9:判断101-200之间的素数
	1：质数，素数
		大于1的整数中，只能被1和这个数本身整除的数
	2：如何判断是否是素数
	3：一次枚举出每个数
*/
// 函数的定义
int isPrimeNumber(int m) {
	int i;
	// 计算一个数的平方使用函数sqrt()使用sqrt需要使用math.h的包
	int k = (int)sqrt((double)m);
	for (i = 2; i <= k; i++) {
		// 判断是否能够整除，如果可以整除的话说明不是素数，切断break跳出
		if (m % i == 0) {
			break;
		}
	}
	if (i > k) {
		return 1;
	//printf("%d,是素数", m);
	}
	else {
		return 0;
		// 到这一步break被执行，说明不是素数； i < m;
	//	printf("%d,不是素数", m);
	}
}
int main() {
	// 函数的声明
	int isPrimeNumber(int m);
	int j;
	// for循环进行判断遍历循环101-200之间的数
	for (j = 101; j <= 200; j++) {
		if (isPrimeNumber(j)) {
			printf("%d  ", j);
		}
	

	}
	return 0;

}

eg10：题目 -> 打印水仙花数：打印出所有的水仙花数，所谓的水仙花数是指一个三位数，其各位数字立方和等于该数本身例如：153是一个水仙花数，因为153 = 1的三次方 + 5 的三次方 + 3的三次方

解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  题目 -> 打印水仙花数：打印出所有的水仙花数，所谓的水仙花数是指一个三位数，其各位数字立方和等于该数本身
  例如：153是一个水仙花数，因为153 = 1的三次方 + 5 的三次方 + 3的三次方
*/
int main() {
	// 分别表示个位，10位，和百位的数
	int x = 0, y = 0, z = 0;
	int i;
	// 将三位数的每一个位取出来
	for (i = 100; i <= 999; i++) {
		x = i % 10;// 获取位个数
		y = i / 10 % 10; // 获取十位数
		z = i / 100 % 10; // 获取百位数
		// 使用if进行判断
		if (i == (x * x * x + y * y * y + z * z * z)) {
			printf("%d 是水仙花数\n",i);
		}
	}
	return 0;
}

eg11: 题目：将正数分解为质因数，例如：输入90，打印出90 = 2 * 3 * 3 * 5
程序分析：对n进行分解质因数，应该先找到一个最小的质因数K然后按照以下的步骤完成
1：如果这个是质数恰巧等于(小于的时候，继续执行循环)n，则说明分解质因数的过程已经结束另外打印出即可
2：但n能被k整除，则打印输出k的值，并用n除以k的商，作为新的正整数n，重复执行第二步
3：如果n不能被k整除，则用k+1作为k的值，重复执行第一步
解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  题目：将正数分解为质因数，例如：输入90，打印出90 = 2 * 3 * 3 * 5
  程序分析：对n进行分解质因数，应该先找到一个最小的质因数K然后按照以下的步骤完成
  1：如果这个是质数恰巧等于(小于的时候，继续执行循环)n，则说明分解质因数的过程已经结束另外打印出即可
  2：但n能被k整除，则打印输出k的值，并用n除以k的商，作为新的正整数n，重复执行第二步
  3：如果n不能被k整除，则用k+1作为k的值，重复执行第一步
*/
int main() {
    int m = 90;
    int i;
    for (i = 2; i <= m; i++) {
        while (m % i == 0) {
            printf("%d ", i);
            m = m / i;
        }
    }
    return 0;
}

eg12: 题目：利用条件运算符来嵌套完成此题，学习成绩>= 90分的同学用A表示，60-89分的同学用B表示，60分以下的同学用C表示程序分析：(a>b)?a:b 这是条件运输符的基本例子。

解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
       题目：利用条件运算符来嵌套完成此题，学习成绩>= 90分的同学用A表示，60-89分的同学用B表示，60分以下的同学用C表示
       程序分析：(a>b)?a:b 这是条件运输符的基本例子。
*/
int main() {
    int score = 50;
    char grade;
    grade = (score >= 90) ? 'A' : ((score >= 60) ? 'B' : 'C');
    printf("grade = % c\n", grade);
    return 0;
}

**eg13:题目：输入两个正整数m和n，求取其最大的公约数和最小公倍数
1: 最小公倍数：两个数的积 / 最大公约数
2: 求最大公约数用辗转相除法(有名欧几里得算法)

例如需要求1997 和 615两个正整数的最大公约数，用欧几里得算法，是这样进行的
1997/615 =3(余152)
615 / 152 =4(余7)
152 / 7 = 21 (余5)
7 / 5 = 1 (余2)
5 / 2 = 2 (余1)
2 /1 = 2 (余0)
至此，最大公约数为1
以除数和余数反复的做除法运算，当余数为0时，取当前算式除数位最大公约数，所以得出1997和615的最大公约数为1**

解题思路和代码

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
      题目：输入两个正整数m和n，求取其最大的公约数和最小公倍数 
      1: 最小公倍数：两个数的积 / 最大公约数
      2: 求最大公约数用辗转相除法(有名欧几里得算法)

      例如需要求1997 和 615两个正整数的最大公约数，用欧几里得算法，是这样进行的
      1997/615 =3(余152)
      615 / 152 =4(余7)
      152 / 7 = 21 (余5)
      7 / 5 = 1 (余2)
      5 / 2 = 2 (余1)
      2 /1 = 2 (余0)
      至此，最大公约数为1
      以除数和余数反复的做除法运算，当余数为0时，取当前算式除数位最大公约数，所以得出1997和615的最大公约数为1

*/
int main() {
    int a = 885;
    int b = 615;
    int r;

    r = a % b;
    
    while (r != 0) {
        a = b;
        b = r;
        r = a % b;
    }
    printf("所以最大公约数是：%d\n", b);
    return 0;

}

eg14：输入一行字符，分别统计出其中的英文字母，空格，数字，和其他字符的个数
解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  eg14：输入一行字符，分别统计出其中的英文字母，空格，数字，和其他字符的个数
  通过字符和ascill码的方式统计字符的值和个数

*/
int main() {
    char c;
    int letter = 0;
    int number = 0;
    int space  = 0;
    int others = 0;
    // 使用getchar函数获取字符的个数
    c = getchar();
    // 当输入没有回车的时候就不结束，为回车的时候就判断个数
    while (c != '\n') {
        //使用if语句判断字符并且统计字符的个数
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
            letter++;
        }
        else if (c >= '0' && c <= '9') {
            number++;
        }
        else if (c == ' ') {
            space++;
        }
        else {
            others++;
        }
        c = getchar();
    }

    printf("字母 = %d, 数字 = %d，空格 = %d ,其他 = %d ", letter, number, space, others);
    return 0;
}

eg15：求s = a+ aa + aaa + aaaa+ …a的值其中a是一个数字，几个数的相加由键盘控制

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  eg15：求s = a+ aa + aaa + aaaa+ .....a的值
  其中a是一个数字，几个数的相加由键盘控制

*/
int main() {
    // 如何控制 ， 如何求S
    int n = 1;
    int a = 2;
    // 使用中间变量保证这个2是永远不变的
    int t = a;
    int sum = 0;
    while (n <= 5) {
        a *= 20;
        a += t;
        printf("a = %d\n", a);
        sum += a;
        n++;
    }
    printf("sum = %d\n", sum);
    return 0;
}

eg16：一个数刚好等于他的因子之和，这个数就称之为完数例如 6 = 1 + 2 +3 ，编程找出1000以内的所有完数

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
  eg16：一个数刚好等于他的因子之和，这个数就称之为完数
  例如 6 = 1 + 2 +3 ，编程找出1000以内的所有完数

*/
// 使用函数的方式判读是不是完数,返回值得类型是int，参数的类型也是int
int compNum(int m) {
    int n;
    int sum = 0;
    for (n = 1; n < m; n++) {
        if (m % n  == 0) {
            sum += n;
        }
        else {
            ;
        }
    }
    if (m == sum) {
        return 1;
       // printf("是完数\n");
    }
    else {
        return 0;
        // printf("不是完数\n");
    }
}

int main() {
    /*
      将一个大问题拆解为一个个小的问题
      1：如何判断一个数是不是完数
      2：使用循环遍历1-1000内的完数
      3：输出完数
    */
    int compNum(int m);
    int s = 6;
    for (s = 1; s <= 1000; s++) {
        if (compNum(s)) {
            printf("%d\n",s);
        }
        else {
            //printf("不是完数\n");
        }
    }

    return 0;

}

eg17:一个求从100米的高度自由落下每次落下后反跳回原高度的一半，再落下求他在第10次落地时，共经过多少米，第10次反弹多高

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
eg17:一个求从100米的高度自由落下每次落下后反跳回原高度的一半，再落下求他在第10次落地时，共经过多少米，第10次反弹多高

*/
int main() {
    /*
       解题思路：1：第一次小球落下是反弹的高度数h = 100；
       路程s = 100；
       然后没一次的弹起和落下都比上一次小一半
       s = s + h/2;
       h = h /2;
    */
    float h = 100;
    float s = 100;
    h = h / 2;
    int i;
    for (i = 2; i <= 10; i++) {
        s = s + h * 2;
        h = h / 2;
    }
    printf("s = %f,h = %f\n", s, h);

    return 0;

}

eg18:猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃掉一般，还不够，又多吃了一个
第二天早上又将剩下的桃子吃了一般，又多吃了一个，以后每天的早上都吃掉前一天剩下的一半零一个
到第10天早上再想吃时，只剩下一个桃子了
求第一天一共摘了多少

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
eg18:猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃掉一般，还不够，又多吃了一个
第二天早上又将剩下的桃子吃了一般，又多吃了一个，以后每天的早上都吃掉前一天剩下的一半零一个
到第10天早上再想吃时，只剩下一个桃子了
求第一天一共摘了多少
*/
int main() {
    /*
       循环：for循环和while循环，一般有明确的开始和结束值得时候多使用for循环，while训话某一个值得时候使用while循环
       将题目表达的意思转换为数学模型，使用数学表达式的方式表示出来，题目的求解过程是从已知推导出未知
       x10 = 1；
       x9 = (x10 + 1)*2
       x8 = (x9 + 1)*2 
       ......
     */
    int day;
    int y = 0;
    int x = 1;
    for (day = 9; day >= 1; day--) {
        y = (x + 1) * 2;
        x = y;
    }
    printf("y = %d\n", y);

    return 0;

}

eg19：打印出一个菱形图案

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
eg19:打印出一个菱形
*/
int main() {

    // 打印图形需要两个变量，二维的图形需要两个变量完成打印
    int i;
    int j;
    int k;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 3 - i + 1; j++) {
            printf(" ");
        }
        for (k = 0; k < 2 * i + 1; k++) {
            printf("*");
        }
    
        printf("\n");
    }
    
    return 0;

}

eg20：有一组分数序列：2/1,3/2,5/3,8/5,13/8,21/13…求出这个数列的前二十项之和，程序分析：抓住分子和分母的变化规律

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
eg20：有一组分数序列：2/1,3/2,5/3,8/5,13/8,21/13....求出这个数列的前二十项之和，程序分析：抓住分子和分母的变化规律
*/
int main() {

    int i;
    float sum = 0;
    float a = 2, b = 1;
    float t;
    for (i = 0; i < 20;i++) {
        sum += a / b;
        t = a;
        a = a + b;
        b = t;
    }
    printf("sum =  %.2f\n", sum);
    return 0;

}

- [ ] eg21：利用递归的方法，一个函数在它的函数内调用它自身的称为递归调用，这种函数被称为递归函数

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
eg21：利用递归的方法，一个函数在它的函数内调用它自身的称为递归调用，这种函数被称为递归函数
*/
//递归函数
int f(int n) {
    if (n == 1) {
        return 1;
    }
    else {
        return n * f(n - 1);
    }
    return f(n);
}

int main() {
    // 函数的声明
    int f(int n);
    int m = 5;
    printf("5! = %d\n", f(m));
    return 0;
}

eg22：利用函数递归调用的方式，将输入的5个字符以相反的方式打印输出

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
eg22：利用函数递归调用的方式，将输入的5个字符以相反的方式打印输出
*/
//递归函数
void f(int n) {
    // 如果当前的条件成立的话就输出...递归函数的流程就是先判断函数什么时候结束然后在判断不结束的时候的执行
    char c;
    if (n == 1) {
        c = getchar();
        putchar(c);
    }
    else {
        c = getchar();
        f(n - 1);
        putchar(c);
    }
}

int main() {
    void f(int n);
    f(5);
    return 0;
}

eg23：有5个人坐在一起，问第五个人多少岁，他说比第四个大2岁
问第四个人的岁数，他说比第三个人大2岁
问第3个人的岁数，他说比第2个人大2岁
问第二个人他说比第一个人大两岁，问最后一个人他说是10岁
请问第五个人多大
程序分析：使用递归的方法，递归分为回推和递推两个阶段，要想知道低5个人岁数，需要知道第四个人的岁数，依次类推推到第一个人10，再往回推

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
    eg23：有5个人坐在一起，问第五个人多少岁，他说比第四个大2岁
    问第四个人的岁数，他说比第三个人大2岁
    问第3个人的岁数，他说比第2个人大2岁
    问第二个人他说比第一个人大两岁，问最后一个人他说是10岁
    请问第五个人多大
    程序分析：使用递归的方法，递归分为回推和递推两个阶段，要想知道低5个人岁数，需要知道第四个人的岁数，依次类推推到第一个人10，再往回推
*/
// 函数的创建
int age(int n) {
    int c = 0;
    if (n == 1) {
        c = 10;
        printf("c = %d\n", c);
    }
    else {
        c = age(n - 1) + 2;
        printf("c = %d\n", c);

    }
    return c;

}
int main() {
    int age(int n);
    printf("age(5) = %d\n ", age(5));
    return 0;
}

- [ ] eg24：给一个不多于5位的正整数，要求，求它是几位数，逆序打印出各位数字
解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
    - [ ] eg24：给一个不多于3位的正整数，要求，求它是几位数，逆序打印出各位数字
*/

int main() {
    // 求出个位，10位和百位的数
    int number = 123;
    int ge, shi, bai;
    bai = number / 100;
    printf("bai = %d\n", bai);
    shi = number % 100 / 10;
    printf("shi = %d\n", shi);
    ge = number % 100 % 10;
    printf("ge = %d\n", ge);
    if (bai != 0) {
        printf("是个三位数");
        printf("%d %d %d\n", ge, shi, bai);
    }
    else if (shi != 0) {
        printf("是一个两位数");
        printf("%d %d\n", ge, shi);
    }
    else if (ge != 0) {
        printf("是个个位数");
        printf("%d\n", ge);
    }
    return 0;
}

eg25：判断一个数是不是回文数

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
   题目：一个五位数，判断是不是回文数，即12321是回文数，个位和万位相同，10位和千位相同
*/

int main() {
    int number = 12345;
    scanf("%d",&number);
    printf("number = %d\n", number);
    //获取五位数
    int wan, qian, shi, ge;
    wan = number / 10000;
    qian = number % 10000 / 1000;
    shi = (number / 10) % 10;
    ge = number % 10;
    if (ge == wan && shi == qian) {
        printf("这是回文数");
    }
    else {
        printf("这不是回文数");
    }
    return 0;
}
```![在这里插入图片描述](https://img-blog.csdnimg.cn/5c2a0b44d9f84d71a1bb6086ba8e8b81.png)**eg26：   题目：请输入星期几的第一个字母来判断是星期几，如果第一个字母一样，则继续判断第二个字母 程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或者if语句判断第二个字母
 monday,tuesday,wednesday,thursday,friday,saturday,sunday**

```cpp
#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 

/*
   题目：请输入星期几的第一个字母来判断是星期几，如果第一个字母一样，则继续判断第二个字母
   程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或者if语句判断第二个字母
   monday,tuesday,wednesday,thursday,friday,saturday,sunday
*/

int main() {
	char c;
	char j;
	c = getchar();
    // 注意这里的getchar是用来吃掉上面的回车的相当于是一个缓冲，不然会报错
	getchar();
	switch (c) {
		case 'm':
			printf("monday\n");
		case 'w':
			printf("wednesday\n");
		case 't':
			printf("please input another letter\n");
			j = getchar();
			if (j == 'u') {
				printf("tuesday\n");
			}if (j == 'h') {
				printf("thurday\n");
			}
			break;
		default:
			break;
	}

}

eg27：题目：删除一个字符串中的指定字母比如字符串 “aca 删除其中的字母a” 可以思考使用指针对其进行遍历

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：删除一个字符串中的指定字母比如字符串 “aca 删除其中的字母a”
   可以思考使用指针对其进行遍历
*/

int main() {
	// 初始化字符串
	char str[] = "sifosijfjkpfjfaphnjdsndjffffedf";
	printf("%s\n", str);
	char s = 'e';
	printf("%c\n", s);
	// 使用for循环遍历字符串数组
	for (int i = 0; i < strlen(str); i++) {
		if (str[i] == s) {
			for (int j = i; j < strlen(str); j++) {
				// 向前移动
				str[j] = str[j + 1];
			}
		}
		

	}
	printf("%s\n", str);
	return 0;

}

eg28：题目：判断一个数是否是质数程序分析：质数，又称素数，有无限个，一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：判断一个数是否是质数
   程序分析：质数，又称素数，有无限个，一个大于1的自然数，除了1和它本身外，不能被其他自然数整除
*/
int isPrime(int m) {
	if (m <= 0) {
		return 0;
	}
	if (m == 1) {
		return 0;
	}
	if (m == 2) {
		return 0;
	}
	for (int i = 3; i < (int)sqrt((double)m); i ++) {
		if (m % i == 0) {
			return  0;
		}

	}
	return 1;

}
int main() {
	int isPrime(int m);
	int n = 13;
	//printf("%d\n", (int)sqrt((double)n));
	printf("%d\n",isPrime(n));
	return 0;
}

eg29:题目：字符串反转，如将字符串“I LIKE KOBE”反转为 “EBOK EKIL I”

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：字符串反转，如将字符串“I LIKE KOBE”反转为 “EBOK EKIL I”
*/

int main() {
	char s[] = "I LIKE KOBE";
	int len = 0;
	len = strlen(s);
	printf("%d\n", len);
	int i;
	char temp;
	for (i = 0; i < len / 2; i++) {
		temp = s[i];
		s[i] = s[len - 1 - i];
		s[len - 1 - i] = temp;
	}
	printf("%s\n", s);
	return 0;
}

使用指针的方式进行处理

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：字符串反转，如将字符串“I LIKE KOBE”反转为 “EBOK EKIL I”
*/

int main() {
	char s[] = "I LIKE KOBE";
	int len = 0;
	char* p = s;
	// 使用while循环求取字符长度
	while (*p != '\0') {
		len++;
		p++;
	}
	printf("len = %d\n", len);
	int i;
	char temp;
	for (i = 0; i < len / 2; i++) {
		temp = *(s+i);
		*(s + i) = *(s+len-1-i);
		*(s + len - 1 - i) = temp;
	}
	printf("%s\n", s);
	return 0;
}

- [ ] eg30：题目：求100以内的素数

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：求100以内的素数
*/
int isPrime(int m) {
	if (m <= 0) {
		return 0;
	}
	if (m == 1) {
		return 0;
	}
	if (m == 2) {
		return 0;
	}
	for (int i = 3; i < (int)sqrt((double)m); i++) {
		if (m % i == 0) {
			return  0;
		}

	}
	return 1;

}
int main() {
	int isPrime(int m);
	int i;
	for (i = 2; i <= 100; i++) {
		if (isPrime(i)) {
			printf("%d  ", i);

	   }
	}
	return 0;

}

eg31：题目：求一个3*3矩阵对角线元素之和

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：求一个3*3矩阵对角线元素之和
*/

int main() {
	// 创建二维数组
	int a[3][3] = { {1,2,3},{4,5,6},{7,8,9} };
	int i = 0;
	int sum = 0;
	for (i = 0; i < 3; i++) {
		sum += a[i][i];
	}
	printf("对角线之和sum = %d\n", sum);
	return 0;
}

- [ ] eg32：题目：有一个已经排好序的数组，现输入一个数，要求按原来的规律将它插入属猪中程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间数的情况，插入后此元素之后的数，依次后移一个位置。

解题代码个思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   题目：有一个已经排好序的数组，现输入一个数，要求按原来的规律将它插入属猪中
   程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间数的情况，插入后此元素之后的数，依次后移一个位置
*/

int main() {
	int a[12] = { 1,4,6,9,13,16,19,28,40,100 };
	int i;
	int j;
	int b = 10;
	// 求取数组长度
	int length = sizeof(a) / sizeof(a[0]);
	printf("原来的数组是:");
	// 对数组进行遍历
	for (i = 0; i < length; i++) {
		printf("%-4d", a[i]);
	}
	printf("\n");
	//插入这个数
	if (b > a[9]) {
		a[10] = b;
	}
	else {
		for (i = 0; i < 10; i++) {
			if (a[i] < b) {
				continue;
			}
			else {
				for (j = 9; j >= i; j--) {
					a[j + 1] = a[j];
				}
				a[j + 1] = b;
			}
			break;
		}
	}


	printf("之后输入的数组是:");
	// 对数组进行遍历
	for (i = 0; i < length; i++) {
		printf("%-4d", a[i]);
	}
	printf("\n");
	return 0;

}

eg33：题目将一个数组逆序输出。程序分析：用最后一个和第一个交换

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   eg33：题目将一个数组逆序输出。程序分析：用最后一个和第一个交换.
*/

int main() {
	// 创建一个数组
	int a[] = { 0,1,2,3,4,5,6,7,8,9 };
	// 求取数组长度
	int length = sizeof(a) / sizeof(a[0]);
	// 定义一个变量I
	int i;
	// 创建一个中间变量用于交换
	int temp;
	// 输出一下
	printf("原始数组是：\n");
	// 遍历数组
	for (i = 0; i < length; i++) {
	    // 将遍历后的数组打印输出
		printf("%d ", a[i]);
	}
	printf("\n");
	//数据的置换
	for (i = 0; i < length / 2; i++)
	{
		// 数组中数据的置换
		temp = a[i];
		a[i] = a[length - 1 - i];
		a[length - 1 - i] = temp;
	}


	// 打印输出排序后的数组
	printf("排序后的数组\n");
	for (i = 0; i < length / 2; i++) {
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;

}

eg34：全局变量，静态变量，auto变量，register变量

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   eg33：全局变量，静态变量，auto变量，register变量
*/
// 创建函数返回值为void
void sellTicket() {
	// 只初始化一次，不会对这个变量重新的初始化
	static int num = 5;
	num--;
	printf("inside sellTicke() num = %d\n", num);
}
int main() {
	int a;
	for (a = 0; a < 5; a++) { 
		sellTicket();
	}


	

	return 0;

}

eg35:变量的作用域**

解题的代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
/*
   eg33：函数变量的作用域
*/
// 全局变量
int a = 1;
int b = 10;
int c;
void add() {
	c = a + b;
	printf("a = %d\n", a);
}

int main() {
    // 变量的作用域，对这个变量进行重新的赋值
    a = 20;
	add();
	printf("c = %d\n", c);
	return 0;
}

eg：36变量的宏定义，宏定义的三种用法

解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
//变量的宏定义，用法1：给变量符初始值
#define PI 3.1415926
// 使用宏定义定义一个标识符用法2：替换某一个操作符
#define CH *
// 使用宏定义的方式定义公式，像定义函数一样定义公式
#define mj(a,b) a*b*b
/*
   eg35：变量的宏定义
   1： 定义一个变量
*/

int main() {
	float r = 1.5;
	//int pai = 3.1415926;
	float mianji = PI CH r CH r;
	printf("%f\n", mianji);
	printf("mj(a,b) =%f\n", mj(PI, r));
	return 0;
}

- [ ] eg37:关于宏定义的优先级问题

解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 

/*
   eg35：宏定义的优先级问题
*/
#define PI 3.14
#define DaYu >
// 宏定义计算时要考虑到优先级的问题
#define MAXIMUM(X,Y) ((X>(Y))?(X):(Y))

int MaxiMum(int x, int y) {
	return (x > y ? x : y);
}

int main() {
	int MaxiMum(int x, int y);
	int a = 10;
	int b = 20;
	int c = MAXIMUM(a,a+b);
	printf("大的那个是:%d\n", c);
	return 0;
}

eg38:条件编译，#if,#ifdef,#ifndef编译器没有编译该语句，该语句不生成汇编语言

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 

/*
  eg38:条件编译，#if,#ifdef,#ifndef编译器没有编译该语句，该语句不生成汇编语言
*/
#define MAX
#define MAXIMUM(x,y) (x>y)?x:y
#define MINIMUM(x,y) (x>y)?y:x



int main() {
    // 编写预编译语言的代码
	int a = 10, b = 20;
		//定义过表示执行这个语句下的语句没有定义过就不执行这个语句下的语句
		#ifdef MAX
			printf("更大的数字是 %d\n", MAXIMUM(a, b));
        #else
	        printf("更小的数字是 %d\n", MINIMUM(a, b));
		#endif

	return 0;

}

eg39：协作式开发c语言项目

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
  eg38:条件编译，#if,#ifdef,#ifndef编译器没有编译该语句，该语句不生成汇编语言
*/
#define MAX
#define MAXIMUM(x,y) (x>y)?x:y
#define MINIMUM(x,y) (x>y)?y:x



int main() {
	int addInt(int x, int y);
	float addFloat(float x, float y);
	float r = 1.5;
	float area = PI * r * r;
	printf("areas = %f\n", area);

	int a = 30;
	int b = 50;
	float c = 1.4;
	float d = 2.9;
	printf("a + b = %d\n", addInt(a, b));
	printf("c + d = %f\n", addFloat(c, d));
	return 0;

}

#pragma once
#define PI 3.1415926734198

#include "myName.h"
// 在这个文件中编写函数，实现模块的独立化开发
int addInt(int x, int y) {
	return x + y;
}

float addFloat(float x, float y) {
	return x + y;
}

eg39:按位与&，按位或|，按位异或^

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
  eg39:按位与&，按位或|，按位异或^
*/

// 二进制转换函数
int f(int desc) {
	int result = 0;
	int temp = 1;
	int yushu = 0;

	while (1) {
		yushu = desc % 2;
		desc /= 2;
		result += yushu * temp;
		temp *= 10;
		if (desc < 2) {
			result += desc * temp;
			break;
		}
	}
	return result;

}


int main() {
	int f(int desc);
	int a = 6;
	int b = 5;
	printf("%d的二进制是%d\n", a, f(a));
	// c语言的二进制表示
	printf("%d的二进制是%d\n", a, f(b));
	// 按位与 0&0 = 0， 1 & 0 = 0， 1&1 = 1;
	int c = a & b;
	printf("%d的二进制是:%d\n", c, f(c));

	// 按位与 0|0 = 0， 1 & 0 = 1， 1&1 = 1;
	int d = a | b;
	printf("%d的二进制是:%d\n", d, f(d));
	
	// 按位与 0^0 = 0， 1 & 0 = 1， 1&1 = 0;
	int e = a ^ b;
	printf("%d的二进制是:%d\n", e, f(e));
	return 0;

}

eg40：对一个二进制进行按位取反

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
  eg40:对一个数的二进制进行按位取反
  原码：正数的原码等于反码等于补码，正数的符号位为0负数的原码，负数的符号位为1
  反码：正数的反码和原码一致，负数的反码是原码按位取反，符号位不变
  补码：正数的补码和原码一致，负数的补码等于：取法然后加上 1
  推理论证：
     5 ----> 0000 0101
	 ~a----> 1111 1010
	 -1----> 1111 1001
	 取反--> 1000 0110
	 b = -6；
*/


int main() {
	int a = 5;
	int b = ~a;
	printf("b = %d\n", b);
	return 0;
}

eg41：杨辉三角行

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
  eg41:输出杨辉三角形
*/


int main() {
	int i;
	int j;
	int a[10][10] = {};

	for (i = 0; i < 9; i++) {
		for (j = 0; j <= i; j++) {
			if (i == j || j == 0) {
				a[i][j] = 1;
			}
	
		}
		printf("\n");
	}
	for(i = 2; i < 10; i++){
		for (j = 1; j < i; j++) {
			a[i][j] = a[i - 1][j] + a[i - 1][j - 1];
		}
		
	}
	
	for (i = 0; i < 10; i++) {
		for (j = 0; j <= i; j++) {
			printf("%-4d", a[i][j]);
	
		}
		printf("\n");
	}
	return 0;

}

eg41：用函数交换两个变量的值

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
  eg41:使用函数交换两个变量的值

*/


// 函数的定义需要有函数头，函数体，返回值

int main() {
	// 使用中间变量的方式交换两个变量的值
	int a = 10;
	int b = 20;
	int temp;

	printf("a = %d,b = %d\n", a, b);
	// 对两个变量进行交换
	temp = a;
	a = b;
	b = temp;
	printf("a = %d,b = %d\n",a,b);
	return 0;

}

使用参数传递的方式完成数值的交换

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
  eg41:使用函数交换两个变量的值
  函数的定义需要有函数头，函数体，返回值
*/

void swap2(int* p_x, int* p_y) {
	// 中间变量
	int temp;
	temp = *p_x;
	*p_x = *p_y;
	*p_y = temp;
}


// 使用指针传递值得方式实现数值的交换
int main() {
	void swap2(int* p_x, int* p_y);
	int a = 10;
	int b = 20;
	int* pa;
	// 把a的地址给指针pa
	pa = &a;
	int* pb = &b;
	swap2(pa, pb);
	printf("a = %d, b = %d\n", *pa, *pb);
	return 0;
}

eg42：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组程序分析：输出正确的答案

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
 eg42：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组程序分析：输出正确的答案
 程序分析：
 1：输入数组
 2：最大值
 3：最大值和第一个元素交换
 4：最小值
 5：最小值与最后一个元素交换
 6：输出数组
*/



int main() {
	// 创建数组
	int a[5] = {1,2,3,4,5};
	int i;
    

	int* p; // p叫做，指针变量，指针是地址，是内存地址
	for (p = a; a < a + 5; p++) { // a+0, a[0],a[4],p+5
		printf("%-4d", *p);
	}


	

	printf("\n");
	return 0;

}

以下的代码提供了一个交换最大最小值的思路：后续代码需要自己进一步完善

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
 eg42：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组程序分析：输出正确的答案
 程序分析：
 1：输入数组
 2：最大值
 3：最大值和第一个元素交换
 4：最小值
 5：最小值与最后一个元素交换
 6：输出数组
*/



int main() {
	// 创建数组
	int a[5] = {1,9,3,8,5};
	int i;
	// 用于存储最大值的下标
	int x;

	// 交换之前将数据输出一下
	int* p; // p叫做，指针变量，指针是地址，是内存地址
	for (p = a; p < a + 5; p++) { // a+0, a[0],a[4],p+5
		printf("%-4d", *p);
	}
	
	int max;
	// max 表示的是数组首元素的地址
	max = a[0];
	for (i = 0; i < 5; i++) {
		if (a[i] > max) {
			max = a[i];
			// x是最大值得坐标
			x = i;
		}
	}
	printf("max = %d,x = %d\n", max,x);
	
	int temp;
	temp = a[0];
	a[0] = a[x];
	a[x] = temp;


	

	for (p = a; p < a + 5; p++) { // a+0, a[0],a[4],p+5
		printf("%-4d", *p);
	}


	

	printf("\n");
	return 0;

}

一定要记住回来完善补全这部分的代码
eg43：有n个整数，使其前面的各数顺序向后移动n个位置，最后m个数编程最前面的m个数
解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
   eg43：有n个整数，使其前面的各数顺序向后移动n个位置，最后m个数编程最前面的m个数。

	for (i = 0; i < length; i++) {
		printf("%-4d", a[i]);
	}

*/



int main() {
	// 创建一个数组
	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i;
	// 计算数组中的元素
	int length = sizeof(a) / sizeof(a[0]);
	int* p;


	for (int i = 1; i <= 3; i++) {
			/*
		   解题思路：
		   1：保存10
		   2：把10前面的所有数，依次后移一位
		   3：把10放到第一个位置
		   4：循环进行两次
		   */
			p = a + length - 1;
			int temp;
			temp = *p;
			// 把10前面的元素依次往后移
	
			while (p > a) {
				*p = *(p - 1);
				p--;
			}
			*p = temp;
	
	}
	
	for (p = a; p <= a + length - 1; p++) {
		printf("%-4d", *p);
	}



	return 0;

}

- [ ] eg44：有n个人围成一圈，顺序排号

从第一个人开始报数（从1-3开始报数），凡是报到3的人退出圈子，问最后留下来的是原来第几号那位
解题的代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*



int main() {
	int table[100] = { 1,1,1,1 };
	for (int i = 0; i <= 8; i++) {
		table[i] = 1;
	}
	for (int i = 1; i <= 8; i++) {
		printf("%-4d", table[i]);
	}
	printf("\n");
	int index;
	int baoShu;
	int count = 8;
	index = 0;
	baoShu = 0;
	while (count > 0) {
		index++;
		baoShu++;
		// 判断出界操作的时候一般是先判断然后再啊执行我们的操作
		while (table[index] == 0) {
			index++;
			if (index > 8) {
				index = 1;
			}
		}
		if (baoShu == 3) {
			table[index] == 0;
			printf("%-4d", index);
			count--;
			baoShu = 0;
		}
	

	}


	return 0;

}

eg45: 写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度
1：写一个函数
2：求一个字符串长度
3：在main函数中输入字符串

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
   eg45: 写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度
   1： 写一个函数
   2：求一个字符串长度
   3：在main函数中输入字符串
*/

int lenoString(char a[]) {
     // 通过指针对数组进行操作
	char* p;
	p = a;
	int count = 0;
	while (*p != '\0') {
		count++;
		p++;
	}
	return count;
}
int lenoString2(char* p) {
	int count = 0;
	while (*p != '\0') {
		count++;
		p++;
	}
	return count;
}


int main() {
	int lenoString(char a[]);
	int lenoString2(char* p);
	char a[] = "vsbudvnsonvaonvjsnv";
    char *p = (char *)"svhnsnvsonvsnvjsfsdf";
	char* p_a;
	p_a = a;


	int count = 0;
	while (*p_a != '\0') {
		count++;
		p_a++;
	}
	printf("count == %d\n", count);
	printf("lenoString = %d\n", lenoString(a));
	printf("lenoString2 = %d\n", lenoString2(p));
	return 0;

}

eg46：编写input（）和output（）函数输入，输出5个学生的数据记录

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg46：编写input（）和output（）函数输入，输出5个学生的数据记录
	1:函数，定义，声明，调用
	2：学生数据记录。实体，对象，结构体
	3：多个结构体，结构体数组
*/
struct student {
	char name[30];
	char sex[5];
	char age;

};

// 输入一个函数不需要返回值要给结构体赋初始值
void input(struct student *stu) {
	int i;
	for (i = 0; i < 3; i++) {
		scanf("%s%s%d", stu[i].name, stu[i].sex, &stu[i].age);

	}

}
// 字符输出函数
void output(struct student* stu) {
	int i;
	for (i = 0; i < 3; i++) {
		printf("name->is : %s, sex->is : %s, age->is: %d\n", stu[i].name, stu[i].sex, stu[i].age);
	}
}

// 等于就是，定义了一种新的数据类型叫做struct student
int main() {

    // 结构体的声明
    struct student stu1;
    struct student stu2[3];
    // 函数的声明
    void input(struct student* stu);
    void output(struct student* stu);
    // 使用循环的方式对数组进行赋值
    input(stu2);
    output(stu2);
    
    /*
    			调用结构体中的数据,使用字符串拷贝函数将字符串赋值到字符串拷贝函数中
    			strcpy(stu1.name, "1419010114");
    			stu1.age = 23;
    			strcpy(stu1.sex, "男");
    			printf("name->is : %s, age->is : %d, sex->is: %s\n", stu1.name, stu1.age, stu1.sex);
    */
    return 0;

}

**eg47：malloc的用法，创建一个链表(malloc动态创建链表)
void *malloc(size_t,size)
void *realloc(void ptr,size_t size);
void free(void p);
解题代码和思路

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg47：malloc的用法，创建一个链表(malloc动态创建链表)
	void *malloc(size_t,size)
	void *realloc(void *ptr,size_t size);
	void free(void *p);
*/

int main() {
	/*
	  	// 强制类型转换一下
		int *p =(int *) malloc(sizeof(int) * 20);
		int i = 10;
		*p = i;
		printf("*p = %d\n", *p);
		// 释放内存空间
		free(p);
	

	*/
	char* p;
	p = (char*)malloc(sizeof(char) * 20);
	strcpy(p, "helloword");
	printf("%s sizeof(p) = %zd\n", p, sizeof(p));
	
	char* q;
	q = (char*)realloc(p,sizeof(char) * 20);
	// 使用字符串拼接函数
	strcat(q, "teacher");
	printf("%s sizeof(q) = %zd\n", q, sizeof(q));
	free(p);
	free(q);
	
	return 0;

}

eg47：输入一个整数，并将其反转后输出

eg48：编写一个函数，输入n为偶数时，调用函数1/2+1/4+…+1/n，当输入n为奇数时调用函数1/1+1/3+…+1/n(利用指针函数)
指针函数：本质是一个函数，不过它的返回值是一个指针
函数指针：本质是一个指针，该指针的地址指向一个函数，所以它是指向函数的指针，定义如下：
#include
int main(void){
return 0;
}
eg48：编写一个函数，输入n为偶数时，调用函数1/2+1/4+…+1/n，当输入n为奇数时调用函数1/1+1/3+…+1/n(利用指针函数)
指针函数：本质是一个函数，不过它的返回值是一个指针
函数指针：本质是一个指针，该指针的地址指向一个函数，所以它是指向函数的指针，定义如下：
#include
int main(void){
return 0;
}

函数指针的用法，求两个值相加后的结果

取出函数的地址实现三个数之间的和（用于理解函数指针的用法，定义和函数指针的调用）

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg48：编写一个函数，输入n为偶数时，调用函数1/2+1/4+.....+1/n，当输入n为奇数时调用函数1/1+1/3+.......+1/n(利用指针函数)

	指针函数：本质是一个函数，不过它的返回值是一个指针
	
	函数指针：本质是一个指针，该指针的地址指向一个函数，所以它是指向函数的指针，定义如下：
	typedef int (*fun_ptr)(int,int);

*/

// 定义一个实现加法的函数
int add(int x, int y) {
	return x + y;
}
int main(void) { 
	int add(int x, int y);
	// 将函数的地址取出来存储发哦p_add中
	int (*p_add)(int, int) = &add;
	int a = 10;
	int b = 20;
	int c = 30;
	int sum = 0;
	sum = p_add(a, b);
	printf("sum = %d\n", sum);
	// 求三个数的和
	printf("三个数的和是%d\n", p_add((a, b), c));
	return 0;
}

以下代码存在一点小的问题需要后续去解决处理

*eg49：编写一个函数，输入n为偶数时，调用函数1/2+1/4+…+1/n，当输入n为奇数时调用函数1/1+1/3+…+1/n(利用指针函数)
指针函数：本质是一个函数，不过它的返回值是一个指针
函数指针：本质是一个指针，该指针的地址指向一个函数，所以它是指向函数的指针，定义如下：
typedef int (fun_ptr)(int,int);

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg48：编写一个函数，输入n为偶数时，调用函数1/2+1/4+.....+1/n，当输入n为奇数时调用函数1/1+1/3+.......+1/n(利用指针函数)

	指针函数：本质是一个函数，不过它的返回值是一个指针
	函数指针：本质是一个指针，该指针的地址指向一个函数，所以它是指向函数的指针，定义如下：
	typedef int (*fun_ptr)(int,int);

*/
double fun1(int n) {
	int i;
	double k = 0.0;
	double sum = 0;
	for (i = 2; k <= n; i += 2) {
		k = (double)1 / i;
		sum += k;
	}
	return sum;
}

double fun2(int n) {
	int i;
	double k= 0.0;
	double sum = 0;
	for (i = 1; k <= n; i += 2) {
		k = (double)1 / i;
		sum += k;
	}
	return sum;
}

int main(void) { 
	double fun1(int n);
	double fun2(int n);
	// 使用函数指针的方式进行调用
	double (*p)(int);

	int n = 5;

//	scanf("%d", &n);
	if (n % 2 == 0) {
		p = fun1;
	}
	else {
		p = fun2;
	}
	double result = p(n);
	printf("result = %lf\n", result);

	return 0;

}

eg50：指向指针的指针，二级指针（表示的是指向指针的指针）

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg49：1：指向指针的指针(二级指针)
	      2：二维数组

*/

int main(void) { 
    // 指向指针的指针
	int a = 100;
	int* p1 = &a;
	int** p2 = &p1;

	printf("&a = %x\n", &a);
	printf("*p2 = %x\n",*p2);
	printf("a = %d\n", a);
	printf("**p2 = %d\n", **p2);
	
	return 0;

}

使用指针获取数组元素的方式

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg49：1：二维数组
	      

*/

int main(void) { 
    // c语言中的二维数组,定义了一个3行4列的二维数组
	int a[3][4] = { {2,1,2,3},{4,5,6,7},{8,9,10,11} };
	int* p0 = (int *) &a[0];
	int* p1 = (int *) &a[1];
	int* p2 = (int *) &a[2];
	printf("*p0 = %d\n", *p0);


	/*
	   使用指针访问二维数组中的任何一个数
	*/
	// 获取数组中不同元素的方式
	int(*p)[4] = a;
	// 表示的是：获取第一行中的第一个元素
	printf("%d\n", *(*p + 0) + 0);
	// 表示的是：获取第一行中的第二个元素
	printf("%d\n", *(*p + 0) + 1);
	// 表示的是：获取第二行中的第二个元素
	printf("%d\n", *(*p + 1) + 1);
	return 0;

}

指针数组二级指针访问数据

eg51：1：二维数组获取字符串的值

eg52：结构体的定义和调用

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg50：结构体指针找一个年龄大的人     
*/
struct man {
	char name[20];
	char age;
}person[3] = { "li",18,"huang",23,"zhou",22 };


int main(void){
	/*
	   void 表示的是没有返回值，没有形式参数
	   void  *
	  

	*/
	
	struct man* p; 
	p = person;
	int m = 0;
	struct man* q = NULL;
	for (int i = 0; i < 3; i++) {
		if (p-> age > m) {
			m = p->age;
			q = p;
	
		}
		p++;
	}
	printf("%s, %d\n", q->name, q->age);
	return 0;

}

eg53字符串排序操作

eg51：字符串排序
1：首先要有若干个字符串
2：排序，比较大小
3：展示出来： a = 10; b = 20; b , a , a = 20, b = 10;

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg51：字符串排序
	1：首先要有若干个字符串
	2：排序，比较大小
	3：展示出来： a = 10; b = 20; b , a , a = 20, b = 10;
*/
void swap(char* str1,char*str2) {
	char temp[20];
	// 交换两个字符串
	strcpy(temp, str1);
	strcpy(str1, str2);
	strcpy(str2, temp);
}


int main(void){
	char str1[20] = "1234";
	char str2[20] = "1134";

	//fgets(str2, 20, stdin);
	//printf("%s\n", str2);
	
	if (strcmp(str1,str2) > 0) {
		printf("str1 is bigger\n");
	}
	else {
		// swap函数交换两个字符串
		swap(str1, str2);
		printf("str2 is bigger\n");
	}
	printf("%s,%s\n", str1, str2);
	return 0;

}

eg52：question —> 809？？ = 800 * ？？ + 9 ？？，其中？？代表的是两位数
809？？为4位数，8？？的结果是两位数，9*？？的结果是三位数，求？？代表的两位数，以及809*？？后的结果**

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg52：question ---> 809*？？ = 800 * ？？ + 9 *？？，其中？？代表的是两位数
	809*？？为4位数，8*？？的结果是两位数，9*？？的结果是三位数，求？？代表的两位数，以及809*？？后的结果
*/


int main(void){
	int a = 0;
	for (a = 10; a < 100; a++) {
		if (809 * a >= 1000 && 809 * a <= 10000 && 8 * a < 100 && 9 * a >= 100) {
			printf("%d = %d * %d\n", 809 * a, 800 * a, 9 * a);

		}
	}
	
	return 0;

}

eg53：将八进制的数转换为10进制

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg52：将8进制转换为10进制
	(123)8 = 1 * 8 ^2 ...

*/


int main(void){
	char s[20] = "123";
	int i = 0;
	int n = 0;
	while (s[i] != '\0') {
		n = n * 8 + s[i] - '0';
		i++;
	}
	printf("%d\n", n);
	

	return 0;

}

**- [ ] eg54:求0-7所能组成的奇数个数

这个问题其实是一个数组排列组合问题，设这个数为sun = a1a2a3a4a5a6a7a8 ,a1 - a8
当表示这个数的某位数值，当一个数的最后一位为奇数时，那么这个数一定为奇数，不管前面的几位是什么数字，如果最后的一位数为偶数，则这个一定为偶数
a1-a8可以取 0-7这八个数字，首位数字不为0；
从该数为一位数到该数为8位数统计奇数个数
1：当只有一位数时也就是该数的最后一位，奇数个数为4
2：当该数为两位数时，奇数个数为4*7 = 28；
3：当该数为三位数时，奇数个数为4 * 8*7 = 224**

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg52：将8进制转换为10进制
	(123)8 = 1 * 8 ^2 ...

*/


int main(void){
	int n = 0;
	int sum = 4;
	for (n = 1; n <= 4; n++) {
		if (n == 1) {
			printf("一共有%d位数，奇数的个数为%d\n", n, 4);
		}
		else if (n == 2) {
			sum += 4 * 7;
			printf("一共有%d位数，奇数的个数为%d\n", n, 4 * 7);

		}
		else {
			sum += 7 * (int)pow(8, n - 2) * 4;
			printf("一共有%d位数，奇数的个数为%d\n", n, 7 * (int)pow(8, n - 2) * 4);
		}
	}
	
	printf("奇数的总数是%d\n", sum);
	return 0;

}

eg54：判断一个素数可以被几个9整除

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
   eg54:判断一个素数可以被几个9整除
*/

int main(void){
	int ss = 11;
	int a = 9;
	while (a % ss != 0) {
		a = a * 10 + 9;
	}
	printf("a = %d\n", a);
	return 0;
}

*- [ ] eg55:两个字符串链接程序
1: 在c语言中字符串的处理是使用 char a , 和 char a[]

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
   eg55:两个字符串链接程序
   1: 在c语言中字符串的处理是使用 char *a , 和 char a[]
*/

int main(void){
	char str1[50] = " I am a teacher";
	puts(str1);
	char str2[50] = "love";
	puts(str2);
	// 字符串链接函数strcat(str1, str2);
	char * str = (char*)malloc(strlen(str1) + strlen(str2) + 1);
	strcat(str, str1);
	strcat(str, str2);
	puts(str);
	return 0;
}

eg56：结构体变量传递

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg56：结构体变量传递
	1: 结构体初始化：结构体的值是如何传递的
*/
struct student {
	int age;
	int gender;

};


void changeStu(struct student a) {
	a.age = 22;
	a.gender = 'M';
}

void changeStuAgain(struct student *a) {
	a->age = 30;
	a->gender = 'M';
}

int main(void){
	void changeStu(struct student a);
	void changeStuAgain(struct student* a);
	struct student oneStu;
	struct student* p_oneStu;
	p_oneStu = &oneStu;
	oneStu.age = 23;
	oneStu.gender = 'H';
	printf("oneStu  age  = %d ,gender = %c\n",oneStu.age,oneStu.gender);
	// 调用函数并传入参数
	changeStu(oneStu);
	printf("option -> oneStu  age  = %d ,option -> gender = %c\n", oneStu.age, oneStu.gender);
	// 调用函数传入当前定义的指针
	changeStuAgain(p_oneStu);
	printf("option_p -> oneStu  age  = %d ,option_p -> gender = %c\n", oneStu.age, oneStu.gender);
	return 0;
}

eg56：读取7个数(1-59)的整数值，每读取一个值，程序打印出该值个数
1：如何读一个数
2：如何打印出一个
3：如何打印出这么多个***

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg56：读取7个数(1-59)的整数值，每读取一个值，程序打印出该值个数*
	1：如何读一个数
	2：如何打印出一个*
	3：如何打印出这么多个*
*/

void printStar(int n) {
	int i;
	for (i = 0; i < n; i++) {
		printf("*");
	}
	printf("\n");
}

int main(void){
	void printStar(int n);
	int n = 10;
	printf("请输入一个整数: ");
	scanf("%d", &n);
	printStar(n);

	return 0;

}

eg56:某公司采用公用电话传递数据，数据是四位整数，在传递的过程中是加密的，加密的规则如下，每位数字都加上5，然后用10的余数代替该数字，在将第一位和第四位交换，第二位和第三位交换

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 
#include "myTestHead.h"
#include "myName.h"
/*
	eg56:某公司采用公用电话传递数据，数据是四位整数，在传递的过程中是加密的，加密的规则如下，每位数字都加上5，然后用
	10的余数代替该数字，在将第一位和第四位交换，第二位和第三位交换
*/

int main(void){
	int a;
	printf("请你输入一个四位数: ");
	scanf("%d", &a);
	printf("&-4d\n", a);
	// 每位数字都加上5
	int aa[4] = {0};
	aa[0] = a % 10;
	aa[1] = a % 100 / 10;
	aa[2] = a % 1000 / 100;
	aa[3] = a / 1000;
	for (int i = 0; i < 4; i++) {
		printf("%-4d", aa[i]);
	}
	for (int i = 0; i < 4; i++) {
		aa[i] += 5;
		aa[i] %= 10;
	}
	for (int i = 0; i < 4; i++) {
		printf("%-4d", aa[i]);
	}
	int t;
	for (int i = 0; i < 2; i++) {
		t = aa[i];
		aa[i] = aa[3 - i];
		aa[3 - i] = t;
	}
	printf("加密之后的数组: ");
	for (int i = 0; i < 4; i++) {
		printf("%-4d", aa[i]);
	}

	return 0;

}

c语言中函数的递归问题：简单来说就是函数自己调用自己的过程就是递归

#define _CRT_SECURE_NO_WARNINGS
#include
#include 
#include 
#include 
#include 

/*
	eg56:用递归的方法实现循环嵌套
*/
int sumN(int n) {
	if (n == 1) {
		return 1;
	}
	else {
		return sumN(n - 1) + n;
	}
}

int main(){
	int sumN(int n);
	int k = 100;
	printf("sumN = %d\n", sumN(k));

	return 0;
}

持续更新中…

你可能感兴趣的:(c语言,开发语言,visual,code,visual,studio)

OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
Faiss Tips：高效向量搜索与聚类的利器焦习娜Samantha
FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
ARM中断处理过程落汤老狗嵌入式linux
一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验张风捷特烈 ide rust 开发语言后端
theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
C语言判断回文数 Y雨何时停T c语言学习
一，回文数概念“回文”是指正读反读都能读通的句子，它是古今中外都有的一种修辞方式和文字游戏，如“我为人人，人人为我”等。在数学中也有这样一类数字有这样的特征，成为回文数。设n是一任意自然数。若将n的各位数字反向排列所得自然数n1与n相等，则称n为一回文数。例如，若n=1234321，则称n为一回文数；但若n=1234567，则n不是回文数。二，判断回文数实现思路一：数组与字符串将数字每一位按顺序放
BART&BERT Ambition_LAO 深度学习
BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
C语言代码练习（第十九天）小小框架 C语言 C语言重点练习 c语言
今日练习：52、有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中53、输出"魔方阵"。所谓魔方阵是指它的每一行，每一列和对角线之和均相等。54、找出一个二维数组中的鞍点，即该位置上的元素在该行上最大、在该列上最小。也可能没有鞍点。有一个已经排好序的数组，要求输入一个数后，按原来排序的规律将它插入数组中运行代码intmain(){intarr[11]={1,3,9,12,15
ARM V8 base instruction -- Debug instructions xiaozhiwise Assembly arm
/**Debuginstructions*/BRK#imm16进入monitormodedebug，那里有on-chipdebugmonitorcodeHLT#imm16进入haltmodedebug，连接有外部调试硬件
ESP32-C3入门教程网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能小康师兄 ESP32-C3入门教程 https 服务器 esp32 OTA MQTT
文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
vue+el-table 可输入表格使用上下键进行input框切换以对_ vue学习记录 vue.js javascript 前端
使用上下键进行完工数量这一列的切换-->//键盘触发事件show(ev,index){letnewIndex;letinputAll=document.querySelectorAll('.table_inputinput');//向上=38if(ev.keyCode==38){if(index==0){//如果是第一行,回到最后一个newIndex=inputAll.length-1}elsei
计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php 课程设计 vue.js
该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
leetcode-617. 合并二叉树 manba_ leetcode hot100 leetcode 算法
题目描述给你两棵二叉树：root1和root2。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为null的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意:合并过程必须从两个树的根节点开始。示例1：输入：root1=[1,3,2,
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
代码随想录Day 41|动态规划之买卖股票问题，leetcode题目121. 买卖股票的最佳时机、122. 买卖股票的最佳时机Ⅱ、123. 买卖股票的最佳时机Ⅲ LluckyYH 动态规划 leetcode 算法数据结构
提示：DDU，供自己复习使用。欢迎大家前来讨论~文章目录买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机解题思路：题目二：122.买卖股票的最佳时机II解题思路：题目三：123.买卖股票的最佳时机III解题思路总结买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机[[121.买卖股票的最佳时机](https://leetcode.cn/problems/combination
【算法练习】IDEA集成leetcode插件实现快速刷 2401_84102892 2024年程序员学习算法 intellij-idea leetcode
============点击右侧边leetcode->设置->配置地址、用户名、密码、存放目录、文件模板用户名要登录后在账号信息里看模板代码1.codefilename!velocityTool.camelC
Day_11 ROC_bird.. 算法
面试题16.15.珠玑妙算-力扣（LeetCode）/***Note:Thereturnedarraymustbemalloced,assumecallercallsfree().*///下标和对应位置的值都一样，answer[0]+1,对应位置的值猜对了，但是下标不对，answer[1]+1int*masterMind(char*solution,char*guess,int*returnSiz
[实验室服务器使用]使用VSCode、PyCharm、MobaXterm和CMD连接远程服务器 YuanDaima2048 工具使用服务器 vscode pycharm cmd 代理模式机器学习实验
文章总览：YuanDaiMa2048博客文章总览实验室服务器使用：使用VSCode、PyCharm、MobaXterm和CMD连接远程服务器在进行实验室工作时，远程连接服务器是常见的需求之一。本篇文章根据个人的一些使用介绍使用不同工具连接服务器的方法，并提供优化功能，使服务器能够使用本机代理的说明。准备服务器账号信息Host（主机）:10.XXX.XX.XXXPort（端口）:[SSHPort]U
LeetCode 53. Maximum Subarray 枯萎的海风算法与OJ C/C++leetcode
1.题目描述Findthecontiguoussubarraywithinanarray(containingatleastonenumber)whichhasthelargestsum.Forexample,giventhearray[−2,1,−3,4,−1,2,1,−5,4],thecontiguoussubarray[4,−1,2,1]hasthelargestsum=6.clicktos
怎么样才能成为专业的程序员？ cocos2d-x小菜编程 PHP
如何要想成为一名专业的程序员？仅仅会写代码是不够的。从团队合作去解决问题到版本控制，你还得具备其他关键技能的工具包。当我们询问相关的专业开发人员，那些必备的关键技能都是什么的时候，下面是我们了解到的情况。关于如何学习代码，各种声音很多，然后很多人就被误导为成为专业开发人员懂得一门编程语言就够了？！呵呵，就像其他工作一样，光会一个技能那是远远不够的。如果你想要成为
java web开发高并发处理 BreakingBad java Web 并发开发处理高
java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据）一：高并发高负载类网站关注点之数据库没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化措施是M-S（
mysql批量更新 ekian mysql
mysql更新优化：一版的更新的话都是采用update set的方式，但是如果需要批量更新的话，只能for循环的执行更新。或者采用executeBatch的方式，执行更新。无论哪种方式，性能都不见得多好。三千多条的更新，需要3分多钟。查询了批量更新的优化，有说replace into的方式，即： replace into tableName(id,status) values
微软BI（3） 18289753290 微软BI SSIS
1) Q：该列违反了完整性约束错误；已获得 OLE DB 记录。源:“Microsoft SQL Server Native Client 11.0” Hresult: 0x80004005 说明:“不能将值 NULL 插入列 'FZCHID'，表 'JRB_EnterpriseCredit.dbo.QYFZCH'；列不允许有 Null 值。INSERT 失败。”。 A：一般这类问题的存在是
Java中的List g21121 java
List是一个有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复
读书笔记永夜-极光读书笔记
1. K是一家加工厂,需要采购原材料,有A,B,C,D 4家供应商,其中A给出的价格最低,性价比最高,那么假如你是这家企业的采购经理,你会如何决策? 传统决策: A:100%订单 B,C,D:0% &nbs
centos 安装 Codeblocks 随便小屋 codeblocks
1.安装gcc,需要c和c++两部分,默认安装下,CentOS不安装编译器的,在终端输入以下命令即可yum install gccyum install gcc-c++ 2.安装gtk2-devel,因为默认已经安装了正式产品需要的支持库,但是没有安装开发所需要的文档.yum install gtk2* 3. 安装wxGTK yum search w
23种设计模式的形象比喻 aijuans 设计模式
1、ABSTRACT FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory 　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：
开发管理 CheckLists aoyouzi 开发管理 CheckLists
开发管理 CheckLists(23) -使项目组度过完整的生命周期开发管理 CheckLists(22) -组织项目资源开发管理 CheckLists(21) -控制项目的范围开发管理 CheckLists(20) -项目利益相关者责任开发管理 CheckLists(19) -选择合适的团队成员开发管理 CheckLists(18) -敏捷开发 Scrum Master 工作开发管理 C
js实现切换百合不是茶 JavaScript 栏目切换
js主要功能之一就是实现页面的特效,窗体的切换可以减少页面的大小,被门户网站大量应用思路: 1,先将要显示的设置为display:bisible 否则设为none 2,设置栏目的id ,js获取栏目的id,如果id为Null就设置为显示 3,判断js获取的id名字;再设置是否显示代码实现: html代码: <di
周鸿祎在360新员工入职培训上的讲话 bijian1013 感悟项目管理人生职场
这篇文章也是最近偶尔看到的，考虑到原博客发布者可能将其删除等原因，也更方便个人查找，特将原文拷贝再发布的。“学东西是为自己的，不要整天以混的姿态来跟公司博弈，就算是混，我觉得你要是能在混的时间里，收获一些别的有利于人生发展的东西，也是不错的，看你怎么把握了”，看了之后，对这句话记忆犹新。 &
前端Web开发的页面效果 Bill_chen html Web Microsoft
1.IE6下png图片的透明显示： <img src="图片地址" border="0" style="Filter.Alpha(Opacity)=数值(100),style=数值(3)"/> 或在<head></head>间加一段JS代码让透明png图片正常显示。 2.<li>标
【JVM五】老年代垃圾回收：并发标记清理GC(CMS GC) bit1129 垃圾回收
CMS概述并发标记清理垃圾回收(Concurrent Mark and Sweep GC）算法的主要目标是在GC过程中，减少暂停用户线程的次数以及在不得不暂停用户线程的请夸功能，尽可能短的暂停用户线程的时间。这对于交互式应用，比如web应用来说，是非常重要的。 CMS垃圾回收针对新生代和老年代采用不同的策略。相比同吞吐量垃圾回收，它要复杂的多。吞吐量垃圾回收在执
Struts2技术总结白糖_ struts2
必备jar文件早在struts2.0.*的时候，struts2的必备jar包需要如下几个： commons-logging-*.jar Apache旗下commons项目的log日志包 freemarker-*.jar
Jquery easyui layout应用注意事项 bozch jquery 浏览器 easyui layout
在jquery easyui中提供了easyui-layout布局，他的布局比较局限，类似java中GUI的border布局。下面对其使用注意事项作简要介绍：如果在现有的工程中前台界面均应用了jquery easyui，那么在布局的时候最好应用jquery eaysui的layout布局，否则在表单页面（编辑、查看、添加等等）在不同的浏览器会出
java-拷贝特殊链表：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？ bylijinnan java
public class CopySpecialLinkedList { /** * 题目：有一个特殊的链表，其中每个节点不但有指向下一个节点的指针pNext，还有一个指向链表中任意节点的指针pRand，如何拷贝这个特殊链表？拷贝pNext指针非常容易，所以题目的难点是如何拷贝pRand指针。假设原来链表为A1 -> A2 ->... -> An，新拷贝
color Chen.H JavaScript html css
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <HTML> <HEAD>&nbs
[信息与战争]移动通讯与网络 comsci 网络
两个坚持:手机的电池必须可以取下来光纤不能够入户,只能够到楼宇建议大家找这本书看看:<&
oracle flashback query(闪回查询) daizj oracle flashback query flashback table
在Oracle 10g中，Flash back家族分为以下成员： Flashback Database Flashback Drop Flashback Table Flashback Query(分Flashback Query,Flashback Version Query，Flashback Transaction Query) 下面介绍一下Flashback Drop 和Flas
zeus持久层DAO单元测试 deng520159 单元测试
zeus代码测试正紧张进行中,但由于工作比较忙,但速度比较慢.现在已经完成读写分离单元测试了,现在把几种情况单元测试的例子发出来,希望有人能进出意见,让它走下去. 本文是zeus的dao单元测试: 1.单元测试直接上代码 package com.dengliang.zeus.webdemo.test; import org.junit.Test; import o
C语言学习三printf函数和scanf函数学习 dcj3sjt126com c printf scanf language
printf函数 /* 2013年3月10日20:42:32 地点：北京潘家园功能：目的：测试%x %X %#x %#X的用法 */ # include <stdio.h> int main(void) { printf("哈哈！\n"); // \n表示换行 int i = 10; printf
那你为什么小时候不好好读书? dcj3sjt126com life
dady, 我今天捡到了十块钱, 不过我还给那个人了 good girl! 那个人有没有和你讲thank you啊没有啦....他拉我的耳朵我才把钱还给他的, 他哪里会和我讲thank you 爸爸, 如果地上有一张5块一张10块你拿哪一张呢.... 当然是拿十块的咯... 爸爸你很笨的, 你不会两张都拿爸爸为什么上个月那个人来跟你讨钱, 你告诉他没
iptables开放端口 Fanyucai linux iptables 端口
1，找到配置文件 vi /etc/sysconfig/iptables 2，添加端口开放，增加一行，开放18081端口 -A INPUT -m state --state NEW -m tcp -p tcp --dport 18081 -j ACCEPT 3，保存 ESC :wq! 4，重启服务 service iptables
Ehcache（05）——缓存的查询 234390216 排序 ehcache 统计 query
缓存的查询目录 1. 使Cache可查询 1.1 基于Xml配置 1.2 基于代码的配置 2 指定可搜索的属性 2.1 可查询属性类型 2.2 &
通过hashset找到数组中重复的元素 jackyrong hashset
如何在hashset中快速找到重复的元素呢?方法很多，下面是其中一个办法： int[] array = {1,1,2,3,4,5,6,7,8,8}; Set<Integer> set = new HashSet<Integer>(); for(int i = 0
使用ajax和window.history.pushState无刷新改变页面内容和地址栏URL lanrikey history
后退时关闭当前页面 <script type="text/javascript"> jQuery(document).ready(function ($) { if (window.history && window.history.pushState) {
应用程序的通信成本 netkiller.github.com 虚拟机应用服务器陈景峰 netkiller neo
应用程序的通信成本什么是通信一个程序中两个以上功能相互传递信号或数据叫做通信。什么是成本这是是指时间成本与空间成本。时间就是传递数据所花费的时间。空间是指传递过程耗费容量大小。都有哪些通信方式全局变量线程间通信共享内存共享文件管道 Socket 硬件（串口，USB）等等全局变量全局变量是成本最低通信方法，通过设置
一维数组与二维数组的声明与定义恋洁e生二维数组一维数组定义声明初始化
/** * */ package test20111005; /** * @author FlyingFire * @date:2011-11-18 上午04:33:36 * @author ：代码整理 * @introduce :一维数组与二维数组的初始化 *summary： */ public c
Spring Mybatis独立事务配置 toknowme mybatis
在项目中有很多地方会使用到独立事务，下面以获取主键为例（1）修改配置文件spring-mybatis.xml  <tx:annotation-driven transaction-manager="transactionManager" /> &n
更新Anadroid SDK Tooks之后，Eclipse提示No update were found xp9802 eclipse
使用Android SDK Manager 更新了Anadroid SDK Tooks 之后，打开eclipse提示 This Android SDK requires Android Developer Toolkit version 23.0.0 or above, 点击Check for Updates 检测一会后提示 No update were found