2019春第十一周作业

这个作业属于哪个课程	C语言程序设计II
这个作业要求在哪	2019年春第十一周作业
我在这个课程的目标是	能够对相对复杂的问题，合理定义程序的多函数结构；能够使用递归函数进行编程；掌握宏的基本用法；掌握编译预处理的概念。
这个作业在哪个具体方面帮助我实现目标	通过PTA作业实践编程学习
参考文献	C语言程序设计

基础作业

单选题

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

1）.实验代码

#include<stdio.h>
void hanio(int n,char a,char c,char b);
int main(void)
{
	int n;
    char a,c,b;
	scanf("%d\n",&n);
	scanf("%c %c %c",&a,&c,&b);
	hanio(n,a,c,b);
	
	return 0; 
 } 
 
 void hanio(int n,char a,char c,char b)
 {
 	if(n==1)
 	printf("1: %c -> %c\n",a,c);
 	else{
 		hanio(n-1,a,b,c);
 		printf("%d: %c -> %c\n",n,a,c);
 		hanio(n-1,b,c,a);
	 }
 }

2）.设计思路

第一步：n-1个盘子从座A搬到座C，第n号盘子从座A搬到座B，n-1个盘子从座C搬到座B。
第二步：n-2个盘子从座A搬到座C，第n-1号盘子从座A搬到座B，n-2个盘子从座C搬到座B。
第三步：直到第1个盘子直接从座A搬到座B为递归出口。

3）.本题调试过程碰到的问题以及解决办法

仔细看输出示例，冒号后面有个空格，加上后答案正确。

4）.运行结果截图

2.编程题：估值一亿的AI核心代码

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

1）.实验代码

#include<stdio.h>
int main(void)
{
	int n,i,j=0,k=0,panduan=0;  \/panduan的作用是在判断是否为独立的can you、would you中判断两个单词中间是否被空格以外的标点符号隔开\/
	scanf("%d\n",&n);
	char duihua[n][1001],m=' ';   \//m的作用是记录上一个字符 
	for(i=0;i<n;i++){
		gets(duihua[i]);
	}
	for(i=0;i<n;i++){
		printf("%s\nAI: ",duihua[i]);
		while(duihua[i][j]!='\0'){  /逐个读取字符进行处理 /
			if(duihua[i][j]>='A'&&duihua[i][j]<'I'||duihua[i][j]>'I'&&duihua[i][j]<='Z'){   /将除了I的大写字母改为小写字母 /
				duihua[i][j]=duihua[i][j]+'a'-'A';
			}
			if(duihua[i][j]=='c'){   /判断是否为独立的can you，是则输出I can并跳出本次字符处理循环结构并将下次代处理的字符转到独立的can you的后面一个字符/
			if((duihua[i][j+1]=='a'||duihua[i][j+1]=='A')&&(duihua[i][j+2]=='n'||duihua[i][j+2]=='N')){
				if((m<'0'||m>'9')&&(m<'A'||m>'Z')&&(m<'a'||m>'z')){
					if((duihua[i][j+3]<'0'||duihua[i][j+3]>'9')&&(duihua[i][j+3]<'A'||duihua[i][j+3]>'Z')&&(duihua[i][j+3]<'a'||duihua[i][j+3]>'z')){
				k=j+3;
				while((duihua[i][k]<'0'||duihua[i][k]>'9')&&(duihua[i][k]<'A'||duihua[i][k]>'Z')&&(duihua[i][k]<'a'||duihua[i][k]>'z')){
				if(duihua[i][k]!=' '){
					panduan=1;
				}
				k++; 
				} 
				if(panduan==0){
				if((duihua[i][k]=='y'||duihua[i][k]=='Y')&&(duihua[i][k+1]=='o'||duihua[i][k+1]=='O')&&(duihua[i][k+2]=='u'||duihua[i][k+2]=='U')){
					if((duihua[i][k+3]<'0'||duihua[i][k+3]>'9')&&(duihua[i][k+3]<'A'||duihua[i][k+3]>'Z')&&(duihua[i][k+3]<'a'||duihua[i][k+3]>'z')){
					printf("I can");
					j=k+3;
					k=0;
					m='n';
					continue;
				}
			}
		}
		}
					}
		    	}
			} 
			if(duihua[i][j]=='c'){   /判断是否为独立的could you，是则输出I could并跳出本次字符处理循环结构并将下次代处理的字符转到独立的could you的后面一个字符/
			if((duihua[i][j+1]=='o'||duihua[i][j+1]=='O')&&(duihua[i][j+2]=='u'||duihua[i][j+2]=='U')&&(duihua[i][j+3]=='l'||duihua[i][j+3]=='L')&&(duihua[i][j+4]=='d'||duihua[i][j+4]=='D')){
				if((m<'0'||m>'9')&&(m<'A'||m>'Z')&&(m<'a'||m>'z')){
					if((duihua[i][j+5]<'0'||duihua[i][j+5]>'9')&&(duihua[i][j+5]<'A'||duihua[i][j+5]>'Z')&&(duihua[i][j+5]<'a'||duihua[i][j+5]>'z')){
				k=j+5;
				while((duihua[i][k]<'0'||duihua[i][k]>'9')&&(duihua[i][k]<'A'||duihua[i][k]>'Z')&&(duihua[i][k]<'a'||duihua[i][k]>'z')){
					if(duihua[i][k]!=' '){
					panduan=1;
				}
				k++; 
				} 
				if(panduan==0){
				if((duihua[i][k]=='y'||duihua[i][k]=='Y')&&(duihua[i][k+1]=='o'||duihua[i][k+1]=='O')&&(duihua[i][k+2]=='u'||duihua[i][k+2]=='U')){
					if((duihua[i][k+3]<'0'||duihua[i][k+3]>'9')&&(duihua[i][k+3]<'A'||duihua[i][k+3]>'Z')&&(duihua[i][k+3]<'a'||duihua[i][k+3]>'z')){
					printf("I could");
					j=k+3;
					k=0;
					m='d';
					continue;
				}
			}
		}
					}
		    	}
			}
		}
			if(duihua[i][j]=='I'){   /判断是否为独立的I，是则输出you并跳出本次字符处理循环结构并将下次代处理的字符转到独立的I的后面一个字符/
			if((m<'0'||m>'9')&&(m<'A'||m>'Z')&&(m<'a'||m>'z')){
				if((duihua[i][j+1]<'0'||duihua[i][j+1]>'9')&&(duihua[i][j+1]<'A'||duihua[i][j+1]>'Z')&&(duihua[i][j+1]<'a'||duihua[i][j+1]>'z')){
				printf("you");
					j++;
					m='u';
					continue;
				}
			}
		}
		    if(duihua[i][j]=='m'&&(duihua[i][j+1]=='e'||duihua[i][j+1]=='E')){   /判断是否为独立的me，是则输出you并跳出本次字符处理循环结构并将下次代处理的字符转到独立的me的后面一个字符/
			if((m<'0'||m>'9')&&(m<'A'||m>'Z')&&(m<'a'||m>'z')){
				if((duihua[i][j+2]<'0'||duihua[i][j+2]>'9')&&(duihua[i][j+2]<'A'||duihua[i][j+2]>'Z')&&(duihua[i][j+2]<'a'||duihua[i][j+2]>'z')){
				printf("you");
					j=j+2;
					m='u';
					continue;
				}
			}
		}
			if(duihua[i][j]=='?'){  /判断是否为问号，是则改为感叹号 /
				duihua[i][j]='!';
			}
			if(duihua[i][j]==' '){  /此代码是为了实现连续多个空格只输出一次空格，标点符号前不输出空格 /
		    if((m==' ')||((duihua[i][j+1]<'0'||duihua[i][j+1]>'9')&&(duihua[i][j+1]<'A'||duihua[i][j+1]>'Z')&&(duihua[i][j+1]<'a'||duihua[i][j+1]>'z'))){
			j++;
			continue;
		    } 
		}
		printf("%c",duihua[i][j]);
		m=duihua[i][j];
		j++;
		panduan=0;
	}
	printf("\n");
	j=0;k=0;m=' ';
	}
}

2）.设计思路

第一步：输入对话。
第二步：逐个读取输入的字符，并按题目要求进行相应处理后输出。

3）.本题调试过程碰到的问题以及解决办法

碰到的问题很多，这里说一下主要问题。

对独立的can you、could you判断条件不够，会认为can？you、could，you等中间不为空格的也是独立的can you、could you，增加判断中间是否全为空格符，不是则不为独立的can you、could you

因为我的思路是逐个读取字符处理，所以CAN YOU、COULD YOU、cAn YoU、ME等存在不为小写字母的单词不会判定为独立的单词，还是判定条件不够的问题，增加大写字母的可能性之后答案正确。

4）.运行结果截图

挑战作业

1.编程题：八皇后问题（用递归法实现）

7-3 ***八皇后问题 (20 分)
在国际象棋中，皇后是最厉害的棋子，可以横走、直走，还可以斜走。棋手马克斯·贝瑟尔 1848 年提出著名的八皇后问题：即在 8 × 8 的棋盘上摆放八个皇后，使其不能互相攻击 —— 即任意两个皇后都不能处于同一行、同一列或同一条斜线上。
现在我们把棋盘扩展到 n × n 的棋盘上摆放 n 个皇后，请问该怎么摆？请编写程序，输入正整数 n，输出全部摆法(棋盘格子空白处显示句点“.”，皇后处显示字母“Q”，每两格之间空一格)。

输入格式

正整数 n (0 ＜ n ≤ 12)

输出格式

若问题有解，则输出全部摆法(两种摆法之间空一行)，否则输出 None。
要求：试探的顺序逐行从左往右的顺序进行，请参看输出样例2。

输入样例1

输出样例1

None

输入样例2

输出样例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 . . . .

1）.实验代码

#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;             
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("\n\n");
        }         
            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");
                    }
                }
                if(a!=n-1)
                printf("\n");
            
            }
        }
        else{
            queen(i+1,0); 
        }
    }
    chess[i][j]='.';                  
    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;                   
    }
    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;
}

2）.设计思路

第一步：假如要在n*n的棋盘上摆放n个皇后，首先要确定第1行皇后的位置，然后确定第2行皇后的位置，直到确定第n行皇后的位置。
第二步：假如第m行皇后没有位置可以摆放了，就要改变第m-1行皇后的位置，然后确定第m行皇后的位置，如果还是没有位置可以摆放，就再改变第m-1行皇后的位置，然后再确定第m行皇后的位置，如果直到第m-1行没有其它位置可以改变，还没有找到第m行皇后的位置，就要改变m-2行皇后的位置，从而改变第m-1行皇后可以摆放的位置，然后再通过第m-1行皇后的位置确定第m行皇后的位置，以此类推，如果直到第1行都没有其他位置可以改变，则输出None。
第三步：通过第二步的方法，如果找到了第n行皇后的位置，输出矩阵，是皇后的位置输出Q，不是则输出.

3）.本题调试过程碰到的问题以及解决办法

虽然想到了思路，但不知道如何用代码实现，参考了八皇后问题才知道代码怎么写，在此基础上添加了输出代码，遇到以下问题。

尚未找到解决办法。

4）.运行结果截图

2.编程题：求迷宫最短通道

7-1 求迷宫最短通道 (20 分)

递归求解迷宫最短通道的总步长。输入一个迷宫，求从入口通向出口的可行路径中最短的路径长度。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位（0<=i<=n-1, 0<=j<=n-1）。求从入口maze[1][1]到出口maze[n-2][n-2]可以走通的路径上经历的最短的总步长。要求迷宫中只允许在水平或上下四个方向的空位上行走，走过的位置不能重复走。
输入格式:
输入迷宫大小的整数n, 以及n行和n列的二维数组（数组元素1代表障碍物，0代表空位）
输出格式:
若有可行的通道则输出一个整数，代表求出的通道的最短步长；若没有通道则输出"No solution"
输入样例:
10
1 1 1 1 1 1 1 1 1 1
1 0 0 1 0 0 0 1 0 1
1 0 0 1 0 0 0 1 0 1
1 0 0 0 0 1 1 0 0 1
1 0 1 1 1 0 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 0 1 0 0 0 1 0 0 1
1 0 1 1 1 0 1 1 0 1
1 1 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1
上述输入代表的是如下这样一个迷宫：

其中红色的小方块是障碍物，蓝色的小方块是空位，白色的小圆连起来是一条从入口到出口的通道，两个圆之间代表一个步长。
输出样例:
14
设计思路
第一步：从起点开始，记录上下左右能走的点。
第二步：分别以上一次记录的点为起点，记录上下左右能走的点，记录过的点为不能走的点。
第三步：如果该点的上下左右都不能走，则停止这条线的记录。
第四步：如果能走的点为终点，记录这条线走过的点的数量，比较多条到终点的线走过的点的数量，输出最少的数量减去一的值。
大概思路就是这样，实现起来需要考虑很多细节问题，难以实现，因为作业截止时间关系，且在被前几题搞晕的因素下，我放弃了。

预习作业

第十二周的教学内容是：第十一章指针进阶
请大家查阅资料，思考如下问题：
请举实例解释以下几个概念：数组指针，指针数组，指针函数，函数指针，二级指针，单向链表。（无实例不给分）
请用自己的理解回答。如果有引用他人的文字，请一定要标出出处（使用Markdown的链接方式）。
数组指针是一个指向数组的指针，例：

int arr[10] = {0};
int (*p)[10] = &arr;

p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针
指针数组是一个存放指针的数组，例：

int *arr[]; //[]优先级高，所以arr首先是一个数组，里面存放的是一个个指针
int** arr[]; //数组中放入二级指针

指针函数一个函数。函数都有返回类型（如果不返回值，则为无值型），只不过指针函数返回类型是某一类型的指针。例：

#include <stdio.h>
 float *find(float(*pionter)[4],int n);//函数声明
 int main(void)
 {
     static float score[][4]={{60,70,80,90},{56,89,34,45},{34,23,56,45}};
     float *p;
     int i,m;
     printf("Enter the number to be found:");
     scanf("%d",&m);
     printf("the score of NO.%d are:\n",m);
     p=find(score,m-1);
     for(i=0;i<4;i++)
         printf("%5.2f\t",*(p+i));
  
     return 0;
 }
 
float *find(float(*pionter)[4],int n)/*定义指针函数*/
 {
     float *pt;
     pt=*(pionter+n);
     return(pt);
 }

共有三个学生的成绩，函数find()被定义为指针函数，其形参pointer是指针指向包含4个元素的一维数组的指针变量。pointer+n指向score的第n+1行。*(pointer+1)指向第一行的第0个元素。pt是一个指针变量，它指向浮点型变量。main()函数中调用find()函数，将score数组的首地址传给pointer.
函数指针是指向函数的指针变量。因此“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。如前所述，C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。函数指针有两个用途：调用函数和做函数的参数。例：

#include<stdio.h>
int max(int x,int y){return (x>y? x:y);}
int main()
{
    int (*ptr)(int, int);
    int a, b, c;
    ptr = max;
    scanf("%d%d", &a, &b);
    c = (*ptr)(a,b);
    printf("a=%d, b=%d, max=%d", a, b, c);
    return 0;
}

二级指针是指向指针的指针，例：

int fun(void)
{
     int *buf ;
     int ret ;
     ret = mem_init(&buf);
     return ret;
}
 
int mem_init(int **buf_t)
{
  *buf_t = malloc(100);
  return 1;
}

单向链表是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。例：

class Hero(object):
    def __init__(self, no=None, nickname=None, name=None, pNext = None):
        self.no = no
        self.nickname = nickname
        self.name = name
        self.pNext = pNext

# 添加节点
def addHero(head, pNew):
    cur = head
    # while cur.pNext != None:
    #     cur = cur.pNext
    #
    # cur.pNext = pNew

    while cur.pNext != None:
        if cur.pNext.no > pNew.no:
            # pNew.pNext = cur.pNext
            # cur.pNext = pNew
            break

        cur = cur.pNext
    #思考为什么把这两行代码不放在while里面，而是放在这。
    pNew.pNext = cur.pNext
    cur.pNext = pNew
# 遍历节点
def showHero(head):
    if isEmpty(head):
        return None

    cur = head

    while cur.pNext != None:
        print("英雄的编号是: %s, 外号是：%s, 姓名:%s" % (cur.pNext.no, cur.pNext.nickname, cur.pNext.name))
        cur = cur.pNext

#判断是否为空
def isEmpty(head):
    if head.pNext != None:
        return False
    return True

#删除
def delHero(head, no):
    cur = head

    while cur.pNext != None:
        if no == cur.pNext.no:
            cur.pNext=cur.pNext.pNext
            break
        cur = cur.pNext
    else:
        print('没有找到')

    ### 链表的长度
def getLength(head):
    length = 0
    cur = head
    while cur.pNext != None:
        cur = cur.pNext
        length = length + 1

    return length


# 头结点
head = Hero()

## 首节点
h1 = Hero(1, '及时雨', '宋江')
h2 = Hero(2, '玉麒麟', '卢俊义')
h3 = Hero(6, '豹子头', '林冲')
h4 = Hero(4, '入云龙', '公孙胜')

addHero(head, h1)
addHero(head, h2)
addHero(head, h3)
addHero(head, h4)

showHero(head)
delHero(head,2)
showHero(head)
print(getLength(head))

出处：https://blog.csdn.net/weixin_40417029/article/details/78580080
https://baike.baidu.com/item/指针函数/2641780?fr=aladdin
https://baike.baidu.com/item/函数指针/2674905?fr=aladdin
https://www.cnblogs.com/reality-soul/p/6372915.html
https://baike.baidu.com/item/二级指针/303561?fr=aladdin
https://baike.baidu.com/item/单向链表/8671935?fr=aladdin
https://blog.csdn.net/miaoqinian/article/details/82354333

二、学习进度统计

周/日期	这周所花的时间	代码行	学到的知识点简介	目前比较迷惑的问题
3/2-3/8	2h	23行	数组	无
3/9-3/11	3h	29行	读取文件数据	无
3/12-3/18	5h	70行	用数组输出矩阵	无
3/19-3/25	8h	140行	多种排序方法	无
3/26-4/1	5h	82行	字符(串)数组的相关知识	无
4/2-4/8	2h	63行	指针的相关知识	无
4/9-4/15	10h	90行	指针的相关知识	无
4/16-4/22	5h	152行	常用字符串函数以及使用指针操作字符串的方法，掌握动态内存分配	无
4/23-4/29	2h	60行	能够根据实际情况合理定义结构，能够使用结构变量与结构数组进行熟练编程，掌握结构指针的操作，并应用于函数传递	无
4/7-4/13	20h	200行	能够对相对复杂的问题，合理定义程序的多函数结构；能够使用递归函数进行编程；掌握宏的基本用法；掌握编译预处理的概念。	怎样又快又好的总结出递归式子

三、学习感悟

这周学习了递归的相关知识，新知识的学习提升了我的能力，以后可以解决更多问题了，遇到的困难要善于寻求帮助，问题不解决就永远都是问题！

四、结对编程过程和结对编程的优缺点

队员优点：1.对不懂的问题善于寻求帮助：结对编程过程中，碰到一个棘手的问题，队员及时百度并向大佬询问，问题一下就解决了。
2.有灵性：对于要用到的新知识点一看就理解了，对于疑惑一点就通
3.冷静不浮躁：当遇到难以解决的问题时，能冷静的需求解决办法，而不是怨天尤人。
缺点：不主动和队友交流：经常有新的想法时不第一时间和队友交流，而是自己独自思考。
结对编程的优点：（1）在开发层次，结对编程能提供更好的设计质量和代码质量，两人合作能有更强的解决问题的能力。
（2）对开发人员自身来说，结对工作能带来更多的信心，高质量的产出能带来更高的满足感。
（3）在心理上, 当有另一个人在你身边和你紧密配合, 做同样一件事情的时候, 你不好意思开小差, 也不好意思糊弄。
（4）在企业管理层次上，结对能更有效地交流，相互学习和传递经验，能更好地处理人员流动。因为一个人的知识已经被其他人共享。
总之，如果运用得当，结对编程能得到更高的投入产出比（Return of Investment）。
不适合结对编程的情况：
并不是所有的项目都适合结对编程，下面是一些不适合使用的例子。
1）处于探索阶段的项目，需要深入地研究，在这种情况下，一个人长时间的独立钻研是有必要的。
2）在做后期维护的时候，如果维护的技术含量不高，只需要做有效的复审即可，不必拘泥于形式，硬拉一个人来结对唱二人转。
3）如果验证测试需要运行很长时间，那么两个人在那里等待结果是有点浪费时间。

posted @ 2019-05-09 21:38 hlywww Views(159) Comments(0) Edit 收藏举报

刷新页面返回顶部

heleir

2019春第十一周作业

基础作业

单选题

1.编程题：汉诺塔问题

输入格式

输出格式

输入样例

输出样例

1）.实验代码

2）.设计思路

3）.本题调试过程碰到的问题以及解决办法

4）.运行结果截图

2.编程题：估值一亿的AI核心代码

输入格式：

输出格式：

输入样例：

输出样例：

1）.实验代码

2）.设计思路

3）.本题调试过程碰到的问题以及解决办法

4）.运行结果截图

挑战作业

1.编程题：八皇后问题（用递归法实现）

输入格式

输出格式

输入样例1

输出样例1

输入样例2

输出样例2

1）.实验代码

2）.设计思路

3）.本题调试过程碰到的问题以及解决办法

4）.运行结果截图

2.编程题：求迷宫最短通道

预习作业

二、学习进度统计

三、学习感悟

四、结对编程过程和结对编程的优缺点

公告