• 第十一周作业


    作业头

    这个作业属于那个课程 C语言程序设计II
    这个作业要求在哪里 https://edu.cnblogs.com/campus/zswxy/software-engineering-class1-2018/homework/3202
    我在这个课程的目标是 使用递归函数进行编程
    这个作业在那个具体方面帮助我实现目标 了解了汉诺塔问题的编程
    参考文献 看书

    基础题

    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
    

    (1)我的代码:

    #include <stdio.h>
    void hanio(int n,char a,char b,char c);
    int main(void)
    {
    	int n;
    	char a,b,c;
    	scanf("%d
    ",&n);
    	scanf("%c %c %c
    ",&a,&b,&c);
    	hanio(n,a,b,c);
    }
    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)运行结果截图:

    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
    

    没有看懂,去网上搜了一下,还是不理解。

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

    实在是看不懂!

    预习题:

    第十二周的教学内容是:第十一章 指针进阶
    请大家查阅资料,思考如下问题:
    请举实例解释以下几个概念:数组指针,指针数组,指针函数,函数指针,二级指针,单向链表。(无实例不给分)
    请用自己的理解回答。如果有引用他人的文字,请一定要标出出处(使用Markdown的链接方式)。

    1、数组指针:首先它是一个指针,它指向一个数组。

    实例:

    int a[4][5];
    int (*p)[5]=a;
    

    这里所代表的 *(p+i) 是二维数组a[i][0]的地址。

    (来源:https://blog.csdn.net/sinat_40043477/article/details/78481350)

    自我理解:数组指针是数组名的指针,即数组首元素地址的指针。

    2、指针数组:指的是数组元素为指针的数组

    实例:

    #include<stdio.h>
    
    int main(void)
    
    {
    
        char **p, i;
    
        char *strings[] ={
    
            "one",
    
            "two",
    
            "three"
    };
     p=strings;                     
        for(i=0; i<3; i++)
    printf("%s
    ", *(p++));    
        return 0;
    }
    

    3、指针函数:指针函数是一个函数。函数都有返回类型(如果不返回值,则为无值型),只不过指针函数返回类型是某一类型的指针。

    实例:

    int * GetDate(int wk,int dy);
      main()
      {
        int wk,dy;
        do{
        printf(Enter week(1-5)day(1-7)
    );
        scanf(%d%d,&wk,&dy);
        }
        while(wk<1||wk>5||dy<1||dy>7);
       printf(%d
    ,*GetDate(wk,dy));
     }
     
     int * GetDate(int wk,int dy)
     {
       static int calendar[5][7]=
       {
         {1,2,3,4,5,6,7},
         {8,9,10,11,12,13,14},
         {15,16,17,18,19,20,21},
         {22,23,24,25,26,27,28},
         {29,30,31,-1}
       };
       return &calendar[wk-1][dy-1];
     }
    

    (来源:)

    自我理解:首先它是一个函数,只不过这个函数的返回值是一个地址值。函数返回值必须用同类型的指针变量来接受,也就是说,指针函数一定有"函数返回值",而且,在主调函数中,函数返回值必须赋给同类型的指针变量。

    4、函数指针:指向函数的指针变量,本质上是一个指针变量

    实例:

    /*函数指针funp作为函数的形参*/
    double calc (double (*funp) (double), double a, double b)
    {
        double z;
        z=(b-a)/2*((*funp) (a) + (*funp) (b));
        return 0;
    }
    double f1 (double x)
    {
    return (x*x);
    }
    double f2 (double x)
    {
    return (sin(x)/x);
    }
    

    5、二级指针:

    实例

    void buf ( int **a )
    {
    	(  *a) = ( int* )malloc ( sizeof ( int ) );
    	( **a )= 1;
    	printf ( "%d",**a );
    
    }
    
    int main( int argc, char *argv[] )
    {
    	int  *a;
    	buf ( &a );
           //printf ( "%d",*a );
    }
    

    (来源:http://blog.chinaunix.net/uid-27183448-id-3409751.html)

    6、单向链表:是使用指针进行构造的列表

    实例:

    #include <stdio.h>
    #include<stdlib.h>
    #define  LEN  sizeof(struct node)
    struct node
    {
    int data;
    struct node  *next;
    };
    main()
    {     struct  node  *p, *pl,* head;
              head=p=(struct node * )malloc(LEN);
              scanf("%d",&p->data);/*头结点的数据成员*/
              while(p->data!=0)   /*给出0结束条件,退出循环*/
              {    pl=p;
                   p=(struct node * )malloc(LEN);
                      scanf("%d",&p->data);/*中间结点数据成员*/
                      pl->next=p;/*中间结点的指针成员值*/
              }
              p-> next=NULL;/*尾结点的指针成员值*/
              p=head;/*链表显示*/
              printf("链表数据成员是:");
              while(p->next!=NULL)
              {
              printf("%d",p->data);
              p=p->next;
              }
              printf("%d
    ",p->data);
    }
    

    学习进度条:

    周/日期 这周所花时间 代码行 学到的知识点简介 目前比较迷惑的问题
    3/4—3/10 18个小时 29行 学会了怎样创建文件,了解了文件处理的步骤 文件的打开方式,有时候不知道哪一种更好
    3/11—3/17 21个小时 66行 上一周学习了一维数组,这周自己预习二维数组,并做了相关题目 那个基础题,关于见文件的,其实还是有点不是特别会
    3/18—3/24 28个小时 88行 更加熟悉了一维数组和二维数组 冒泡法排序还是有点不懂
    3/25—3/31 24个小时 46行 学了关于回文的知识
    4/1—4/7 35个小时 63行 指针的运用 暂时还不知道
    4/8—4/14 30个小时 83行 字符与字符串在指针中的运用 有时候格式会出错
    4/15—4/21 20个小时 107行 掌握动态内存分配 暂时还不知道
    4/22—4/28 16个小时 73行 结构的嵌套
    5/6—5/12 13个小时 21行 递归函数的编程和运用 我觉得这章有挺多知识我还没掌握的

    折线图:

    学习感悟:

    我觉得这周作业难度相对来说挺大的,可能是自己还不够优秀吧,编程题最后几个都看不懂,根本无从下手。

  • 相关阅读:
    刘志博 作业 2.15
    刘志博 作业2.6
    作业一
    2.6
    张靖悦
    java 2.15
    java 2.6
    java 1.12
    java 1.8
    java 1.3
  • 原文地址:https://www.cnblogs.com/-lsg10026244/p/10844821.html
Copyright © 2020-2023  润新知