Markdown

1，从键盘输入一个整数判断该数是否为素数

思路：
质数又称素数，指在一个大于1的自然数中,除了1和此整数自身外,没法被其他自然数整除的数.例如：2、3、5、7、11、13。
整除是指整数a除以自然数b除得的商正好是整数而余数是零.我们就说a能被b整除(或说b能整除a)。
判断是否为素数需要从2遍历到本身，并判断整除遍历余数是否为0若不为0且不等于本身则为素数。

关键代码：

int a,b,c;
scanf("%d%d%d",&a,&b,&c);//键盘输入abc
printf("a=%d,b=%d,c=%d\n",a,b,c);//打印abc，并换行

代码实现：

#include <iostream>

using namespace std;

void c(int a)
{

for(int i=2;i<a;i++)
{
 if(a%i==0)
 {
 printf("%d不是素数",a);
 return;
 }
 else
 {
 if(a==i)
 {
 printf("%d不是素数",a);
 return;
 }
 }
}
printf("%d是素数",a);
}
int main()
{
    int d=0;
    printf("请输入:");
    scanf("%d",&d);
    if(d>2)
    {
    c(d);
    }
    else {
    printf("%d不是素数",d);
    }
    return 0;
}

法二：

ispercham(int num)
{
    if(num==1)
    {
        return 0;
    }
    int m=0;
    m=sqrt(num);
    for(int i=2;i<m;i++)
    {
        if(num%i==0)
        {
            return 0;
        }
    }
    return 1;
}

void main()
{
    int nums=0;
    scanf("%d",&nums);
    while (nums>0)//输入-1代表测试结束
    {
        int ret=isperchem(nums);
        if(ret=1)
        {
            printf("yes%d",nums);
        }
        else
        {
            printf("no%d",nums);
        }
        scanf("%d",&nums);
    }
}

**

2.计算1到20000以内所有的水仙花数，水仙花是每位数字的n次方之和等于本身，n是这个数的位数。

**
思路：

**

3,输入前9位斐波那契数列

**

            int main()
            {
                int a=0;
                scanf("%d",&a);
                PrintFibonachi(a);
            }
            void PrintFibonachi(int a)
            {
                int a1、a2=1;
                int sum=0;
                printf("1");
                printf("1");
                for(int i=1;i<a;i++)
                {
                    sum=a1+a2;
                    a1=a2;
                    a2=sum;
                    printf("%d\n",sum);
                }
            
            }

正确：

    void fn(int a1,int a2,int n)
    {
        if(n>0)//这里没有for，递归本身就是for
        {
            printf("%d",a1+a2);
            fn(a2,a1+a2,n-1);
        }
        
    }
    void fibo(int a);
    {
        if(a==1)
        {
            printf("%d\n",1);
        }
        else
        {
            printf("%d,%d",1,1);
        }
        fn(1,1,a-2); //从第三项开始累加
    }
    void main()
    {
        int a=0;
        scanf("%d",a);
        while(a!=0)
        {
            getFibo(a);
            scanf("%d",a);
        }
    }

4.输入一行以空格分格的英文，判断其一共有多少单词，不能包括冠词a，例如：A big dog 一共两个单词。

注：
1.'\0’是字符串结束符，ascii码是0；
‘ ’是空格，代表一个显示为空白的字符，ascii码为32，ascii码中有很多不可见字符，但是都有自己的独特意义。
2.初始定义字符串时char a[1000];
在函数中用到a这个字符串时,使用规则如下
function（a）;//此时a为指针
function(int a) //定义入参为指针地址
{
int b=a;//用到传入的指针值
}
3.
1、 gets可以接收空格；而scanf遇到空格、回车和Tab键都会认为输入结束，所有它不能接收空格。
例如：如果输入为"hello world"时，上面程序的运行结果是"hello world"。而如果用scanf则只能输出hello
2、scanf 对末尾回车符的处理：把回车符保留在缓存中。gets对末尾回车符的处理：接收回车，但把回车替换为\0.
3、gets的返回值为char型，当读入成功时会返回输入的字符串指针地址，出错时返回NULL；scanf返回值为int型，返回实际成功赋值的变量个数，当遇到文件结尾标识时返回EOF。
4、gets函数仅用于读入字符串；scanf为格式化输出函数，可以读入任意C语言基础类型的变量值，而不是仅限于字符串(char)类型。

正解：

    bool judgeWord(int *b,int wordlength)
    {
        if(wordlength=1&&(*b!='A'&& *b!='a'))
        {
            return 1;
        }
        return 0;
    }
    int NumwordIn(char *a)
    {
        int num=0;
        while('\n'!=*a)
        {
            char arraysize[10]={0};
            int arraynum=0;
            while(('\n'!=*a)&&(' '!=*a))
            {
                arraysize[arraynum]=*a;//数组名是首地址
                ++arraynum;
                ++a;
            }
            int judge =judgeWord(arraysize,arraynum);
            if(judge==1)
            {
                ++num;
            }
            while(('\n'!=*a)&&(' '==*a))
            {
                ++a;
            }
        }
        return num;
    }
    void main()
    {
        char sentence[1000];
        gets(sentence);
        printf("%d\n",sentence);
        int ret =NumwordIn(sentence);
        printf("%d\n",ret);
    }

5.将三个字符串由小到大排序

**一、strcmp() 函数

*注解：函数原型：
int strcmp(const char str1, const char str2)
参数
str1 – 要进行比较的第一个字符串。
str2 – 要进行比较的第二个字符串。
返回值
该函数返回值如下：
如果返回值 < 0，则表示 str1 小于 str2。
如果返回值 > 0，则表示 str1 大于 str2。
如果返回值 = 0，则表示 str1 等于 str2。
即：两个字符串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇’\0’为止。如：
1.“A”<“B” 2.“A”<“AB” 3.“Apple”<“Banana” 4.“A”<“a” 5.“compare”<“computer”
二、strcpy() 函数
函数原型：
char strcpy(char dest, const char src);
功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间；
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
正文：

    #include "stdio.h"
    #include "string.h"
    swap(char *a,char *b)
    {
        char num[100]={0};
        strcpy(num,a);
        strcpy(a,b);
        strcpy(b,num);
    }
    void getsequence(char *a,char *b,char *c)
    {
        if(strcmp(a,b)>0)
        {
            swap(a,b)
        }
        if(strcmp(a,c)>0)
        {
            swap(a,c);
        }
        if(strcmp(b,c)>0)
        {
            swap(b,c);
        }
        printf("%c,%c,%c\n",a,b,c)
    }
    void main()
    {
        char low[10]={0};
        char middle[10]={0};
        char high[10]={0};
        gets(low);
        gets(middle);
        gets(high);
        getsequence(low,middle,high);
    }

6.一篇文本中有三行文字，每行不多余5个字符，要求分别统计出每行中的大写字母，小写字母、数字空格以及其他字符的个数。

注解：'\0’表示ASCII编号为0的字符，在C语言中最常用于代表字符串结束的标志。
'\n’表示ASCII编号为13的字符，代表回车键，输出这个字符就会换一行。
'\0’作为字符串的结束标志，本身会占用一个字符。所以要存一个最长5个字节的字符串，至少要有6个字节来存放，即char str[6]。
正文：

judge(char *c,int a)
    {
        int Big=0;
        int Small=0;
        int Nnum=0;
        int Kkongge=0;
        int Oother=0;
        for(int i=0;i<a.i++)
        {
            if(c[i]>'a'&&c[i]<'z')//是a到z不是a到j
            {
                ++Small;
            }
            else if(c[i]>'A'&&c[i]<'Z')
            {
                ++Big;
            }
            else if(c[i]>'0'&&c[i]<<'9')//是0到9而不是1到9
            {
                ++Num;
            }
            else if(c[i]==' ')
            {
                ++Num;
            }
            else
            {
                ++Oother;//遇到你没有办法通过程序去判别的，你就先把确定的写出来，不确定的写到else里
            }
        }
        printf("%d,%d,%d,%d,%d",Big,Small,Nnum,Kkongge,Oother);
    }
    chargetln(char *c)
    {
        int num;
        char Array[100];
        int Arraynum;
        while(('\0'!=*c))
        {
        while(('\n'!=*c)&&('\0'!=*c))
        {
            Array[Arraynum]=*c;
            ++c;
            ++Arraynum;
        }
        judge(c,Arraynum);
        while(('\n'==*c)&&('\0'!=*c))
        {
            ++c;
        }
        }

    }
    void main()
    {
        char cc[100]={1dveA 2W@\n,2cAAFwq2 f $\n,aa};
        printf("%c\n",cc);
        chargetln(cc);
    }

最新总结：当你发现某一块让你十分逻辑混乱你就拿出来单独建立个函数。

7,有一行电文，译码规律为：a->z,b->y,c->x,把第一个字母变成第26个字母，第i个变成第（26-i+1）个，非字母字符不变。

注解：关于%s打印string和char*
①void main()
{
string aa=“qqq”;
printf(“%s”,aa.c_str()); //把 string类 的对象里的字符串 转换成 C 中 char 型变量的字符串，c_str() 以 char* 形式传回 string 内含 //字符串

//或者cout<<a；
}

②用字符数组来输入输出

char * a=“abdcd”;

scanf(“%s”,a);

printf(“%s\n”,a);
’
③/* #include<stdio.h>
int main(void) {
char op[20] = { “123” };
char*p = op;
//op是指针(地址),*op是值,p是指针,*p是值
printf(“%s”, op);//=>一串 =>op是指针(地址)或者printf(“%s”,p);=>p是指针
return 0;
}=>输出123
*/

正文：

void switchChar(char *a)
{
    while(*a !='\n')
    {
        
        if(*a>'a'&&*a<'z')
        {
            *a =(26-(*a-'a')-1)+'a';
        }
        else if(*a>'A'&&*a<'Z')
        {
            *a =(26-(*a-'A')-1)+'A';
        }
        ++a;

    }
    printf("%s\n",a);//定义字符串直接用%s打印,s直接给首地址即可
}
void main()
{
    char cc[]={"abt145~@3 sadz"};
    switchChar(cc);
}

8.将两个字符串连接起来。不用stract函数

错误：
void plus(char *c,char *d )
{
char *p=c;
while(*c!="\0")
{
++c;
}
c=d;//错在了c和d只是指针不能改变地址，值固定存在了原地址的位置（随机），现在你把d的首地址给到c的末地址只是指向变了，值还是没过来,若你想在指定地址赋值你要采用指针数组的形式，如正解所示
printf("%s\n",p);//起始地址开始搜索
}
void main()
{ 
	char c[100]={1fw3WGW~12 \nddqdv+ \n"};
	char d[100]={1fw3WGW~12 \nddqdv+ \n"};
	plus(c,d);
}
正确：
#include <stdio.h>
void plus(char *ptr1,char *ptr2)
{
 char *p=ptr1;//只是遍历的作用，指向有值的地址才有用
 int length =0;
 while(p!="\0")
 {
 ++p;
 ++length;
 }
 p=ptr2;
 while(p!="\0")
 {
 ptr1[length]=*p//此处为字符数组，ptr[0]就是首位置，而不是函数的指针，要是这么定义的话就是个随机地址了。
 ++length;
 ++p;
 }
 ptr1[length]='\0';//注意是'\0','\n',而不是双冒号
 printf（"%s\n",ptr1）;
}


void main()
{ 
	char c[100]={1fw3WGW~12 \nddqdv+ \n"};
	char d[100]={1fw3WGW~12 \nddqdv+ \n"};
	plus(c,d);
}

**

9.将两个字符串s1,s2进行比较，如果s1>s2，输出一个正数；如果s1=s2则输出零；如果s1<s2则输出一个负数。不用strcmp函数，输出的正数或者负数的绝对值应该是比较两字符串相应字符的ascii值。

**
注解：‘\0’结束符的ascii值为0

正解：

Strcmp(char *ptr1,char *ptr2)
{
	int d=0;
	while((*ptr1!='\0')||(*ptr1!='\0'))
	{
		d=*ptr1-*ptr2;
		if(d!=0)//!!!!!!!!!这个不要忘记啊，这个条件是除了全都遍历一遍后，唯一的结束条件也是题目要求
		{
		break;//直接退出当前循环
		}
		++ptr1;
		++ptr2;
	}
	d=*ptr1-*ptr2;//避免跳出循环时一个结束了另外一个没结束
	return d;
}

void main()
{
	int d=0;
	char a[100];
	char b[100];
	gets(a);
	gets(b);//使用gets时进去的也是地址
	d=Strcmp(a,b);
	printf("%d\n",d);
}

**

10.将字符串数组S2中全部字符全部复制到S1中，不用strcpy函数

**

正文：

strcpy(char *a,char *b)
{
	int i=0; 
	while(*b!='\0')
	{
		a[i]=b[i];
		i++;
	}
	a[i]='\0';/一定要加这个  字符串相关操作要考虑结束符，在拼接哪里的最后以为也加了
	printf("%s\n",a)
}

void main()
{
	char a[100];
	char b[100];
	gets(b);
	strcpy(a,b);
}

**

11.用时间最短的方法将负数全部排在正数的前面，比如：-4，-6，-3，-2，-1，0，2，5，1.

**
注解：①动态计算数组长度：sizeof(arr)/sizeof(arr[0]);
②
全部初始化：int a[3]={1,2,3};
局部初始化：int a[3]={1,2}；(没有给定初值的元素默认为0值) //这个事故我想要的结果
默认初始化：int a[]={1,2,3};（数组的元素由给定初值的个数决定）

正解：

    MoveNegative(int *a,int length)
    {
        int low=0;
        int high=length-1;
        while(low<high)
        {
            while(a[low]<=0&&(low<high))//易错点在这里要用while循环找到大于0点，至于此处等于0就是不作考虑
            {
                ++low;
            }
            while(a[high]>0&&(low<high))//同理
            {
                --high;
            }
            if(low<high)
            {
                int temp;
                temp=a[low];
                a[low]=a[high];
                a[high]=temp;
                low+=1;//更新下一次开始查找的位置
                high-=1;
            }

        }
    }
    void main()
    {
        int cc[9]={1,3,-1,4,2,-9,-5,2,-1};
        MoveNegative(cc,9);
        for(int i=1;i<9;i++)
        {
            printf("%d\n".cc[i]);
        }
    }

**

12.数组a和b各有10个元素，将他们相同位置逐个比较，如果a中元素大于b中相应元素的次数多于b数组中元素大于a中元素次数，则认为a大于吧，请统计大于小于等于的次数。

**
正文：

void JudgeSize(char *a,char *b)
{
	int Max=0,Middle=0,min=0;
	int i=0;
    while((*a!='\0')||(*b!='\0'))
    {
		if(a[i]>b[i])
		{
		++Max;
		}
		else if(a[i]<b[i])
		{
		++Min;
		}
		else
		{
		++Middle;
		}
    }
    if(Max>Min)
    {
    printf("a大于b，大于次数%d\n",Max);
    }
    else if(Max>Min)
    {
    printf("a小于b，小于次数%d\n",Min);
    }
    else
    {
    printf("a等于b，等于次数%d\n",Middle);
    }
}
void main()
{
	char a[10];
	char b[10];
	gets[a];
	gets[b];
	JudgeSize(a,b);
}

**

13.编写函数，使输入的字符串按反序存放

**
注解：数值型数组中未被赋值的元素默认为0，而字符数组中未被赋值的元素默认为\0（即空字符）

正文：

switch(char *array)
{
	int *ptr=array;
	int length=0;
	while((*ptr)!='\0')
	{
		++length;
		++ptr;
	}
	int low=array;//注意此时的起始地址不是0是随机地址，在初始赋值的时候写low=0，若是第二次通过scanf赋值的话写low=array
	int high=array+length-1;
	while(low<high)
	{
		temp=array[low];
		array[low]=array[high];
		array[high]=temp;
		low++;
		high--;
	}
}

void main()
{
	char c[10];//赋值字符数组单引号是一个，双引号是赋值全部,本题让你自己输入而不是开始时固定,与前者相比本题的难度在于你要多出一步去判断数组大小而不是直接传入。
	scanf(c);
	printf("1%s\n",c);
	switch(c);
	printf("2%s\n",c);//数组打印直接用这种方法即可，注掉的也可
	//for(int i=0;i<10;i++)
	//{
	//printf("%d",c[i]);
	//}
}

**

14.求Sn=a+aa+aaa…+aaan，其中a为一个数字，一共有n项，a和n由用户的键盘输入。

**
正文：

#include <stdio.h>
int PLUS(a,n)
{
int S=0;
int p=0
for(int i=1;i<n+1;i++)
{
    //p=a*10+a;难点在于Sn的算法，像我这么写的话没有办法把a加进去，也就是S1直接就是aa了而不是a
    p=p*10+a;
	S=S+p;
}
return S;
}
void main()
{
	int a=0;
	int n=0;
	int Sn=0;
	scanf("%d",&a);
	scanf("%d",&n);
	Sn=PLUS(a,n);
	printf("%d\n",Sn);
}

**

15.设计一个函数process,在你调用该函数的时候，每次实现不同的功能。输入a,b两个数，第一次调用时找出a,b中最大者。第二次找出最小者，第三次求两个数的和。

**

注释：
“1、switch语句中，必须至少有一个case，case里必有break;
也必须有default，有没有break都可以。”
示例："反例一：
switch (arg)
{
// case 1:
// cout << "“1"”;
default:
break;
}
反例二：
switch (arg)
{
case 1:
cout << ““1"”;
}”
“1、在反例一中，没有case，故错误。
2、在反例二中，没有default，故错误。”

正文：

int Choose(int a,int b)
{
	static int time=0;//本题考点在staic应用1，定义变量时非本cpp调用不了。2，在定义函数时，非本cpp调用不了，除非用一个非staic函数包括一下staic函数，外部调用非static就可以调用static了，实现数据保护。3、static定义的局部变量存在全局区在整个程序运行区间不会销毁，一直存在，本题就使用此性质。
	time +=1;
	switch(time)
	{
		case 1:
		{
			if（a>b）
			{
				return a;
			}
			else{
			return b;}
			break;
		}
		case 2:
		{
			if (a<b)
			{
				return b;
			}
			else{
			return a;}
			break;
		}
		case 3:
		{
			return a+b;
			break;
		}
		default:
		{
		printf("xixixi");
		break;
		}
	}
}

void main()
{
	int a=0;
	int b=0;
	scanf("%d",a);
	scanf("%d",b);
	printf("%d\n”,Choose(a,b));
	printf("%d\n”,Choose(a,b));
	printf("%d\n”,Choose(a,b));	
}

**

16.输入某年某月某日，判断这一天是该年的第几天

**
注解：
一、闰年的判定方法：
①、普通年能被4整除且不能被100整除的为闰年。（如2004年就是闰年，1900年不是闰年）
②、世纪年能被400整除的是闰年。（如2000年是闰年，1900年不是闰年）
二、
问：typedef struct Data {
int id;
char name[50];
} Data;中struct后面的Data和}后面的Data有什么区别？？？
答：
在C语言中，typedef用于创建新的类型别名。在你的代码示例中，typedef struct Data开始定义一个新的结构体类型，并为其创建一个别名Data。
struct Data是结构体的实际名称，而Data是使用typedef创建的别名。它们指的是相同的数据类型，但是使用Data会更加简洁和方便。
因此，当你声明一个变量时，你可以使用Data作为结构体类型的名称，例如：
c
Data d1;
在这个例子中，d1是一个结构体类型的变量，包含一个整型的id和一个字符数组name。
总结来说，struct Data是实际的结构体类型名称，而Data是通过typedef创建的别名，用于简化代码和提高可读性。
d.在switch中的语言角度将不一定有break和default的，这样的话程序就回一直向下走，直到没有对应的case退出，这不是一个好习惯
正文：

	typedef struct Data
    {
        int year;
        int month;
        int day;
    }Data;
    int Calculatetime(Data date)
    {
        int num=0;
        switch(data.month-1)
        {
            case 11:num+=30;
            case 10:num+=31;
            case 9:num+=30;
            case 8:num+=31;
            case 7:num+=31;
            case 6:num+=30;
            case 5:num+=31;
            case 4:num+=30;
            case 3:num+=31;
            case 2:num+=30;//假如此时为3月 case1+case2+data.day
            case 1:num+=31;//假如此时为2月 case1+data.day
        }
        return num;
    }
    int Getdays(Data date)
    {
        int num =0;
        if(data.month==1)
        {
            return data.day;
        }
        num=Calculatetime(data);
        if((data.year%4==0&&data.year%100!=0)||data.year%400!=0)//闰年
        {
            num=num+1+data.day;
        }
        else
        {
            num=num+data.day;
        }
        return num;
    }
    void main()
    {
        int t=0;
        Data data={0,0,0}
        scanf("%d",data.year);
        scanf("%d",data.month);
        scanf("%d",data.day);
        t= Getdays(data);
    }

**

17.有n个正数，使得前面每个数依次向后移动m个位置，最后m个数变成最前面m个数。

**
正文：

void prrintfCC(int length,char *a)
{
	for(int i=0;i<length;i++)
	{
	printf("%d",a[i]);
	}
	printf("\n");
}
void turnover(char *cc/int cc[],int left,int right)//以上两种一维数组定义都可以
{
	int temp=0;
	for(int i=left,j=right;i<j;i++,j--)
	{
		temp=cc[i]'
		cc[i]=cc[j];
		cc[j]=temp;
	}
}
void main()
{
	int cc[7]={1,2,3,4,5,6,7};
	prrintfCC(7,cc);
	int n=7;
	int m=0;
	scanf("%d",&m);
	turnover(cc,0,n-m-1);
	turnover(cc.0,m-1);
	turnover(cc,m,n-1);
	prrintfCC(7,cc);
	
}

**

18.编写一个函数 void exchange(char *str1,char *str2,int a,int b),将字符创str1中第a个字符到b个字符结束的位置替换成str2。

**
正文：

#include <stdio.h>
#include <string.h>
int strlen(char *str)
{
    char *p=str;
    int number =0;
    while(*p!='\0')
    {
        number++;
        p++;
    }
    return number;
}
//思路1.如果str2的个数不等i到j就退出；2遍历扫描将str2赋值给str1基础上+a-1个单位的字母。
int exchange(char *str1,char*str2,int a,int b)
{
    int c=strlen(str2);
    if(c!=b-a+1)
    {
        return 0;
    }
    int head=a-1;
    int tail=b-1;
    char *p=str2;
    while(*p!='\0'&&(head>tail))//此处注意不是p！=‘\0‘，而是*p!='\0'
    {
        *(str1+head)=*p;
        ++p;
        ++head;
    }
    return 1;

}

void main()
{
    char *str1={"geuihubhe"};
    char *str2={"mmm"};
    int l,h;
    scanf("%d",l);
    scanf("%d",h);
    exchange(str1,str2,l,h);
}

**

19.有一分数序列2/1、3/2、5/3、8/5、13/8…。求前20项和。

**
正文：

//仅仅写出核心步骤
int i=2,j=1;
int sum=0;
for(int i=0;i<20;i++)
{
sum=i*1.0/j;//int->double
i+=j;
j=i-j;//重要的是j取i累加后的值在减j也就正好是i的值赋给j,省的加temp进行swap了
}

**

20.打印10行杨辉三角

**
注解：
1.每个数等于它上方两数之和。
2.每行数字左右对称，由1开始逐渐变大。
3.第n行的数字有n项。
4.前n行共[(1+n)n]/2 个数。
5.第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。
6第n行的第m个数和第n-m+1个数相等 ，为组合数性质之一。
7.每个数字等于上一行的左右两个数字之和。可用此性质写出整个杨辉三角。即第n+1行的第i个数等于第n行的第i-1个数和第i个数之和，这也是组合数的性质之一。即 C(n+1,i)=C(n,i)+C(n,i-1)。
8.(a+b)n的展开式中的各项系数依次对应杨辉三角的第(n+1)行中的每一项：
与杨辉三角联系最紧密的是二项式乘方展开式的系数规律，即二项式定理。例如在杨辉三角中，第3行的三个数恰好对应着两数和的平方的展开式的每一项的系数（性质 8），第4行的四个数恰好依次对应两数和的立方的展开式的每一项的系数，即
，以此类推。

正文：

            #include <stdio.h>
            #include <stdlib.h> //这个是malloc的库文件
            void getYangHui(int line)
            {
                int a[10][10]={0};//静态创建数组
                int *pMartix=(int *)malloc(sizeof(int)*n*n);//动态创建数组
                for(int row=0;row<line;row++)
                {
                    for(int col=0;col<line;col++)
                    {
                        *(pMartix+row*line+col)=1;
                    }
                }
                for(int row=2;row<line;row++)
                {
                    for(int col=1;col<line;col++)
                    {
                        *(pMartix+row*line+col)=*(pMartix+(row-1)*line+col)+*(pMartix+(row-1)*line+col-1);
                    }
                }
                for(int row=0;row<line;row++)
                {
                    for(int col=0;col<line;col++)
                    {
                        printf("%d\n",pMartix[row][col]);//此处可以用指针表示法*(pMartix+row*line+col)。或者数组表示法都可
                    }
                }
            }
            void main()
            {
                int Yang[10][10]={0}//定义静态二维数组
                int n=0;
                scanf("%d",&n);
                getYangHui(n);
            }

**

21.n个人围城一圈并按顺序排号，从第一个人开始报数，凡是报到3的人退出圈子，下一个人从1开始报号，请设计算法求解最后退出圈子的成员编号。

**
正文：

    //核心是三个变量，总数：每次找到一个减一；计数器：当数到3归零，并让数组值置1；数组值：初始全部置0当遇到count=3置1；这三个变量也作为判断条件出现在代码里
    PrintJosephCircle(int NemArray,int offsum)
    {
        int *pArray=(int*)malloc(sizeof(int)*NemArray);//sizeof后面接的是关键字
        memset(pArray,0,sizeof(int)*NemArray);
        int count =0;
        int remain=NemArray;
        while(1)
        {
            for(int i=0;i<NemArray;i++)
            {
                if((++count==3)&&(pArray[i]!=1))
                {
                    count=0;
                    pArray[i]=1;
                    remain-=1;
                    printf("%d\n",i+1);
                }
            }
            if(0>=remain)
            {
                break;
            }
        }

    }
    void main()
    {
        int NemArray,offsum;
        scanf("%d%d",&NemArray,&Offsum);
        PrintJosephCircle(NemArray,offsum);
    }

22.使用表尾指针指向的循环单链表来模拟n人的约瑟夫环。
正文1：

    #include <stdio.h>
    #include "malloc.h"
    typedef int elemtype;//定义变量要用typedef而不是define
    typedef struct CircularLinkNode
    {
        elemtype LDate;
        struct CircularLinkNode *nextNode;//注意此处把struct带上了
    }CircularLinkNode,*CircularLinkList;

    void createcircleLink(CircularLinkNode *&tailla,int *arra,int arraylength)
    {
        int index=0;
        if(tailla!=NULL)
        {
            CircularLinkNode *tmp=(CircularLinkNode*)malloc(sizeof(CircularLinkNode)));//什么时候需要开空间？
            tmp->LData=arra[inxex];
            index+=1;
            tailla=tmp;
            tailla->nextNode=tailla;
        }
        while(index<arraylength)
        {
            CircularLinkNode *tmp=(CircularLinkNode*)malloc(sizeof(CircularLinkNode)));
            tmp->LData=arra[index];
            tmp->LNext=tailla->LNext;
            tailla->LNext=tmp;
            tailla=tmp;
        }
    }
    void josephcircular(CircularLinkList tailla,int arraylength,int offsum)
    {
        int remainNodes =n ;
        CircularLinkNode *priornode=tailla;
        CircularLinkNode *nextnode=tailla->nextnode;
        int cntnum=1;//报数，从1开始报名
        while(remainNodes>1)
        {
            if(cntNum=offsum)
            {
                printf("%d:",nextnode->LData);
                priornode->LNext=nextnode->LNext;//删除节点
                free(nextNode);
                nextNode=priotnode->LNext;
                cntnum=1;
                remainNodes-=1;
            }
            else//没有报到9
            {
                priornode=nextnode;
                nextnode=nextnode->nextnode;
                cntnum+=1;
            }
        }
        printf("%d",nextnode->data);//就是剩余最后一个值
    }
    void main()
    {
        CircularLinkNode *tailla=NULL;
        int n=0;//定义船上的人数
        scanf("%d",n);
        int arra[100];
        for(int i=1;i<=n;i++)
        {
            arra[i-1]=i;
        }
        int arraylength= n;
        createcircleLink(tailla,arra,arralength);//从这考虑前面需要定义什么
        int offsum;
        scanf("%d",offsum);
        josephcircular(tailla,arralength,offsum);
    }

正文2:

            #include <stdio.h>
            #include "malloc.h"
            typedef int Elemtype;
            typedef struct CircleLinkNode
            {
                Elemtype Data;
                struct CircleLinkNode *Next;
            }CircleLinkNode,*CircleLinkList;
            CreateLinkNode(CircleLinkNode *&tailla,int *Array,int arraylength)
            {
                int index=0;
                if(tailla!=NULL)
                {
                    CircleLinkNode *tmp=(CircleLinkNode*)malloc(sizeof(int)*arraylength);
                    tmp->Data=Array[index];
                    index+=1;//在你创建完了以后不要忘记index加1
                    tail=tmp;
                    tail->Next=tail;
                }
                while(index<arraylength)
                {
                    CircleLinkNode *tmp=(CircleLinkNode*)malloc(sizeof(int)*arraylength);
                    tmp->Data=Array[index];
                    index+=1;
                    tmp->Next=tail->Next;
                    tail->Next=tmp;
                    tail=tmp;//就穿建了循环单链表，且最后一个tail在表尾
                }
            
            }
            void josephcircular(CircleLinkList tailla,int arraylength,int offsum)
            {
                int remain=arraylength;
                CircleLinkNode *priorNode=tailla;
                CircleLinkNode *nextNode=tailla->next;
                int cnt=1;
                while(reamin>1)
                {
                    if(cnt==offsum)
                    {
                        printf("%d",nextNode->data);
                        cnt=1;
                        priorNode->Next=nextNode->Next;
                        free(nextNode);
                        remain-=1;
                        nextNode=priorNode->Next;

                    }
                    else
                    {
                        priorNode=priorNode->Next;
                        nextNode=nextNode->Next;
                        cnt+=1;
                    }
                }
                printf("%d",nextNode->data);
            }
            void main()
            {
                CircleLinkNode *tailla=NULL;
                int Array[100];
                int n=0
                scanf("%d",n);
                int arraylength=n;
                for(int i=1;i<length;i++)
                {
                    Array[i-1]=i;
                }
                CreateLinkNode(tailla,Array,arraylength);
                int offsum=0;
                scanf("%d",offsum);
                josephcircular(tailla,arraylength,offsum);
            }

**

23.输入5个国家英文名，编写代码让英文名按照顺序排序

**
正文：

	#include<stdio,h>
	#include<string.h>
    sortcountry(char *pArray[30],int arraynum)//题目未禁止使用库函数，故此处可用
    {
        for(int i=0;i<arraynum;i++)
        {
            for(int j=0;j<arraynum-i;j++)
            {
                if(strcmp(pArray[j],pArray[j-1])<0)//顺序
                {
                    char tmp[30];
                    strcpy(tmp,pArray[j]);
                    strcpy(pArray[j-1],pArray[j]);
                    strcpy(pArray[j],pArray[j-1]);
                }
            }
        }
    }
    void main()
    {
        char country[5][30];
        for(int i=0;i<5;i++)
        {
            scanf("%d",country[i]);
        }
        sortcountry(country,5);
        for(int i=0;i<5;i++)
        {
            printf("%d",country[i]);
        }
    }

遥遥领先！！
**

24，有8个学生，每个学生选修3 门课程，学生选修课分数记录如结构体所示： typedef struct CoursesScore { int chinese; int english; int math; char name[10]; }CourseScore 请编写代码计算每个学生的平均分，总分，每门课程的总分，最后根据每个学生的总分进行排名，输出总成绩排名前三的学生信息。

**

正文1：

            #include <stdio.h>
            #define  Student_Num 8;
            #define Course_Num 3;
            typedef struct CoursesScore
            {
                int English;
                int Chinese;
                int Math;
                char name[10];
            }CoursesScore;
            typedef struct StudentsCoursesScore
            {
                CoursesScore score;
                int scoresum;
            }StudentsCoursesScore,StudentsCourses[Student_Num];

            void func(StudentsCourses beat)
            {
                int sum[Student_Num]={0};
                for(int i=0;i<8;i++)
                {
                    sum[0]+=beat[i].score.English;
                    sum[1]+=beat[i].score.Chinese;
                    sum[2]+=beat[i].score.Math;
                    beat.scoresum=beat[i].score.English+beat[i].score.Chinese+beat[i].score.Math;
                }
                for(int i=0;i<Course_Num;i++)
                {
                    for(int j=1;j<Student_Num-1;j++)
                    {
                        if(beat[j-1].scoresum>beat[j].scoresum)
                        {
                            StudentsCourses temp;
                            temp=beat[j-1];
                            beat[j-1]=beat[j];
                            beat[j]=beat[j-1];
                        }
                    }
                }
            }
            void main()
            {
                StudentsCourses beat={{1,4,3,"ca1",0},{1,5,3,"ca2",0},{1,7,3,"ca3",0},{1,25,3,"ca4",0},{1,6,3,"ca5",0},{1,8,3,"ca6",0},{1,4,3,"ca7",0},{1,11,3,"ca8",0},};//结构体的赋值方式挺特殊的，直接{}内{}
                func(beat);
                for(int i=7;i>4;i++)
                {
                    printf("%d%d%s",beat[i].scoresum,beat[i].scoresum/3.0,beat[i].score.name);
                }
            }