第十一周作业
一、本周作业头
这个作业属于哪个课程 | 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",&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);
}
}
二、设计思路既流程图。
三、本题调试过程遇到的问题及解决办法。
1、在写题目时出现了答案错误和部分正确
解决办法:自己认真检查和翻阅资料询问助教,在输出时由于是由我写的代码是由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 个字符的、以回车结尾的用户的对话,对话为非空字符串,仅包括字母、数字、空格、可见的半角标点符号。
输出格式:
按题面要求输出,每个 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",&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;
}
二、设计思路既流程图。
三、本题调试过程遇到的问题及解决办法。
本题调试过程中遇到太多的问题了,有很多的不懂的地方,这是借鉴了他人的代码完成的。
解决办法:百度和自查资料
在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("\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
学习进度统计和学习感悟
学习感悟
天行健,君子以自强不息。这次作业让我明白我是有多菜。
折线图
结对编程
优点:
1、程序员互相帮助,互相教对方,可以得到能力上的互补。
2、可以让编程环境有效地贯彻Design。
缺点:
1、两个人在一起工作可能会出现工作精力不能集中的情况。程序员可能会交谈一些与工作无关的事情,反而分散注意力,导致效率比单人更为低下。
2、结对编程可能让程序员们相互学习得更快。有些时候,学习对方的长外,可能会和程序员们在起滋生不良气氛一样快。比如,合伙应付工作,敷衍项目。
有时候发现结对编程还是有点用,结队编程就是让我们知道合作的重要性。