第十一周编程总结-CSDN博客

这个作业属于那个课程	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的值进行交换，下列表述中正确的是（D）。 (1分)
不定义参数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
凡是函数中未指定存储类别的局部变量，其隐含的存储类型为(B )。 (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 Hanoi(int n, char a,char c,char b);
int main()
{
    int n;
   char a,c,b;
    scanf("%d %c %c %c",&n,&a,&c,&b);
    Hanoi(n, a, c, b);
    
    return 0;
}
void Hanoi(int n, char a, char c, char b)
{
    if (n == 1)
    {
        printf ("1: %c -> %c\n",a,c);
    }
    else{
        Hanoi(n-1, a,b,c);
        printf ("%d: %c -> %c\n",n,a,c);
        Hanoi(n-1,b,c,a);
    }
}

实验思路

好的我来讲下这到题目吧，首先我们的定义函数中定义了三个形参，用来存放盘子，如果盘子数大于2以上，我们移盘是从a->c借助b,但是在移动的过程中，每根柱子的作用是会改变的，所以才有了最后一步。

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

这道题目真的理解了好久，主要是对递归了解的不够深入，我当时一直不理解为什么定义函数最后还要加一步，经过这几天对递归的理解和昨晚室友们的提醒，我终于逐渐的理解的这道题，我深知这是远远不够的，必须将递归思想清晰化，才可能解决一类题目，所以目前任在努力中。

正确截图

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>
int main(void)
{
    int n,i,j=0,k=0,panduan=0;
    scanf("%d\n",&n);
    char duihua[n][1001],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'){
                duihua[i][j]=duihua[i][j]+'a'-'A';
            }
            if(duihua[i][j]=='c'){
            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'){
            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'){
            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')){
            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=' ';
    }
}

实验思路

对于这个题目不知道该怎么描述，其实这个题目用我我们以前的知识，用死办法去做是可以完成的，因为题目给出了条件，我们只需要根据他给我们的条件去实行就行了，不过就是代码比较长，我自己当初并没有尝试着写，后来我室友他们的思路就是这个，然后在他们的帮助下完成了。

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

这个题目问题还是有的，不过很多是以前一些简单的问题，所以这里我们只需把这题目的思路和一些关键步骤搞懂就行，不是特别难，但要思路清晰和仔细才可能少走弯路。

正确截图

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

实验代码

实验思路

对于这个题目，我的感觉是很有挑战性的，我只能尽量去理解，还在思考着........

遇到的问题

正确截图

预习作业

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

周	这周所花的时间	代码行	学到的知识点简介	目前比较迷惑的问题
第一周	六个小时左右	102	学习了数组	对于数组的使用不太熟悉
第二周	八个小时左右	98	学习了文件，学会使用文件去处理代码	对于文件的一些操作
第三周	十个小时	124	学习了二维数组	暂时没有
第四周	十多个小时	134行	学习了最多的是利用for语句和数组使那些数按顺序排好	目前是编程经常错，好难编
第五周	9个多小时	121行	字符串头文件：#include<string.h>.字符串函数：strcpy.字符和字符串的区别。	对于指针的的理解还不是很深
第六周	七小时	100行左右	学会使用指针定义函数，然后就是学会使用指针返回多个函数值	对于比较复杂的转化还存在困难
第七周	12小时左右	140多行	通过学习更加了解指针了，还有数组与指针结合以及他们的关系	对于那些挑战题，感觉无从下手
第八周	14小时	200行左右	这周学习了结构，然后学习了比较多的函数	对于那些新函数理解的还不是很深刻
第九周	10小时	150行左右	这周就是继续练习结构，然和更深层次的理解结构多种形式	目前对于结构指针和结构数组不是特别理解
第十周	8小时	100行左右	这周虽然虽然没有编程题，但是还是在不断学习知识的	预习了递归对于递归理解不够深刻
第十一周	15小时	200行左右	这周真是在做有关递归的编程题，但是感觉做题的时候只可意味，不可言传，要理解就得靠自己	对于递归的运用任然知之甚少

学习的感悟：

在这一个学期，我跟着老师节奏和在寝室和室友一起学习，感觉非常的不错，慢慢的发现自己在一步一步在进步，我发现越是学到后面题目越有挑战性，然后解决问题越来越实用，越来越贴近社会，
这就是我的学习心得。

结对编程

结队编程过程：
队友都很积极的配合，感觉还是非常的棒的，虽然这周我有点事不在，但是我的搭档还是非常认真地在学习，
为搭档这种精神点赞，队友这周表现非常棒。

心得：好处：
（1）在开发层次，结对编程能提供更好的设计质量和代码质量，两人合作能有更强的解决问题的能力。
（2）对开发人员自身来说，结对工作能带来更多的信心，高质量的产出能带来更高的满足感。
（3）在心理上, 当有另一个人在你身边和你紧密配合, 做同样一件事情的时候, 你不好意思开小差, 也不好意思糊弄。
（4）在企业管理层次上，结对能更有效地交流，相互学习和传递经验，能更好地处理人员流动。因为一个人的知识已经被其他人共享。
自我感觉好处：能使两个人沟通起来，得到1+1>2的效果。
我觉得我和搭档的编程水平很一般，但是两个人不断地努力，这实现了共同进步的目的。
我的优点：思维自我感觉还是可以的，对关于思路很很快的想出来。
我的缺点：书看的太少，基础知识不牢固。
队友优点：能够一起探讨问题，比较积极主动提出问题。
队友缺点：对于知识点的掌握还不是很好。