2019春第十一周作业

这个作业属于那个课程	C语言程序设计II
这个作业要求在哪里	第十一周作业要求
我在这个课程的目标是	能够对相对复杂的问题，合理定义程序的多函数结构；能够使用递归函数进行编程；掌握宏的基本用法；掌握编译预处理的概念
这个作业在哪个具体方面帮助我实现目标	锻炼了我的编程能力，加深了我对递归、结构的认识
参考文献	C语言程序设计II第十章

选择题

2-1
宏定义“#define DIV(a, b) a/b”，经DIV(x + 5, y - 5) 引用，替换展开后是（A）。 (1分)
x + 5 / y - 5
(x + 5 / y – 5)
(x + 5) / (y - 5)
(x + 5) / (y - 5);
作者: 张高燕
单位: 浙江大学城市学院
2-2
定义带参数的宏“#define JH(a,b,t) t = a; a = b; b = t”，对两个参数a、b的值进行交换，下列表述中正确的是（B）。 (1分) 改正：这个题应该选D.
不定义参数a和b将导致编译错误
不定义参数a、b、t将导致编译错误
不定义参数t将导致运行错误
不需要定义参数a、b、t类型
作者: 张高燕
单位: 浙江大学城市学院
2-3
如果所有的变量按照下面的程序进行定义和声明，那么在main()函数中所有可用的变量为 （C）。 (2分)
void fun(int x)
{
static int y;
……
return;
}
int z;
void main( )
{
int a,b;
fun(a);
……
}
x,y
x,y,z
a,b,z
a,b,x,y,z
作者: 李克峰
单位: 山东交通学院
2-4
如果一个变量在整个程序运行期间都存在，但是仅在说明它的函数内是可见的，这个变量的存储类型应该被说明为(A )。 (1分)
静态变量
动态变量
外部变量
内部变量
作者: 王从银
单位: 吉首大学
2-5
下面说法中正确的是（A）。 (1分)
若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度
若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度
设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑变量生命周期问题
静态全局变量使用过多，可那会导致动态存储区（堆栈）溢出
作者: 张高燕
单位: 浙江大学城市学院
2-6
凡是函数中未指定存储类别的局部变量，其隐含的存储类型为(A )。 (1分)
自动（auto）
静态（static）
外部（extern）
寄存器（register）
作者: 张高燕
单位: 浙江大学城市学院
2-7
在一个C源程序文件中，若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是D。 (1分)
extern
register
auto
static
作者: 张高燕
单位: 浙江大学城市学院
2-8
将一个函数说明为static后，该函数将 (B )。(1分)
既能被同一源文件中的函数调用，也能被其他源文件中的函数调用
只能被同一源文件中的函数调用，不能被其他源文件中的函数调用
只能被其他源文件中的函数调用，不能被同一源文件中的函数调用
既不能被同一源文件中的函数调用，也不能被其他源文件中的函数调用

7-1 汉诺塔问题* (10 分)

汉诺塔是一个源于印度古老传说的益智玩具。据说大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘，大梵天命令僧侣把圆盘移到另一根柱子上，并且规定：在小圆盘上不能放大圆盘，每次只能移动一个圆盘。当所有圆盘都移到另一根柱子上时，世界就会毁灭。

请编写程序，输入汉诺塔圆片的数量，输出移动汉诺塔的步骤。
输入格式
圆盘数 起始柱 目的柱 过度柱
输出格式
移动汉诺塔的步骤
每行显示一步操作，具体格式为：
盘片号: 起始柱 -> 目的柱
其中盘片号从 1 开始由小到大顺序编号。
输入样例
3
a c b
输出样例
1: a -> c
2: a -> b
1: c -> b
3: a -> c
1: b -> a
2: b -> c
1: a -> c

实验代码

#include<stdio.h>
void Hanot(int n,char a,char c,char b);
int main(void)
{
	int n;
    char a,c,b;
	scanf("%d %c %c %c",&n,&a,&c,&b);
	Hanot(n,a,c,b);
	
	return 0; 
 } 
 
 void Hanot(int n,char a,char c,char b)    //一定要注意！！这不是塔a,c,b。是字符变量a.c.b。所以它里面存的是字符a（塔），b（塔），c（塔）。作用是把字符变量a里的（塔）上的盘子移动到字符变量c里的（塔）上的盘子，借助字符变量b里的（塔）。
 {
 	if(n==1)
 	       printf("1: %c -> %c
",a,c);
 	else{
 		Hanot(n-1,a,b,c);                   //把a塔上的盘子移动到b塔，如果n>1,借助c塔。
 		printf("%d: %c -> %c
",n,a,c);
 		Hanot(n-1,b,c,a);                  //把b塔上的盘子移动到c塔，如果n>1,借助a塔。
	 }
 }

具体思路

具体思路：必须有三个塔才能搬，并且每个塔的作用可能每次都会不一样，所以就得把塔设定为字符变量，形参char a是被搬动的塔，char c是目标塔，char b是中间塔。

本题遇到的问题及解决方法

遇到的问题：看不懂，
解决的方法：和室友交流，一起沟通，在2019//5//9已经完全懂了怎么实现的了。

正确截图

7-2 估值一亿的AI核心代码 (20 分)

以上图片来自新浪微博。
本题要求你实现一个稍微更值钱一点的 AI 英文问答程序，规则是：
无论用户说什么，首先把对方说的话在一行中原样打印出来；
消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉；
把原文中所有大写英文字母变成小写，除了 I；
把原文中所有独立的 can you、could you 对应地换成 I can、I could—— 这里“独立”是指被空格或标点符号分隔开的单词；
把原文中所有独立的 I 和 me 换成 you；
把原文中所有的问号 ? 换成惊叹号 !；
在一行中输出替换后的句子作为 AI 的回答。
输入格式：
输入首先在第一行给出不超过 10 的正整数 N，随后 N 行，每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。
输出格式：
按题面要求输出，每个 AI 的回答前要加上 AI: 和一个空格。
输入样例：
6
Hello ?
Good to chat with you
can you speak Chinese?
Really?
Could you show me 5
What Is this prime? I,don 't know
输出样例：
Hello ?
AI: hello!
Good to chat with you
AI: good to chat with you
can you speak Chinese?
AI: I can speak chinese!
Really?
AI: really!
Could you show me 5
AI: I could show you 5
What Is this prime? I,don 't know
AI: what Is this prime! you,don't know

实验代码

#include<stdio.h>
#include<string.h>
int main(void)
{
	char str1[1001];
	static int i,a,x,y,N,b;
	
	scanf("%d
",&N);
	char str[N][1001];
	for(i=0;i<N;i++){              /*输入对话，存入二维数组*/ 
		gets(str[i]);
	}
	
	for(b=0;b<N;b++){               /*对输入的对话一行一行 进行改造*/ 
	i=0;
	a=0;
	x=0;
	while(str[b][i]!=''){               /*改造开始，以单个字母进行改变*/ 
		if(str[b][i]==' '&&x==1){          /*多个空格变成一个*/ 
			str1[a]=' ';
			a++;
			x=0;
		}
		
		if(str[b][i]!=' '){               /*清除符号前的空格*/ 
			if((str1[a-1]==' ')&&((str[b][i]<'a'||str[b][i]>'z')&&(str[b][i]<'A'||str[b][i]>'Z'))&&((str[b][i]<'0')||(str[b][i]>'9'))){
				if(str[b][i]=='?'){                       /*改变问号为叹号*/ 
					str1[--a]='!';
				    a++;
				    x=1;
				}
				else{
					str1[--a]=str[b][i];
				    a++;
				    x=1;
				}
			}
			else{
				if(str[b][i]<='Z'&&str[b][i]>='A'&&str[b][i]!='I'){       /*改大写为小写*/
					str1[a]=str[b][i]-'A'+'a';
			        a++;
			        x=1;
				}
				else{
					if(str[b][i]=='?'){                     /*改变问号为叹号*/
						str1[a]='!';
						a++;
					    x=1;
					}
					else{                               /*其他字母正常存入*/ 
						str1[a]=str[b][i];
					    a++;
					    x=1;
					}
				}
			}
		}
		i++;                      /*下一个字母*/ 
	}
	
	str1[a]='';                 /*添加字符串结束标记*/ 
	if(str1[a-1]==' '){           /*去掉字符串最后的空格*/ 
		str1[a-1]='';
	}
	
	i=0;
	while(str1[i]!=''){
		/*判断是否为can you*/
		if(str1[i]=='c'&&str1[i+1]=='a'&&str1[i+2]=='n'&&str1[i+3]==' '&&str1[i+4]=='y'&&str1[i+5]=='o'&&str1[i+6]=='u'){     
			if(((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+7]<'a'||str1[i+7]>'z')&&(str1[i+7]<'A'||str1[i+7]>'Z'))){ 
				str1[i]='I';                        /*判断can you是否独立（“独立”是指被空格或标点符号分隔开的单词）*/ 
			    str1[i+1]=' ';
			    str1[i+2]='c';
			    str1[i+3]='a';
			    str1[i+4]='n';
			    str1[i+5]='8';
			    str1[i+6]='8';
			    i+=7;                             /*减少判断量，从can you后的字符继续判断*/ 
			    continue;
			}
		}
		/*判断是否为could you*/
		if(str1[i]=='c'&&str1[i+1]=='o'&&str1[i+2]=='u'&&str1[i+3]=='l'&&str1[i+4]=='d'&&str1[i+5]==' '&&str1[i+6]=='y'&&str1[i+7]=='o'&&str1[i+8]=='u'){
			if(((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+9]<'a'||str1[i+9]>'z')&&(str1[i+9]<'A'||str1[i+9]>'Z'))){
				str1[i]='I';                        /*判断could you是否独立（“独立”是指被空格或标点符号分隔开的单词）*/
			    str1[i+1]=' ';
			    str1[i+2]='c';
			    str1[i+3]='o';
			    str1[i+4]='u';
			    str1[i+5]='l';
			    str1[i+6]='d';
			    str1[i+7]='8';
			    str1[i+8]='8';
			    i+=7;                             /*减少判断量，从could you后的字符继续判断*/
			    continue;
			}
		}
		 /*判断I是否独立（“独立”是指被空格或标点符号分隔开的单词）*/
		if(str1[i]=='I'&&((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+1]<'a'||str1[i+1]>'z')&&(str1[i+1]<'A'||str1[i+1]>'Z'))){
			str1[i]='7';
		}
		 /*判断me是否独立（“独立”是指被空格或标点符号分隔开的单词）*/
		if((str1[i]=='m'&&str1[i+1]=='e')&&((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+2]<'a'||str1[i+2]>'z')&&(str1[i+2]<'A'||str1[i+2]>'Z'))){
			str1[i]='5';
			str1[i+1]='6';
			i++;
		}
		i++;
	}
	/*输出改变后的字符串,'8'转义为空，（'5''6'）转义为you，'7'转义为you*/ 
	printf("%s
AI: ",str[b]);
	y=strlen(str1);
	for(i=0;i<y;i++){
		if(str1[i]=='8')
			continue;
		else if(str1[i]=='5'&&str1[i+1]=='6'){
			printf("you");
			i++;
			continue;
		}
		else if(str1[i]=='7'){
			printf("you");
		}
		else
		    printf("%c",str1[i]);
	}
	printf("
");
    }
    
}

优化后代码,用了三个自定义函数来实现功能，并容易修改及增加功能。

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

void change(char str[][1001],char str1[1001],int b);
void Specific_change(char str1[1001]);
void printf_(char str1[1001]);

int main(void)
{
    char str1[1001];
    static int i,N,b;
    
    scanf("%d
",&N);
    char str[N][1001];
    
    for(i=0;i<N;i++){              /*输入对话，存入二维数组*/ 
        gets(str[i]);
    }
    
    for(b=0;b<N;b++){               /*对输入的对话一行一行 进行改造*/ 
        change(str,str1,b);         //改成标准语句存入str1
        
        Specific_change(str1);      //改变特定的内容
    
        printf("%s
AI: ",str[b]);  
        printf_(str1);              ////输出原样字符和转义后的字符
    }
    
}

void change(char str[][1001],char str1[1001],int b)
{
	int i=0,a=0,x=0; 
	while(str[b][i]!=''){               /*改造开始，以单个字母进行改变*/ 
        if(str[b][i]==' '&&x==1){          /*多个空格变成一个*/ 
            str1[a]=' ';
            a++;
            x=0;
        }
        
        if(str[b][i]!=' '){               /*清除符号前的空格*/ 
            if((str1[a-1]==' ')&&((str[b][i]<'a'||str[b][i]>'z')&&(str[b][i]<'A'||str[b][i]>'Z'))&&((str[b][i]<'0')||(str[b][i]>'9'))){
                if(str[b][i]=='?'){                       /*改变问号为叹号*/ 
                    str1[--a]='!';
                    a++;
                    x=1;
                }
                else{
                    str1[--a]=str[b][i];
                    a++;
                    x=1;
                }
            }
            else{
                if(str[b][i]<='Z'&&str[b][i]>='A'&&str[b][i]!='I'){       /*改大写为小写*/
                    str1[a]=str[b][i]-'A'+'a';
                    a++;
                    x=1;
                }
                else{
                    if(str[b][i]=='?'){                     /*改变问号为叹号*/
                        str1[a]='!';
                        a++;
                        x=1;
                    }
                    else{                               /*其他字母正常存入*/ 
                        str1[a]=str[b][i];
                        a++;
                        x=1;
                    }
                }
            }
        }
        i++;                      /*下一个字母*/ 
    }
    str1[a]='';                 /*添加字符串结束标记*/ 
    if(str1[a-1]==' '){           /*去掉字符串最后的空格*/ 
        str1[a-1]='';
    }
} 

void Specific_change(char str1[1001])    /*转义，转换*/ 
{
    int i=0;
    while(str1[i]!=''){
        /*判断是否为can you*/
        if(str1[i]=='c'&&str1[i+1]=='a'&&str1[i+2]=='n'&&str1[i+3]==' '&&str1[i+4]=='y'&&str1[i+5]=='o'&&str1[i+6]=='u'){     
            if(((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+7]<'a'||str1[i+7]>'z')&&(str1[i+7]<'A'||str1[i+7]>'Z'))){ 
                str1[i]='I';                        /*判断can you是否独立（“独立”是指被空格或标点符号分隔开的单词）*/ 
                str1[i+1]=' ';
                str1[i+2]='c';
                str1[i+3]='a';
                str1[i+4]='n';
                str1[i+5]='8';
                str1[i+6]='8';
                i+=7;                             /*减少判断量，从can you后的字符继续判断*/ 
                continue;
            }
        }
        /*判断是否为could you*/
        if(str1[i]=='c'&&str1[i+1]=='o'&&str1[i+2]=='u'&&str1[i+3]=='l'&&str1[i+4]=='d'&&str1[i+5]==' '&&str1[i+6]=='y'&&str1[i+7]=='o'&&str1[i+8]=='u'){
            if(((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+9]<'a'||str1[i+9]>'z')&&(str1[i+9]<'A'||str1[i+9]>'Z'))){
                str1[i]='I';                        /*判断could you是否独立（“独立”是指被空格或标点符号分隔开的单词）*/
                str1[i+1]=' ';
                str1[i+2]='c';
                str1[i+3]='o';
                str1[i+4]='u';
                str1[i+5]='l';
                str1[i+6]='d';
                str1[i+7]='8';
                str1[i+8]='8';
                i+=7;                             /*减少判断量，从could you后的字符继续判断*/
                continue;
            }
        }
         /*判断I是否独立（“独立”是指被空格或标点符号分隔开的单词）*/
        if(str1[i]=='I'&&((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+1]<'a'||str1[i+1]>'z')&&(str1[i+1]<'A'||str1[i+1]>'Z'))){
            str1[i]='7';
        }
         /*判断me是否独立（“独立”是指被空格或标点符号分隔开的单词）*/
        if((str1[i]=='m'&&str1[i+1]=='e')&&((str1[i-1]<'a'||str1[i-1]>'z')&&(str1[i-1]<'A'||str1[i-1]>'Z'))&&((str1[i+2]<'a'||str1[i+2]>'z')&&(str1[i+2]<'A'||str1[i+2]>'Z'))){
            str1[i]='5';
            str1[i+1]='6';
            i++;
        }
        i++;
    }
}

void printf_(char str1[1001])     /*输出改变后的字符串,'8'转义为空，（'5''6'）转义为you，'7'转义为you*/
{
    int i,y; 
    y=strlen(str1);
    for(i=0;i<y;i++){
        if(str1[i]=='8')
            continue;
        else if(str1[i]=='5'&&str1[i+1]=='6'){
            printf("you");
            i++;
            continue;
        }
        else if(str1[i]=='7'){
            printf("you");
        }
        else
            printf("%c",str1[i]);
    }
    printf("
");
} 

实验思路

具体思路：看代码后的注释，还有思路图就很明了了。
其实呢，能把具体实现步骤改成三个自定义函数的，第一个函数是改成标准语句存入str1.：用void change(char str[][1001],char str1[1001],int b)；这个函数解决。第二个函数是改变特定的内容，比如（I)和(me）改成（you），比较方便添加一些其他的特定内容，用void Specific_change(char str1[1001]).第三个函数是用来输出的，输出原样字符和有意义的字符，用void printf_(char str1[1001]);来实现。

本题做对过程中遇到的问题及解决方法

嗯········，问题太多，不一 一表述了，这是遇到的最后一个问题。

遇到的问题：判断me后面一个字符是否为空格或其他字符的的时候，应该是str1[i+2]，而不是str1[i+1].
解决方法：把str1[i+1]全改成str1[i+2]，

正确截图

7-3 ***八皇后问题 (20 分)

在国际象棋中，皇后是最厉害的棋子，可以横走、直走，还可以斜走。棋手马克斯·贝瑟尔 1848 年提出著名的八皇后问题：即在 8 × 8 的棋盘上摆放八个皇后，使其不能互相攻击 —— 即任意两个皇后都不能处于同一行、同一列或同一条斜线上。
现在我们把棋盘扩展到 n × n 的棋盘上摆放 n 个皇后，请问该怎么摆？请编写程序，输入正整数 n，输出全部摆法(棋盘格子空白处显示句点“.”，皇后处显示字母“Q”，每两格之间空一格)。
输入格式
正整数 n (0 ＜ n ≤ 12)
输出格式
若问题有解，则输出全部摆法(两种摆法之间空一行)，否则输出 None。
要求：试探的顺序逐行从左往右的顺序进行，请参看输出样例2。
输入样例1
3
输出样例1
None
输入样例2
6
输出样例2
. Q . . . .
. . . Q . .
. . . . . Q
Q . . . . .
. . Q . . .
. . . . Q .

. . Q . . .
. . . . . Q
. Q . . . .
. . . . Q .
Q . . . . .
. . . Q . .

. . . Q . .
Q . . . . .
. . . . Q .
. Q . . . .
. . . . . Q
. . Q . . .

. . . . Q .
. . Q . . .
Q . . . . .
. . . . . Q
. . . Q . .
. Q . . . .

实验代码

#include<stdio.h>

void queen(int i,int j);    //递归函数， 
int check(int i,int j);     //判断是否会遇到其他皇后 的函数 

char chess[13][13];         //最大棋盘 
int a,b,n,sum=0;            //sum记录能摆放的方法次数 

int main(void){
    
    scanf("%d",&n);
    queen(0,0);
    if(sum==0){
        printf("None"); 
    }
    return 0;

}

void queen(int i,int j){
    
    if(j>=n){
        return ; 
    }
    if(check(i,j)==1){     //如果能放
        chess[i][j]='Q';   //放皇后
        if(i==n-1){        //如果是最后一行，记录情况
            sum++;         //记录符合的次数
            if(sum!=1)      //如果有新方法，就在新方法前加一个换行，使得最后一种方法后面没有换行
                printf("
");
        
            for(a=0;a<n;a++){    
                for(b=0;b<n;b++){
                    if(chess[a][b]!='Q'){
                        if(b!=n-1)
                            printf(". ");
                        else
                            printf(".");
                    }
                    if(chess[a][b]=='Q'){
                        if(b!=n-1)
                            printf("Q ");
                        else
                            printf("Q");
                    }
                }
                printf("
");
            }
        }
        else{
            queen(i+1,0); //不是最后一行就分析下一行
        }
    }
    chess[i][j]='.';        //如果此位置不能放，就置空（0），判断旁边的格子。
                           //如果此位置能放，走到这里就意味着上面的代码全部执行了，把皇后拿走（置零），再讨论其他情况，拿旁边位置试探。
    queen(i,j+1);
}

int check(int i,int j){
    int k;
    for(k=0;k<n;k++){
        if(chess[i][k]=='Q')
            return 0;                   //0=不能放
    }
    for(k=0;k<n;k++){
        if(chess[k][j]=='Q')
            return 0; 
    }
    for(k=-n;k<=n;k++){                 //两对角线
        if(i+k>=0&&i+k<n&&j+k>=0&&j+k<n)//从左上到右下对角线
            if(chess[i+k][j+k]=='Q') return 0;
        if(i-k>=0&&i-k<n&&j+k>=0&&j+k<n)//从左下到右上对角线
            if(chess[i-k][j+k]=='Q') return 0;
    }
    return 1;
}

实验思路

想了两天了，都没想出来。然后自己百度，就是这个：八皇后问题 递归实现 C语言 超详细 思路 基础
还没把这个题吃透，还在消化，我刚开始的时候还看不懂，觉得这个题挺绕的，但在我自己调试过后，点鼠标点了过几百次后，哇！！能想到这个算法的人，逻辑太强了吧，当时只感觉：哇！厉害厉害，处理的太妙了！真的太强了！我做不到，现在想到死可能也想不出。
好了，言归正传，这个题的思路其实不难，主要是递归算法怎么返回上一层函数，注意，是返回上一层函数，就是说：这一行不能放皇后，返回上一行放皇后的函数，然后判断上一行的下一列能否放皇后。一直反复。
我觉得最妙的是这个 chess[i][j]='.'; 在函数中的位置，真的绝妙，而且还只能放这里，使得这个函数能从矩阵（0，0）的位置开始判断，直到第一行不能摆放皇后才结束。

遇到的问题及解决方法

遇到的问题：开始看代码看不明白。
解决的方法：边调试变自己在纸上写，搞懂了递归的细节，还有数据的变化。

正确截图

在PTA上一直格式错误，所以只能放自己在DEV-C++的正确截图了

加了一行代码：如下，就在sum++后面。

if(sum!=1)   printf("
");

有一个答案错误实在不知道是为什么了，运行超时就是代码还不够优化。

运行超时也解决了

预习中的疑惑

刚开始预习的时候疑惑挺多的，后来通过看书，做题，还有百度都解决了一大部分。现在感觉只二级指针还不能完全熟练的应用，还有单链表倒置用递归输出还没想明白。

对自己作业的评价

对自己这次的作业不满意，因为我逻辑能力不是太好，递归只靠我用脑子去想真的想不到具体实现的细节，还有一些过程实现的先后顺序和位置都可能导致我程序运行后输出错误，使得我不能写出解答程序。所以多动手，真的很好。

学习进度条

周	这周所花的时间	代码行	学到的知识点简介	目前比较迷惑的问题
第十一周	十八个小时以上	200多行	递归思想，具体的递归实现大概规律	命令行参数怎么定义和使用呢
第九周	六个小时	130行	学到了结构体更深层次的用法	命令行参数怎么使用
第八周	八个小时	170多行	学到了结构体的基本用法和性质	结构体里能用static吗？
第七周	六个小时	200多行	学到了scanf的自定输入	在函数声明的形参表中定义一个char *，什么意思
第六周	七个小时	156行	学到了指针的基本用法，还有用指针做自定义函数的形参用法	在函数声明的形参表中定义一个char *，什么意思
第五周	七个多小时	137行	字符串头文件：#include<string.h>.字符串函数：strcpy.字符和字符串的区别。	指针的拓展使用不会
第四周	十多个小时	134行	选择排序法，字符数组和字符串的使用	为什么我在PTA和上用的也是c++编译器，但是在c++上能正确输出，在PTA上就不正确，为什么呢。
第三周	八小时	106	二维数组的基本知识	PTA的测试点是啥，第一个题除了穷举法还有没有其他方法？指针在文件中的写入位置在哪？怎么来确定的？
第二周	六个多小时	153	文件的打开与关闭，读取数据与写入数据	指针的用法还是有点不会

学习感悟

PTA里的开放性题目非常有意思，我自己已经做了几个了。递归思想很重要，因为递归在解决一些问题非常方便，代码行数少，简单。但是就是比较绕吧，所以得牢牢抓住递归规律和出口，可以从简单的数据开始自己运算，设计好递归算法，再推广到大的数据用电脑进行运算，看结果符不符合预期。

结对编程

过程：
和室友共同思考，交流解决问题。

心得：好处：
（1）在开发层次，结对编程能提供更好的设计质量和代码质量，两人合作能有更强的解决问题的能力。

（2）对开发人员自身来说，结对工作能带来更多的信心，高质量的产出能带来更高的满足感。

（3）在心理上, 当有另一个人在你身边和你紧密配合, 做同样一件事情的时候, 你不好意思开小差, 也不好意思糊弄。

（4）在企业管理层次上，结对能更有效地交流，相互学习和传递经验，能更好地处理人员流动。因为一个人的知识已经被其他人共享。
自我感觉好处：能使两个人沟通起来，得到1+1>2的效果。
但是！！！那也得使强强联手才行呀，所以，有个时候真还不如自己一个人编写程序，还能冷静思考。
我的优点：基础知识记得不错，能持之以恒的坚持写代码，会耐心教队友不会的知识。
我的缺点：太过自信。
队友优点：愿意学，虽然效果不大。英语好，表现不错。
队友缺点：啥也不知道。

预习作业

数组指针：指向数组的指针，比如：int num[10],*p; p=num; p为数组指针。
指针数组：整个数组都是指针，比如： int *num[5]; num[5]为指针数组；
指针函数：函数的返回值为指针的函数，比如： char *Char1（char *ch，int n） Char1为指针函数。
函数指针：指向函数的指针，比如：char （*p1）（char，int）； p1为函数指针。第一个char是指向的函数的返回值类型，函数指针后的括号包含指向的函数的形参类型。
二级指针：指向指针的指针，比如：int * *p； p为二级指针。
单向链表：结构体内的成员包含指向自身结构体的结构指针。 比如：struct num{int n;struct num *next=NULL}; 结构指针next指向下一个同类型的结构首地址，可以通过next找到下一个结构。