第十一周作业
一、本周作业头
| 这个作业属于哪个课程 | C语言程序设计Ⅱ |
|---|---|
| 这个作业要求在哪里 | https://www.cnblogs.com/pengchen511/p/10564067.html |
| 我在这个课程的目标是 | 灵活的使用递归函数和宏定义来解决问题 |
| 这个作业在那个具体方面帮助我实现目标 | 使我对递归函数有了一定的了解，了解了宏定义函数并且能灵活的使用，自己的知识库得到了的拓展 |
| 参考文献 | c语言教课书和百度以及对经典例题的练习 |
二、基础作业
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 hanio (int n,char a,char b,char c);
int main()
{
int n;
char a,b,c;
scanf ("%d
",&n);
scanf ("%c %c %c",&a,&b,&c);
hanio (n,a,b,c);
return 0;
}
void hanio (int n,char a,char b,char c)
{
if (n==1)
{
printf ("%d: %c -> %c
",n,a,b);
}
else
{
hanio (n-1,a,c,b);
printf ("%d: %c -> %c
",n,a,b);
hanio (n-1,c,b,a);
}
}
二、设计思路既流程图。
三、本题调试过程遇到的问题及解决办法。
1、在写题目时出现了答案错误和部分正确
解决办法：自己认真检查和翻阅资料询问助教，在输出时由于是由我写的代码是由a最终移到b，所以输出语句时，printf ("%d: %c -> %c
",n,a,b);，之前写的是a到c，因为它要由c过渡到b嘛，就在中间输出a到c。还有就是要输出盘子的编号，之前没看清，所以没输出，在输出hanio (n-1,a,c,b);自己都不知道什么意思，最后百度和询问别人，加上一下午的实验才懂，按我自己的理解是把n-1由a->c,在c->b,把第n个盘子由a->c,再把n-1个盘子从b移到c。下句也是这样理解的。
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 iszf(char a){
if(a>='0' && a<='9'){
return 1;
}
if(a>='a' && a<='z'){
return 1;
}
if(a>='A' && a<='Z'){
return 1;
}
return 0;
}
char zxxx(char a){
if(a>='A' && a<='Z'){
if(a=='I'){
return 'I';
}else{
return a+32;
}
}
return a;
}
int main(){
int n;
scanf("%d
",&n);
while(n--){
char a[1010],b[1010];
int la=0,lb=0;
gets(a);
printf("%s
",a);
la=strlen(a);
int lk=0;
int ff=0;
for(int i=0;i<la;i++){
if(a[i]==' '){
lk++;
}else if(!iszf(a[i])){
lk=0;
ff=1;
b[lb++]=zxxx(a[i]);
}else{
if(lk>0 && ff){
b[lb++]=' ';
}
lk=0;
ff=1;
b[lb++]=zxxx(a[i]);
}
}
b[lb]=0;
printf("AI: ");
for(int i=0;i<lb;i++){
if( (b[i]=='I')&&
(i==0||!iszf(b[i-1]))&&
(!iszf(b[i+1]))
){
printf("you");
}else if( (b[i]=='m'&&b[i+1]=='e')&&
(i==0||!iszf(b[i-1]))&&
(!iszf(b[i+2]))
){
printf("you");
i+=1;
}else if(b[i]=='?'){
printf("!");
}else if( (b[i]=='c'&&b[i+1]=='a'&&b[i+2]=='n'&&b[i+3]==' '&&b[i+4]=='y'&&b[i+5]=='o'&&b[i+6]=='u')&&
(i==0||!iszf(b[i-1]))&&
(!iszf(b[i+7]))
){
printf("I can");
i+=6;
}else if( (b[i]=='c'&&b[i+1]=='o'&&b[i+2]=='u'&&b[i+3]=='l'&&b[i+4]=='d'&&b[i+5]==' '&&b[i+6]=='y'&&b[i+7]=='o'&&b[i+8]=='u')&&
(i==0||!iszf(b[i-1]))&&
(!iszf(b[i+9]))
){
printf("I could");
i+=8;
}
else{
printf("%c",b[i]);
}
}
printf("
");
}
return 0;
}
二、设计思路既流程图。
三、本题调试过程遇到的问题及解决办法。
本题调试过程中遇到太多的问题了，有很多的不懂的地方，这是借鉴了他人的代码完成的。
解决办法：百度和自查资料
在mian函数之前编写代码是为了定义全局变量，从头往后遍历，循环比较四个单词，发现当前位置存在四个单词之一就判断它的独立性； 如果该单词独立，那么替换成目标单词，然后遍历的下标加上目标单词的长度；
如果没发现或者单词不独立，那么遍历的下标加 1 。
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 . . . .
一、实验代码。
二、设计思路既流程图。
三、本题调试过程遇到的问题及解决办法。
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 (*p) [5]=b,即 *(p+i) 是二维数组b[i][0]的地址。
#include <stdio.h>
int main(){
int a[5] = { 1,2,3,4,5 };
int len = sizeof(arr) / sizeof(int); //求数组长度
int i;
for(i=0; i<len; i++){
printf("%d ", *(a+i) ); //*(arr+i)等价于arr[i]
}
return 0;
}
指针数组：指针数组是数组元素为指针的数组，本质还是数组，利用数组和指针的结合体，比起单个更高效，数组各个元素都是指针类型用于存放内存地址，格式为：类型名 *数组名 [数组长度]，例如：char *a[50]
意思是一个字符型的数组a有50个可以储存50个字符型数据。定义了50个a[50] 的指针。
int a[1] = "good";
int *p;
p = a;
printf("%c", *p++);
printf("%c", p[1]);
指针函数：带有指针的函数，即其本质是一个函数，只不过这种函数返回的是一个对应类型的地址。指向函数代码首地址的指针变量称为函数指针。例如：int (f)(int x) -> double (ptr)(double x);
#include<stdio.h>
int main()
{
int f();
int i，a，b;
int (*p)(); /* 定义函数指针 */
scanf("%d"，&a);
p=f; /* 给函数指针p赋值，使它指向函数f */
for(i＝1;i<9;i++)
{
scanf("%d"，&b);
a＝(*p)(a，b); /* 通过指针p调用函数f */
}
printf("The Max Number is:%d"，a)
}
f(int x，int y)
{
int z;
z＝(x>y)?x:y;
return(z);
}
函数指针:定义一个指针变量，接收函数的入口地址，让它指向函数的指针叫函数指针。例如：int (*p) (int int) 定义了一个函数指针p，它可以指向有两个整型参数且返回值类型为int的函数。
#include "stdio.h"
main()
{
char *ch(char *，char *);
char str1[]="nice to meet you!";
char str2[]="me too!";
printf("%s"，ch(str1，str2));
}
char *ch(char *str1，char *str2)
{
int i;
char *p;
p=str2
if(*str2==NULL) exit(-1);
do
{
*str2=*str1;
str1++;
str2++;
}while(*str1!=NULL);
return(p);
}
二级指针:A(即B的地址)是指向指针的指针，称为二级指针.例子：int **p，
int a =1;
int *b =&a;
int **c=&b;
cout<<&a<<endl;
cout<<b<<endl;
cout<<*c<<endl; /*以上输出都是a的地址，而下面两行就是b的地址*/
cout<<&b<<endl;
cout<<c<<endl;
void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}
void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, "hello" );
printf( str );
}
单向链表:这是常见的动态存储分布的数据结构，由若干个同类型的结点串联而成，最后的结点叫尾点，链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始;链表是使用指针进行构造的列表;又称为结点列表，因为链表是由一个个结点组装起来的;其中每个结点都有指针成员变量指向列表中的下一个结点;列表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向nuLL的指针。
#include <stdio.h>
#include <stdlib.h>
struct grade
{
int score;
struct grade *next;
};
typedef struct grade NODE;
//typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。
//使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，
//另一个是简化一些比较复杂的类型声明。
struct grade *create(); //创建链表
void insert(NODE *head,NODE *pnew,int i); //插入链表
void pdelete(NODE *head,int i); //删除列表
void display(NODE *head); //输出链表
void Pfree(NODE *head); //销毁链表
int main(int argc, char *argv[])
{
struct grade *head,*pnew;
head=create();
if(head==NULL)
return 0;
printf("输出创建的链表：");
display(head);
pnew=(NODE *)malloc(sizeof(NODE));
if(pnew==NULL)
{
printf("创建失败！");
return 0;
}
pnew->score=88;
insert(head,pnew, 3); //将新节点插入节点3的后面
printf("插入后的链表：");
display(head);
pdelete(head,3); //删除节点3
printf("删除后的链表：");
display(head);
Pfree(head);
return 0;
}
struct grade *create()
{
NODE *head,*tail,*pnew;
int score;
head=(NODE *)malloc(sizeof(NODE)); //创建头节点.
if(head==NULL) //创建失败返回
{
printf("创建失败！");
return NULL;
}
head->next=NULL; //头节点指针域置NULL
tail=head; // 开始时尾指针指向头节点
printf("输入学生成绩：");
while(1) //创建链表
{
scanf("%d",&score);
if(score<0) //成绩为负是退出循环
break;
pnew=(NODE *)malloc(sizeof(NODE)); //创建新节点
if(pnew==NULL) //创建失败返回
{
printf("创建失败！");
return NULL;
}
pnew->score=score; //新节点数据域存放输入的成绩
pnew->next=NULL; //新节点指针域置NULL
tail->next=pnew; //新节点插入到表尾
tail=pnew; //为指针指向当前的尾节点
}
return head; //返回创建链表的头指针
}
void insert(NODE *head,NODE *pnew,int i)
{
NODE *p;
int j;
p=head;
for(j=0;j<i&&p!=NULL;j++) //p指向要插入的第i个节点
p=p->next;
if(p==NULL) //节点i不存在
{
printf("与插入的节点不存在！");
return;
}
pnew->next=p->next; //插入节点的指针域指向第i个节点的后继节点
p->next=pnew; //犟第i个节点的指针域指向插入的新节点
}
void pdelete(NODE *head,int i)
{
NODE *p,*q;
int j;
if(i==0) //删除的是头指针，返回
return;
p=head;
for(j=1;j<i&&p->next!=NULL;j++)
p=p->next; //将p指向要删除的第i个节点的前驱节点
if(p->next==NULL) //表明链表中的节点不存在
{
printf("不存在！");
return;
}
q=p->next; //q指向待删除的节点
p->next=q->next; //删除节点i，也可写成p->next=p->next->next
free(q); //释放节点i的内存单元
}
void display(NODE *head)
{
NODE *p;
for(p=head->next;p!=NULL;p=p->next)
printf("%d ",p->score);
printf("
");
}
void pfree(NODE *head)
{
NODE *p,*q;
p=head;
while(p->next!=NULL) //每次删除头节点的后继节点
{
q=p->next;
p->next=q->next;
free(q);
}
free (head); //最后删除头节点
}
void Pfree(NODE *head)
{
NODE *p,*q;
p=head;
while(p->next!=NULL)
{
q=p->next;
p->next=q->next;
free(q);
}
free(p);
}
转自：http://hi.baidu.com/y�ٰ�y/blog/item/fa9f1c5b1525b500367abe80.html
学习进度统计和学习感悟
学习感悟
天行健，君子以自强不息。这次作业让我明白我是有多菜。
折线图
结对编程
优点：
1、程序员互相帮助，互相教对方，可以得到能力上的互补。
2、可以让编程环境有效地贯彻Design。
缺点：
1、两个人在一起工作可能会出现工作精力不能集中的情况。程序员可能会交谈一些与工作无关的事情，反而分散注意力，导致效率比单人更为低下。
2、结对编程可能让程序员们相互学习得更快。有些时候，学习对方的长外，可能会和程序员们在起滋生不良气氛一样快。比如，合伙应付工作，敷衍项目。
有时候发现结对编程还是有点用，结队编程就是让我们知道合作的重要性。