第十一周做业及其总结

时间 2019-12-02

标签第十一周 1周及其总结繁體版

原文原文链接

第十一周做业

1、本周做业头

这个做业属于哪一个课程	C语言程序设计Ⅱ
这个做业要求在哪里	http://www.javashuo.com/article/p-rbjtrmhq-hg.html
我在这个课程的目标是	灵活的使用递归函数和宏定义来解决问题
这个做业在那个具体方面帮助我实现目标	使我对递归函数有了必定的了解，了解了宏定义函数而且能灵活的使用，本身的知识库获得了的拓展
参考文献	c语言教课书和百度以及对经典例题的练习

2、基础做业

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

汉诺塔是一个源于印度古老传说的益智玩具。听说大梵天创造世界的时候作了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着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 b,char c);
int main()
{
    int n;
    char a,b,c;
    scanf ("%d\n",&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",n,a,b);
    } 
    else
    {
        hanio (n-1,a,c,b);
        printf ("%d: %c -> %c\n",n,a,b);
        hanio (n-1,c,b,a);
    }
}

2、设计思路既流程图。

3、本题调试过程遇到的问题及解决办法。

一、在写题目时出现了答案错误和部分正确
解决办法：本身认真检查和翻阅资料询问助教，在输出时因为是由我写的代码是由a最终移到b，因此输出语句时，printf ("%d: %c -> %c\n",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 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。this

输出格式：

按题面要求输出，每一个 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>
#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",&n);
    while(n--){
        char a[1010],b[1010];
        int la=0,lb=0;
        gets(a);
        printf("%s\n",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("\n");
 
    }
    return 0;
}

2、设计思路既流程图。

3、本题调试过程遇到的问题及解决办法。

本题调试过程当中遇到太多的问题了，有不少的不懂的地方，这是借鉴了他人的代码完成的。
解决办法：百度和自查资料
在mian函数以前编写代码是为了定义全局变量，从头日后遍历，循环比较四个单词，发现当前位置存在四个单词之一就判断它的独立性；若是该单词独立，那么替换成目标单词，而后遍历的下标加上目标单词的长度；
若是没发现或者单词不独立，那么遍历的下标加 1 。3d

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 . . . .

1、实验代码。

2、设计思路既流程图。

3、本题调试过程遇到的问题及解决办法。

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

1、实验代码。

2、设计思路既流程图。

3、本题调试过程遇到的问题及解决办法。

预习做业

第十二周的教学内容是：第十一章指针进阶
请你们查阅资料，思考以下问题：
请举实例解释如下几个概念：数组指针，指针数组，指针函数，函数指针，二级指针，单向链表。（无实例不给分）
请用本身的理解回答。若是有引用他人的文字，请必定要标出出处（使用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("\n"); 

}

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%C9%D9%B0%D7y/blog/item/fa9f1c5b1525b500367abe80.html

学习进度统计和学习感悟

学习感悟

天行健，君子以自强不息。此次做业让我明白我是有多菜。

折线图

结对编程

优势：
一、程序员互相帮助，互相教对方，能够获得能力上的互补。
二、可让编程环境有效地贯彻Design。
缺点：
一、两我的在一块儿工做可能会出现工做精力不能集中的状况。程序员可能会交谈一些与工做无关的事情，反而分散注意力，致使效率比单人更为低下。
二、结对编程可能让程序员们相互学习得更快。有些时候，学习对方的长外，可能会和程序员们在起滋生不良气氛同样快。好比，合伙应付工做，敷衍项目。

有时候发现结对编程仍是有点用，结队编程就是让咱们知道合做的重要性。