• 第十一周作业

    这个教程属于哪个教程 C语言程序设计II
    这次作业要求在哪里 https://edu.cnblogs.com/campus/zswxy/software-engineering-class2-2018/homework/3201
    我在这个课程的目标是 对递归函数有初步的认识
    这个具体在哪个方面帮助我实现目标的 看慕课，然而并没有实现多少。
    参考文献 c语言程序设II

    基础题：

    选择题：

    2-1

    宏定义“#define DIV(a, b) a/b”，经DIV(x + 5, y - 5) 引用，替换展开后是（）。 (1分)

     
    2-2

    定义带参数的宏“#define JH(a,b,t) t = a; a = b; b = t”，对两个参数a、b的值进行交换，下列表述中正确的是（）。 (1分)

     
    2-3

    如果所有的变量按照下面的程序进行定义和声明，那么在main()函数中所有可用的变量为 （）。 (2分)

    void fun(int x)
{  
    static int y;
    ……
    return;
}
int z;
void main( )
{   
    int a,b;
    fun(a);
    ……
}
     
    2-4

    如果一个变量在整个程序运行期间都存在，但是仅在说明它的函数内是可见的，这个变量的存储类型应该被说明为( )。 (1分)

     
    2-5

    下面说法中正确的是（）。 (1分)

     
    2-6

    凡是函数中未指定存储类别的局部变量，其隐含的存储类型为( )。 (1分)

     
    2-7

    在一个C源程序文件中，若要定义一个只允许本源文件中所有函数使用的全局变量，则该变量需要使用的存储类别是。 (1分)

     
    2-8

    将一个函数说明为static后，该函数将 ( )。(1分)

    编程题：

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

    汉诺塔是一个源于印度古老传说的益智玩具。据说大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘，大梵天命令僧侣把圆盘移到另一根柱子上，并且规定：在小圆盘上不能放大圆盘，每次只能移动一个圆盘。当所有圆盘都移到另一根柱子上时，世界就会毁灭。

    题图1.jpg

    请编写程序，输入汉诺塔圆片的数量，输出移动汉诺塔的步骤。

    输入格式

    圆盘数 起始柱 目的柱 过度柱

    输出格式

    移动汉诺塔的步骤
    每行显示一步操作，具体格式为：
    盘片号: 起始柱 -> 目的柱
    其中盘片号从 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、实验代码：
    int main (void)
{
    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);
     }
  } 

    2、设计思路：



     3、遇到的问题及解决办法：

                书上有原题。

    4、运行结果截图：

                                                          7-2 估值一亿的AI核心代码 (20 分)
     

    AI.jpg

    以上图片来自新浪微博。

    本题要求你实现一个稍微更值钱一点的 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

    　　参考资料：

    https://blog.csdn.net/xidianbaby/article/details/85007904

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

    　　参考资料：

    https://www.cnblogs.com/cnnnnnn/p/8506883.html

    挑战题：

                                                                                              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

    上述输入代表的是如下这样一个迷宫：

    大小为10的迷宫示意图.PNG

    其中红色的小方块是障碍物，蓝色的小方块是空位，白色的小圆连起来是一条从入口到出口的通道，两个圆之间代表一个步长。

    输出样例:

    14

       实验代码：

    #include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
 
 
int n;
int tu[10][10];
int vist[10][10];
 
 struct Point{
int x,y;
int len;
} p;
 
queue<Point> Q;
 
 int flag=0;
 
void bfs(){
Point a=Q.front();Q.pop();
int dx=a.x;int dy=a.y;
if(dx==n-2&&dy==n-2){
flag=a.len;
return;
}
if(!tu[dx][dy-1]&&!vist[dx][dy-1]){
Point b;b.x=dx;b.y=dy-1;b.len=a.len+1;
vist[dx][dy-1]=1;Q.push(b);
}
if(!tu[dx][dy+1]&&!vist[dx][dy+1]){
Point b;b.x=dx;b.y=dy+1;b.len=a.len+1;
Q.push(b);vist[dx][dy+1]=1;
}
if(!tu[dx+1][dy]&&!vist[dx+1][dy]){
Point b;b.x=dx+1;b.y=dy;b.len=a.len+1;
Q.push(b);vist[dx+1][dy]=1;
}
if(!tu[dx-1][dy]&&!vist[dx-1][dy]){
Point b;b.x=dx-1;b.y=dy;b.len=a.len+1;
Q.push(b);vist[dx-1][dy]=1;
}
if(Q.empty()) return;
else bfs();
}
 int main(){
 cin>>n;
 for(int i=0;i<n;i++){
     for(int j=0;j<n;j++)
         scanf("%d",&tu[i][j]);
}
p.x=1;p.y=1;p.len=0;
Q.push(p);vist[1][1]=1;
bfs();
if(flag) printf("%d",flag);
else printf("No solution");
}

      运行结果截图：

     参考资料：

    https://blog.csdn.net/weixin_41777721/article/details/88862499

    预习作业：

    举实例解释概念：

    1、数组指针：一个指向一维或者多维数组的指针。

    比如：int * b=new int[10];指向一维数组的指针b ; 注意，这个时候释放空间一定要delete [] ,否则会造成内存泄露，b 就成为了空悬指针。
             int (*b2)[10]=new int[10][10]; 注意，这里的b2指向了一个二维int型数组的首地址。
             注意：在这里，b2等效于二维数组名，但没有指出其边界，即最高维的元素数量，但是它的最低维数的元素数量必须要指定！就像指向字符的指针，即等效一个字符串,不要把指向字符的指针说成指向字符串的指针。这与数组的嵌套定义相一致。

           int(*b3) [30] [20];  //三级指针――>指向三维数组的指针； 
           int (*b2) [20];     //二级指针； 
           b3=new int [1] [20] [30]; 
           b2=new int [30] [20]; 
          两个数组都是由600个整数组成，前者是只有一个元素的三维数组，每个元素为30行20列的二维数组，而另一个是有30个元素的二维数组，每个元素为20个元素的一维数组。 
          删除这两个动态数组可用下式： 
          delete [] b3;  //删除（释放）三维数组； 
          delete [] b2;  //删除（释放）二维数组； 
          再次重申：这里的b2的类型是int (*) ，这样表示一个指向二维数组的指针。b3表示一个指向（指向二维数组的指针）的指针，也就是三级指针.

      出处：http://www.cnblogs.com/findumars/p/6417941.html

    2、指针数组：一个数组里存放的都是同一个类型的指针，通常我们把他叫做指针数组。

    比如 int * a[10];它里边放了1０个int * 型变量，由于它是一个数组，已经在栈区分配了１０个(int * )的空间，也就是３２位机上是４０个byte,每个空间都可以存放一个int型变量的地址，这个时候你可以为这个数组的每一个元素初始化，或者单独做个循环去初始化它。

           举例：声明一个指针数组如下所示，可理解为：首先，其为一个3维数组，数组里存放的是返回int型的指针。

    [cpp] view plain copy
     
    1. int *p[3];  
    2. p[0] = new int[4];  
    3. p[1] = new int[5];  
    4. p[2] = new int[6];  
    5.   
    6. delete p[0];  
    7. delete p[1];  
    8. delete p[2];  

         出处：http://www.cnblogs.com/findumars/p/6417941.html

    3、指针函数：所谓函数类型是指函数返回值的类型。在C语言中允许一个函数的返回值是一个指针(即地址)，这种返回指针值的函数称为指针型函数。

    定义指针型函数的一般形式为：
        类型说明符 *函数名(形参表) 
        { 
            ……          /*函数体*/
        } 
    其中函数名之前加了“*”号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。
    如：
        int *ap(int x,int y)
        {
          ......       /*函数体*/
    }
    表示ap是一个返回指针值的指针型函数，它返回的指针指向一个整型变量。
    【例】本程序是通过指针函数，输入一个1～7之间的整数，输出对应的星期名。
    main(){
      int i;
      char *day_name(int n);  
      printf("input Day No: ");
      scanf("%d",&i);
      if(i<0) exit(1);
      printf("Day No:%2d-->%s ",i,day_name(i));
    }
    char *day_name(int n){
      static char *name[]={ "Illegal day",
                            "Monday",
                            "Tuesday",
                            "Wednesday",
                            "Thursday",
                            "Friday",
                            "Saturday",
                            "Sunday"};
      return((n<1||n>7) ? name[0] : name[n]);
    }

      出处：https://www.cnblogs.com/zhizhan/p/3764498.html

    4、函数指针：关于函数指针，我想在我们可能需要写个函数，这个函数体内要调用另一个函数，可是由于项目的进度有限，我们不知道要调用什么样的函数，这个时候可能就需要一个函数指针。

    int a();这个一个函数的声明； 
          int (*b)();这是一个函数指针的声明； 
          让我们来分析一下，左边圆括弧中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和由边圆括弧中的入口参数（本例中参数是空）。注意本例中还没有创建指针变量-只是声明了变量类型。

          目前可以用这个变量类型来创建类型定义名及用sizeof表达式获得函数指针的大小：

          unsigned psize = sizeof (int (*) ()); 获得函数指针的大小 
          为函数指针声明类型定义  typedef int (*PFUNC) (); //PFUNC是一个函数指针，它指向的函数没有输入参数，返回int。使用这个类型定义名可以隐藏复杂的函数指针语法，就我本人强烈建议我们大内弟子使用这种方式来定义

       出处：http://www.cnblogs.com/findumars/p/6417941.html

    5、二级指针：指向指针的指针。

    一级指针与二级指针的比较：一级指针的值为地址，地址需要空间来存放，是空间就具有地址
    ，二级指针就是为了获取这一空间的地址。一级指针所关联的是其值（一个地址）名下空间里
    的数据，这个数据可以是任意类型并做任意用途，但二级指针所关联的数据只有一个类型一个
    用途，就是地址。
    指针的用途：提供目标的读取或改写，而二级指针就是对于内存地址的读取和改写。
    二级指针分为指向指针变量的指针和指向数组的指针。
    例1、（简单的指向指针变量的指针）
    int main()
    {
        int k,*p,**pp;
        k=8;
        p=&k;
        pp=&p;
        printf(“k=%d,p=%d,p=%d ”,**pp,*pp,p);
        return 0;
    }
    6、单向链表：单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点；
    列表是由结点构成，head指针指向第一个成为表头结点，而终止于最后一个指向NULL的指针。
     
    例2.5 已知单链表H，写一算法将其倒置。即实现如图2.22的操作。(a)为倒置前，(b)为倒置后。

    算法思路：依次取原链表中的每个结点，将其作为第一个结点插入到新链表中去，指针p用来指向当前结点，p为空时结束。算法如下：
    void reverse (Linklist H)
    { LNode *p;
    p=H->next; /*p指向第一个数据结点*/
    H->next=NULL; /*将原链表置为空表H*/
    while (p)
    { q=p; p=p->next;
    q->next=H->next; /*将当前结点插到头结点的后面*/
    H->next=q;
    }
    }
    算法2.15。该算法只是对链表中顺序扫描一边即完成了倒置，所以时间性能为O(n)。
        出处：https://blog.csdn.net/u011308691/article/details/16809235

     

    学习感悟：

    这一周接触的递归函数，从刚开始学就感觉很不懂，加上这周的题目，更是让人一脸懵。上网查了资料，但是感觉都看不懂，理不清思路。很难受。

    编程感悟：

    题目都不会写，有啥好说的啊，都处于懵逼状态

    学习进度条：

      周/日期 这周所花时间 代码行数 学到的知识点 目前比较疑惑的问题
      3.29--4.4 5h 50行 理解变量，内存和地址之间的关系 关系模糊
      4.4--4.11 5h 62行 指针、数组和地址之间的关系

    +1
      4.11--4.19 6h 78行 字符串和字符指针  指针的内存动态分配
      4.20--4.26  6h 80行       结构体     结构体的具体实质
      4.27--5.2

    4h

    		 54行 复习  
      5.3--5.10

    6h

    		 92行 递归函数

    递归函数

     

     

     
  • 相关阅读:
    OO第四单元作业总结暨完结撒花
    OO第三单元作业总结【自我审判】
    菜鸡学C语言之知识点简单整理
    菜鸡学C语言之混凝土（四柱汉诺塔）
    OO第二单元作业总结【自我反思与审视】
    菜鸡学C语言之寻根溯源
    菜鸡学C语言之真心话大冒险
    菜鸡学C语言之摸鱼村村长
    OO面向对象第一单元总结
    day10 python全栈学习笔记
  • 原文地址：https://www.cnblogs.com/tzw1026/p/10843890.html
Copyright © 2020-2023  润新知