C/C++的学习TEXT

避免累积乘的问题（for循环嵌套）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
//1的阶乘，加2的阶乘，加3的阶乘
int main()
{
	int n, ret, i, sum = 0;
	for (n = 1; n <= 3; n++)
	{
		ret = 1;//为了避免累积乘的现象出现，这一步必须要有
		for (i = 1; i <= n; i++)
		{
			ret = ret * i;
		}
		sum = sum + ret;
	}
	printf("%d\n", sum);
	return 0;
}

辗转相除法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include<stdio.h>
//辗转相除法求两个数的最大公约数，和最小公倍数
int main()
{
	int a, b, m, n, r;
	printf("Enter m,n");
	scanf("%d%d",&m,&n);
	a = m;
	b = n;
	while (m % n)//如果m%n=0，自动跳出循环
	{
		r = m % n;
		m = n;
		n = r;
	}
	printf("最大公约数=%d\n", n);
	printf("最小公倍数=%d\n", a * b / n);
	return 0;
}

闰年计算方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
main()
{
	int year = 0;
	int count = 0;
	for (year = 1000; year <= 2000; year++)
	{
		if (year % 4 == 0 && year % 100 != 0)
            //if((year%4==0)&&(year%100!=0))||(year%400==0))
		{
			printf("%d\n", year);
			count++;
		}
		else if (year % 400 == 0)
		{
			printf("%d\n", year);
			count++;
		}
	}
	printf("\ncount=%d\n", count);
	return 0;
}

素数：（规则）试除法,1不是素数

素数只能被1和它本身整除

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
//打印100到200间的素数
int main()
{
	int i;
	//判断i是否为素数
	int count = 0;
    int j = 0;
	for (i = 100; i <= 200; i++)
	{
		for (j = 2; j < i; j++)
		{
			if (i % j == 0)
			{
				break;
			}
		}//此时有两种情况都可以跳出循环，要把它们分离开来
		if (j == i)
		{
			count++;
			printf("%d ", i);

		}

	}
	printf("\ncount= %d\n", count);
	return 0;
}


//从键盘输入一个大于2的整数m，判断m是不是素数（）
#include<stdio.h>
#include<math.h>
main()
{
    int k,m,i;
    do
        scanf("%d",&m);
    while(m<=2);
    k=(int)sqrt(m);//从算法上考虑，为了减少重复量，开平方后面的数就不用相除了
    for(i=2;i<=k;i++)
        if(m%i==0)
            break;
    if(i<=k)
        printf("%d is not a prime number\n",m);
    else
        printf("%d is a prime number\n",m);
}

打印1到100内包含九的数字：

1
2
3
4
5
6
7
8
9
10
11
12
13
int main()
{
    int i=0;
    int count=0;
    for(i=1;i<=100;i++){   //如果十位数有9，那么这个数除10就会等于9，如果个位数有9，那么这个数取余%10就会等于9
        if(i%10==9)
            count ++;
        else if(i/10==9)
            count ++;
    }
    printf("count=%d\n",count);
    return 0;
}

打印1+1/2-1/3+1/4+…+99/1-100/1的值

1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
    int i=0;
    double sum=0.0;
    int flag=1;//flage相当于正负号
    for(i=1;i<=100;i++){
        sum+=flag*1.0/i;
        flag=-flag;
    }
    printf("%lf\n",sum);
    return 0;
}

打印九九乘法口诀表（典型循环嵌套）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main()
{
    int i,j;
    //确定打印九行
    for(i=1;i<=9;i++)
    {//打印一行
        for(j=1;j<i;j++)
        {
            printf("%d*%d=%-3d",i,j,i*j);//-3d不够三位左空格补齐
        }
        printf("\n");
    }
    return 0;
}

二分查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
int main()
{
    int k=7;//k为要找的数
    int arr[]={1,2,3,4,5,6,7,8,9,10}
    int sz=sizeof(arr)/sizeof (arr[0]);//计算元素个数
    int left=0;      //左下标
    int right=sz-1   //右下标
    int mid=(left+right)/2;
    while(left<right)
    {
      if(arr[mid]>k)//要找的元素在中间元素左边，左下标不变，右下标变为mid-1
      {
        right=mid-1;
      }
      else if(arr[mid]<k)//要找的元素在中间元素右边，右下标不变，左下标变成mid+1
      {
        left=mid+1;
      }
       else(arr[mid]==k)
           printf("找到了，下标为：%d",mid);
        break;
    }
    if(left>right)
        printf("找不到");
    return 0;
}


//设计一个函数，实现二分查找
int binary_search(int arr[],int k)
{}
int main()
{
    //二分查找：在一个有序数组中查找具体某一个数，如果找到了就返回这个数的下标，找不到返回-1
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int k=7;
    int ret=binary_search(arr,k);
    if(ret==-1)
        printf("找不到指定的数字\n");
    else
        printf("找到了，下表是：%d\n",ret);
}

char()函数的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//从键盘上连续输入字符，并统计其中大写字母的个数直到“换行”字符结束
#include<stdio.h>
main()
{
    char ch;
    int sum=0;
    while (1)
    {
        ch=getchar();
        if(ch=='\n')
            break;   //只能终止他所在的循环体
        if(ch>='A'&&ch<='Z')
           sum++;
    }
           printf("%d",sum);
}


//输入一行字符，分别统计出其中的英文字母，空格，数字和其他字符的个数
#include<stdio.h>
int main()
{
    char c;
    int letter=0,big=0,space=0,digit=0,other=0;
    printf("请输入需要统计的字段:\n");
    while((c=getchar())!='\n')//到回车才结束循环
    {
        if(c>='a'&&c<='z')
            letter++;
        else if(c>'A'&&c<='Z')
            big++;
        else if(c>='0'&&c<='9')
            digit++;
        else
            other++;
    }
    printf("小写=%d\n大写=%d\n空格=%d\n数字=%d\n其它=%d",letter,big,space,digit,other);
    return 0
}
//有三行文字的文章，每行有80个字符，分别统计中英文大写字母，小写字母，数字，空格以及其他字符的个数（二维 ）

图案打印

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
  //菱形从上到下a,b,c,d,e,f,g
   a
  bbb
 ccccc
ddddddd
 eeeee
  fff
   g
main()
   {
       int i,j;
       char c='a';
       for(i=1;i<=5;i++)
       {
           for(j=1;j<=5-i;j++)
               printf(" ");
           for(j=1;j<=2*i-1;j++)
               printf("%c",c);
           printf("\n");
           c=c+1;
       }
       for(i=1;i<=4;i++)
       {
           for(j=1;j<=i;j++)
               printf(" ");
           for(j=1;j<=9-2*i;j++)
               printf("%c",c);
           printf("\n");
           c=c+1;
       }
   }

写一个函数，每次调用一次这个函数，就会将num的值加1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
C++
void Add(int* p)
{
    //*p++;//++的优先级比较高，++是作用于p的，不是作用于*p的，所以这样写代码是错误的
    (*p)++;
}
int main()
{
    int num=0;
    Add(&num);
    printf("%d\n",num);//1
    Add(&num);
    printf("%d\n",num);//2
    Add(&num);
    printf("%d\n",num);//3
}

编写一个程序，加密输出(字符数组应用举例)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//加密规则：所有的大写英文字母加三，小写英文字母减三，其他字符不变。
//注意：特殊的X，Y，Z这三个大写英文字母直接加三不能使其正确加密，所以加密后让X为A，Y为B，Z为C；同理x,y,z使其为a,b,c.
#include<stdio.h>
#include<string.h>
main()
{
    char ch,str1[81],str2[81];//字符数组最大为81，防止溢出
    int i;
    printf("Enter a string:\n");
    get(str1);//get函数可以输入包括空格的字符
    strcpy(str2,str1);
    for(i=0;(ch=str2[i])!='\n';i++)//(ch=str2[i])!='\0'代表一直执行直到遇到\0
        if(ch>='A'&&ch<='W')
            str2[i]+=3;
        else if(ch=='X'||ch=='Y'||ch=='Z')
            str2[i]-=23;
        else if(ch>='d'||ch<='z')
            str2[i]-=3;
        else if(ch=='a'||ch=='b'||ch=='c')
            str2[i]+=23;
    str2[i]='\0';
    printf("原串是:%s\n",str1);
    printf("加密后的串是:%s\n,str2");
}

魔方阵（基数）/鞍点（flag的运用）

  • 魔方阵（是指组成元素为自然数1，2…n的平方的n×n的方阵，其中每个元素值都不相等，且每行，每列以及主副对角线上各n个元素之和都相等）的排列规律：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
8  1  6
3  5  7
4  9  2

1,先给备用数组内所有数赋初值0;(下面的i代表行号，j代表列号)(第1步是为第7步做铺垫)
2,第0行的中间那个数a[i][j]=0,此时i = 0,j = n/2;
3,当前的数在首行(i=0)时，下一个数放在最后一行(i=n-1)，j++;
4,当前的数在最后一列(j=n-1)时，下一个数放在第一列(j=0)，i--;
5,如果同时满足了(i=0和j=n-1)，那么进行i=n-1,j=0;
6,如果3.4.5都不满足，就进行i--,j++;
7,经过上面3步的判断，找到了新的i和j的值，如果此时a[i][j]放的值是0，代表这地方未被用过，可放下一个数；
如果此时这里放的不是0，代表已经被用过了，那么下一个数就直接放到这个数的前面那个数的的下面（比如本例n=3时：4本该放到a[0][1]的，但a[0][1]被1占了，所以，就直接把4放到4的前面那个数3的下面。）
    
    
#include<stdio.h>
void main()
{
	int a[10][10];
	int i,j,ok,n,m;
 
	for(i = 0;i < 10;i++)                   /*给备用的数组做初始化*/
	{
		for(j = 0;j < 10;j++)
			a[i][j] = 0;
	}
 
	ok = 0;                                  /*限定输入的数必须满足要求*/
	while(ok == 0)
	{
		printf("Please input a number as the value of n:(必须是10以内的奇数)\n");
	    scanf("%d",&n);
		if(n % 2 != 0 && n > 0 && n < 10 )
			ok = 1;
		else
			ok = 0;
	}
 
	i = 0;
	j = n/2;
	a[i][j] = 1;
	for(m = 2;m <= n*n;m++)                  /*因为1已经放好了，所以我们从2开始放*/
	{
 
		if((i == 0) && (j != n-1))            /*算法中的第3步*/
		{
			i = n-1;
			j = j+1; 
			if(a[i][j] == 0)                  /*算法中的第7步*/
				a[i][j] = m;
			else
			{
				i = 1;
				j = j - 1;
				a[i][j] = m;
			}
		}
 
		else if((i != 0) && (j == n-1))      /*算法中的第4步*/
		{
			i = i-1;
			j = 0;
			if(a[i][j] == 0)                /*算法中的第7步*/
				a[i][j] = m;
			else
			{
				i = i + 1;
				j = n - 1;
				a[i][j] = m;
			}
		}
 
	   else if((i == 0) && (j == n-1))       /*算法中的第5步*/
		{
			i = n-1;
			j = 0;
			if(a[i][j] == 0)                 /*算法中的第7步*/
				a[i][j] = m;
			else
			{
				i = 1;
				j = n - 1;
				a[i][j] = m;
			}
		}
 
		else                                 /*算法中的第6步*/
		{
			i = i-1;
			j = j+1;
			if(a[i][j] == 0)                 /*算法中的第7步*/
				a[i][j] = m;
			else
			{
				i = i + 2;
				j = j - 1;
				a[i][j] = m;
			}
		}
	}
 
    printf("%d阶魔方阵:\n",n);
	for(i = 0;i < n;i++)                        /*输出数组*/
	{
		for(j = 0;j < n;j++)
		{
			printf("%4d",a[i][j]);
		}
		printf("\n");
	}
}
————————————————
版权声明：本文为CSDN博主「Fritie」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/leipinyuan/article/details/79090126

  • 鞍点flag的用法

    • 鞍点：在二维矩阵中,鞍点是在它所在这一行的最大，在列上是最小的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include<stdio.h>
//当需要多次更换矩阵的时候可以定义符号常量
#define M 3
#define N 3
int main()
{
    //输入数组
    int i,j,a[M][N],hangmax,hangmax_j,k,flag;
    printf("请依次输入%d*%d的数组元素：\n",M,N);
    for(i=0;i<M;i++)
        for(j=0;j<N;j++)
        scanf("%d",&a[i][j]);
    //打印数组
    printf("数组如下:\n");
    for(i=0;i<M;i++)
    {
         for(j=0;j<N;j++)
        scanf("%6d",&a[i][j]);//6d控制格式，因为有单位也有双位
    printf("\n");
    }
    for(i=0;i<M;i++)
    {
        hangmax=a[i][j];//先假设第i行的第一个数是最大数
        //比较第i行哪个数最大
        for(j=0;j<N;j++)
        {
            if(a[i][j]>hangmax)
            {
                hangmax=a[i][j];
                hangmax_j=j;//这里必须有变量来接受最大数的纵下标
            }
        }
        //比较第i行最大值是不是在所在列中最小
        flag=1;
        for(k=0;k<M;k++)//设新变量k，因为是在一行行比较的大环境下
        {
            if(a[k][hangmax_j]<hangmax)//这一行的hangmax就不是鞍点
                //标志变量的使用，触发flag，锁定鞍点位置
                flag=0;
        }
        if(flag==1)//如果flag=1，表示有鞍点
        {
            printf("鞍点是：a[%d][%d]=%d",i,hangmax_j,max);
            //二维数组只有一个鞍点，或没有鞍点
            break;//这里break的作用：防止flag==0被反复执行，因为有可能第一行存在鞍点之后行数不存在鞍点，那么就为flag=0
        }
    }
    if(flag==0)
    printf("该数组不存在鞍点");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//打印100到200之间的素数
#include<stdio.h>
int is_prime(int n)
{
    //拿2到n-1的数来进行试除
    int j=0;
    for(j=2;j<n;j++)
    {
        if(n%j==0)
            return 0;//直接结束函数，不执行这个函数下面的语句
    }
    //if(j==n)
    return 1;
}

int main()
{
    int i=0;
    for(i=100;i<200;i++)
    {
        //判断i是不是素数
        //规定不是素数返回0;是素数返回1
        if(is_prime(i)==1)
            printf("%d",i);
    }
    return 0;
}

将字符串中ASCII码值最大的放在最前面，

并使该字符前的原字符顺次向后移动。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include<stdio.h>
#define M 30
main()
{
	char str[M];
	int i,max,max_i;
	//输入数组
	printf("enter a string:");
	gets(str);
	printf("\n the original string:");
	puts(str);
	printf("\n");
	//打印数组
	max = str[0];
	for (i = 0;i<M; i++)
	{
		if (str[i] > max)
		{
			max = str[i];
			max_i = i;
		}
	}
    //不能这样写的原因是如果输入pipiwrr，结果是wpppprr，会覆盖结果
	/*for (i = 0; i < max_i; i++)
		str[i + 1] = str[i];*/
    for(i=max_i;i>=0;i--)
        str[i+1]=str[i];
	str[0] = max;
	puts(str);

}

冒泡法排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
//输入一个正整数n(1<n<=10),再输入n个整数，按绝对值从小到大排序后输出
#include<stdio.h>
#define N 10
main()
{
	int a[N] = {0},n,i,j,max;
	printf("输入多少个正整数n:\n");
	scanf("%d",&n);
	//打印一遍
	printf("打印这个数组:");
	for (i = 0; i < n; i++)
		scanf("%d", &a[i]);
	for(i=0;i<n-1;i++)
		for(j=0;j<n-1-i;j++)//冒泡法重点在于趟数与数字数的关系，趟数等于数字数减一
	if (a[j] > a[j + 1])
	{
		max = a[j];
		a[j] = a[j + 1];
		a[j + 1] = max; 
	}
    printf("排列后的顺序:\n")
	for(i=0;i<n;i++)
	printf("%d", a[i]);
}


//冒泡排序数组中的数字(cong'x)
void bubble_sort(int arr[],int sz)
{
    //确定冒泡排序的趟数
    int i=0;
    for(i=0;i<sz-1;i++)
    {
        int flag=1;//假设这一趟要排序的数据已经有序
        //每一趟冒泡排序
        int j=0;
        for(j=0;j<sz-1-i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
                flag=0;//本躺排序的数据其实不完全有序
            }
        }
        if(flag==1)
        {
            break;
        }
    }
}
int main()
{
    int arr[]={9,8,7,6,5,4,3,2,1};
    int i=0;
    int sz=sizeof(arr)/sizeof(arr[0]);
    //对arr进行排序，排成升序
    //arr是数组，我们对数组进行传参，真实传递过去的并不是数组本身，而是首元素的地址 &arr[0]
    bubble_sort(arr);//冒泡排序函数
    for(i=0;i<sz;i++)
    {
        printf("%d",arr[i])
    }
}

杨辉三角形(要求打印十行)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
......

#include<stdio.h>
#define N 11
main()
{
    int i,j,a[N][N];
    for(i=1;i<N;i++)//贴切生活，从第一行开始而不从0行开始,列也是如此
    {
        a[i][i]=1;
        a[i][1]=1;
    }
    for(i=3;i<N;i++)
        for(j=2;j<=i-1;j++)
            a[i][j]=a[i-1][j-1]+a[i-1][j];
    printf("杨辉三角形:\n");
    for(i=1;i<N;i++)
    {
        for(j=1;j<i;j++)
            printf("%d\t",a[i][j]);
        printf("\n");
    }
}

求周边数组元素之和(4行5列)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<stdio.h>
#define M 4
#define N 5
main()
{
    int a[M][N]={{1,2,3,4,5}{3,4,5,6,7}{6,7,8,9,4}{2,3,4,5,6}};//根据需求可以更换数组元素
    int i,j,s=0;
    for(i=0;i<M;i++)//打印数组
    {
        for(j=0;j<N;j++)
            printf("%3d",a[i][j]);
        printf("\n");
    }
    for(j=0;j<N;j++)//第一行数组元素加上最后一行数组元素
    {
        s=s+a[0][j];
        s+=a[M-1][j];
    }
    for(i=1;i<M-1;i++)
    {
        s+=a[i][0];//打印最左边去掉第一行和最后一行的数组元素
        s+=a[i][N-1];//打印最右行去掉第一行和最后一行的数组元素
    }
    printf("%d\n",s);
}

删除有序数组中的相同数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include<stdio.h>
#define N 15
main()//第一种方法
{
    int i,j,k=0,b=[N];//将排除过相同数的数组填到数组b中
    int a[15]={2,3,4,5,5,6,7,8,9,10,10,11,12,12};
    for(i=0;i<N;i++)
    {
        b[k]=a[i];
        for(j=i+1;j<N;j++)//如果后一个数组元素和前一个不等就把这两个数分别赋给b数组的两个数组元素；如果后一个数组等于前一个数组元素，那么把这两个数组元素赋给b数组的同一个数组元素
            if(a[i]!=a[j])
            {
                k++;
                break;//跳出内层循环
            }
            else break;//else和离它最近的没有匹配的if进行匹配
    }
    for(i=0;i<=k;i++)
    {
        if(i%4==0)
            printf("\n");
        printf("%6d",b[i]);
    }
    printf("\n");
}


main()//第二种方法，自认为好理解
{
    int i,k=0,n=0,b[N];
    int a[N]={2,3,4,5,6,7,8,9,10,10,10,11,12,12};
    for(i=0;i<N;i++)//如果后一个数组元素和前一个不等就把这两个数分别赋给b数组的两个数组元素；如果后一个数组等于前一个数组元素，那么把这两个数组元素赋给b数组的同一个数组元素   和第一种方法思想差不多，就是程序书写不一样		
        if(a[i]!=a[i+1])
        {
            b[k]=a[i];
            k++;
        }
    for(i=0;i<k;i++)
    {
        printf("%6d",b[i]);
        n++;
        if(n%4==0)
            putchar("%6d",b[i]);
    }
    putchar('n');
}

设计一个函数，输入一个4位数字，要求输出这4个数字字符，但每两个数字间空一个空格。例如，输入1990，应输入“1 9 9 0”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<stdio.h>
main()
{
	char str[81];
	void insert(char str[]);
	printf("input four digits:\n");
	gets(str);//录入数组元素
	insert(str);//调用函数
	printf("output digits after insert space:\n");
	puts(str);//输出更改过后的数组
}
void insert(char str[])
{
	int i;
	for (i = strlen(str); i > 0; i--)
	{
		str[2 * i] = str[i];//把数字放在下标为0，2，4，6这几个数组元素中
		str[2 * i - 1] = ' ';//把空格放在下标为1，3，5，7的数组元素中
	}
}

置换一个字符串中的字符eg.werty置换成ytrew

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<stdio.h>
#define M 5//定义大小最好定义大一点
#include<string.h>
void fun(char a[])
{
	int j, k;
	char temp;
	k = strlen(a) - 1;
	for (j = 0; j <= k; j++)//第一个和最后一个互换，第二个和倒数第二个互换...
	{
		temp = a[j];
		a[j] = a[k];
		a[k] = temp;
		k--;
	}
}
main()
{
	char a[M];
	printf("置换前的字符串:\n");
	scanf("%s", a);//直接打印一个字符串
	fun(a);
	printf("置换后的字符串:\n");
	printf("%s", a);
}

描述第n个斐波那契数(函数的递归与迭代)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//1  1  2  3  5  8  13  21  34  55... 
/*用递归来写效率非常低
int Fib()
{
    if(n<=2)
        return 1;
    else
        return Fib(n-1)+Fib(n-2)
}
*/
//用迭代来写,用三个变量不断赋值
int Fib(int n)
{
    int a=1;//前两个斐波那契数
    int b=1;
    int c=1;//如果求前两个斐波那契数，直接return 1，不进循环
    //只有从第三个数开始才用这个方法
    while(n>=3)
    {
        c=a+b;
        a=b;
        b=c;
        n--;
    }
    return c;
}
int main()
{
    int n=0;
    int ret=0;
    scanf("%d",&n);
    //递归方法：
    //Fib<=2时为1
    //Fib>2时为Fib(n-1)+Fib(n-2)
    ret=Fib(n);
    printf("ret=%d\n",ret);
    return 0;
}

汉诺塔问题

(三个柱子，第一个上面有几个从小到大的圆盘，要求按原顺序移动到另一个柱子上，一次只能挪1个，最少需要几步？)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
```



## 青蛙跳台问题

#### (n个台阶，1次可以跳一个台阶，也可以跳两个台阶，这只青蛙要跳到第n个台阶上，有多少种跳法）

## 用人民币一元兑换1分，2分，5分硬币，共有多少种不同换法

```c++
#include<stdio.h>
main()
{
	int c1, c2, c5, cnt = 0;
	printf("1元硬币有以下兑换方法：");
	for(c1=0;c1<=100;c1++)
		for(c2=0;c2<=50;c2++)
			for(c5=0;c5<=20;c5++)
				if (c1 * 1 + c2 * 2 + c5 * 5 == 100) 
				{
					printf("%3d个1分硬币，%3d个2分硬币，%3d个5分硬币\n", c1, c2, c5);
					cnt++;
				}
	printf("共有%d种方法\n", cnt);
}

请编写函数,将含有数字的字符串,实现将字符串中从左至右的数字提出并按提出顺序组成一个新的整型数据。 (要求使用字符数组和字符指针来实现)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<stdio.h> 
int find(char *p)
{
int t,s=0; 
while (*p)  
{if ((*p)>='0' &&(*p)<='9')  
  {
    t=(*p)-'0';
    s=s*10+t;  //*10的目的，让数组中的数字，从大到小依次对于这个新的整形数据的各十百千...位
  } 
p++;} 
return s;
}
void main( )
{
  char s[80]; 
  printf("请输入一串含有数字的字符串:\n");
  gets(s);
  printf("字符串%s中的数字字符组成的整数为:\n",s);
  printf("%d\n",find(s));
}

输入一个八进制数字字符串，函数convert将其转换成十进制数后输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include<stdio.h>
int convert(char *p)
{
  int n=0,a[6]; 
    while(*p) 
    { 
      n=n*8+*p-'0';//进制转换 
      p++;  
    }  
    return n;
}
main()
{
	char s[6];
	int a;
    printf("请输入一个8进制数字的字符串: ");
	gets(s);
	a=convert(s);
	printf("%d\n",a);
}
/*采用的具体方法是余除法，例如八进制数12，取余分解出最低位为2，再乘以相应的权重，由于是最低位，所以权重是8的0次方=1；再用12/10，进行下一轮循环，取余分解出最低位1，再乘以相应的权重，权重为8的一次方=8，累加起来为2+8=10，所以相对于的十进制数为10*/
#include<stdio.h>
#include<math.h>
int Trans(int n)
{
    int sum=0;
    int i=0;
    while(n)
    {
        sum+=(n%10)*pow(8,i++);
        n/=10;
    }
    return sum;
}
main()
{
    int n;
    printf("请输入一个八进制数:");
    scanf("%d",&n);
    printf("转化为十进制数为:");
    printf("%d",Trans(n));
}

调用函数用指针实现将某字符串复制到一个空字符串的功能（要求在主函数中输入字符串，并输出复制后的结果）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
void fun(char *s,char *t)
{
    while(*s!='\0')
    {
        *t++=*s++;//使每个数组元素都复制到空zi'fu
    }
    *t='\0';//使复制完成后以\0结尾，方便打印
}
main()
{
    char s1[100],s2[100];
    printf("input s1:\n");
    gets(s1);
    fun(s1,s2);
    printf("s2 is %s\n",s2);
}

输出1到100之内共有多少个完数（完数是指一个数的因子之和等于这个数本身，例如6=1+2+3 那么6就是一个完数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int fun(int N)
{
    int i,x,sum=0,n=0;
    for(x=1;x<=N;x++)//检测1到100之内的数，x是要检测的数，n是1到100中完数的个数
    {
        sum=0;//每次循环都要归零
        for(i=1;i<x;i++)//用i试除看此时的i是不是x的因数
        {
            if(x%i==0)//说明此时i是x的因数
                sum+=i;
        }
        if(x==sum)//判断因字数之和等不等于其本身(注意这个if条件语句的位置)
            n++;
    }
    returm n;
}
main()
{
  int sum=0,M=100; void NONO();
  sum=fun(M);
  printf("共有完数个数为:%d\n",sum);
}

pi的估算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
//1+1*1/3+1*1/3*2/5+...
int main()
{
    double s=2.0,t=2.0;
    int i=1,j=3;
    while(t>1e-16)
    {
        t=t*i/j;
        s=s+t;
        i++;
        j=j+2;
    }
    printf("pi=%.10lf\n",s);
}