第十一周作业及总结

第十一周作业

一、本周作业头

这个作业属于哪个课程	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 x,y,z;
    scanf ("%d\n",&n);
    scanf ("%c %c %c",&x,&y,&z);
    hanio (n,x,y,z);
    return 0;
}
void hanio (int n,char x,char y,char z)
{
    if (n==1)
    {
        printf ("%d: %c -> %c\n",n,x,y);
    } 
    else
    {
        hanio (n-1,x,z,y);
        printf ("%d: %c -> %c\n",n,x,y);
        hanio (n-1,z,y,x);
    }
} 

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

一、实验代码。

二、设计思路既流程图。

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

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的链接方式）。

数组指针:
一数组指针的应用：

#include "stdio.h"

typedef   float(A)[10];         //定义一个字符型含有十个元素的数组类型A



int main()

{

        float   fArray[10];                //定义fArray数组

        A*  pf=&fArray;                  //pf数组指针指向fArray整个数组的地址入口

        int   i=0;

        for(i=0;i<10;i++)     //将遍历数组指针，依次赋值

        {

             (*pf)[i]=i;       

         }

    for(i=0;i<10;i++)

    {

          printf("%f\n",fArray[i]);        //通过fArray数组输出上一步遍历由指针数组遍历的值

    }

}

结果输出为：

0.000000

1.000000

2.000000

3.000000

4.000000

5.000000

6.000000

7.000000

8.000000

9.000000
原文：https://blog.csdn.net/liuchuangjin/article/details/45866615

指针数组：

#include<stdio.h>

#include<string.h>



#define  DIM(a)    (sizeof(a)/sizeof(*a))

//key为传入的字符串地址，table[]为传入的数组地址，size为传入的数组大小元素的个数

int lookup_keyword(const  char*  key,const   char*   table[ ],const   int  size)    

{

       int   ret=-1;

       int     i=0;

       for(i=0;i<size;i++)

       { 

               if(strcmp(key,table[i]==0))

               {

                      ret=i;

                      break;

               }

         }

               return     ret;

}



int   main()

{

    //定义指针数组并初始化

     const  char*  keyword[]={

                                            "do",

                                             "for",

                                             " if ",

                                             "register",

                                             "return",

                                              "switch",

                                               "while",    

                                               "case",

                                               "static"



                                                };           

                           printf("%d\n",lookup_keyword("return",keyword,DIM(keyword)));

                           printf("%d\n",lookup_keyword("return",keyword,DIM(keyword)));

}

结果输出为4，-1
原文：https://blog.csdn.net/liuchuangjin/article/details/45866615

指针函数：
（1） 基本概念

指针函数：顾名思义就是带有指针的函数，即其本质是一个函数，只不过这种函数返回的是一个对应类型的地址。

（2） 定义式

type *func (type , type)

如：int *max(int x, int y)

（3） 例子详解

#include <iostream>
using namespace std;


int *GetNum(int x); //指针函数声明形式


void main(void)
{
    cout<<"===============start================"<<endl;
    int num;
    cout<<"Please enter the number between 0 and 6: ";
    cin>>num;
    cout<<"result is:"<<*GetNum(num)<<endl;  //输出返回地址块中的值
}

int *GetNum(int x) {
    static int num[]={0,1,2,3,4,5,6};
    return &num[x];  //返回一个地址
}

函数指针:
1） 基本概念

函数指针：指向函数的指针变量，本质上是一个指针变量

（2） 定义式

type (*func)(type , type )

如：int  (*max)(int  a, int  b)

（3） 例子详解

#include <iostream>
using namespace std;
 
int max(int a, int b) {
    return a>b?a:b;
}
 
void main(void)
{
    cout<<"===========start==========="<<endl;
    int (*func)(int,int);       //定义一个指向该函数形式的指针变量
    func=max;
    int a,b;
    cout<<"Please enter two numbers:";
    cin>>a>>b;
    int result=(*func)(a,b);    //运用指针变量调用函数
    cout<<"max="<<result<<endl;
}

原文：https://blog.csdn.net/u014131641/article/details/51104808

二级指针：
举例

int c=2,d=3;
int *pc=&c;

pc是指针变量的存储内容，也就是c的地址

*pc就是对指针的解引用，取出这个c这个地址里面的值

实例

#include <stdio.h>
 
int c=2,d=3;
int *pc=&c;        //一级指针指向c
int **ppc = &pc;    //二级指针指向一级指针pc    （指向指针的指针）
 
int main()
{
    
 
    //一级指针*p指向c
    printf("一级指针*p指向c\n\n");
    printf("c的地址=%p      c的地址\n",&c);
    printf("pc的值 =%p       pc中指向的就是C的地址\n",pc);
    printf("*pc的值=%d              对c的地址进行取值*pc==2;\n",*pc);
 
    putchar('\n');
    printf("-------------------------------------------------------------\n");
 
    //二级指针（指针的指针）**ppc指向*pc  
    printf("二级指针（指针的指针）**ppc指向*pc\n\n");
    printf("pc的地址   =%p   一级指针pc的地址\n",&pc);    
    printf("ppc的值    =%p   二级指针ppc指向的地址其实就是一级指针pc的地址\n",ppc);   
    printf("*ppc的值   =%p   对ppc进行一次解引用，*ppc==pc，*ppc也就是c的地址\n",*ppc);  
    printf("*(*ppc)的值=%d          对ppc进行两次解引用，*(*ppc)==*pc==c==2\n",*(*ppc));
 
    putchar('\n');
    return 0;
}

原文：https://blog.csdn.net/qq_34991245/article/details/81868212

单向链表：

#include <stdio.h>
#include <math.h>
#include <cstring>
#include <memory.h>
#include <malloc.h>
 
 
//节点的定义
typedef struct Node {
 void *data; //数据域 //链域
 struct Node *next;
} NodeStruct, *pNode;
 
 
pNode head = NULL;
 
  
 
 
typedef char (*pCompareFunc)(void *a, void *b);
typedef void* (*pChar)(void *p);
 
 
// 字符串判断
int str_compare(void *a, void *b) {
 char *pa = (char*)a;
 char *pb = (char*)b;
 return strcmp(pa , pb);
}

// 分配一个节点
pNode allocate_node(void *data, pChar char_func) {
 pNode node = allocate();
 node->data = char_func(data);
 return node;
} 
// 创建节点
pNode allocate() {
 void *p = malloc(sizeof(NodeStruct));
 pNode node = (pNode)p;
 node->next = NULL;
 node->data = NULL;
 return node;
}
// 添加一个节点
void insertNode(pNode node){
 if (head == null){
  head=node;
  }
  else {
  node->next = head;
  head = node;
  }
}
void* char_char(void *p) {
 char* pa = (char*)malloc(sizeof(char));
 memcpy(pa, p, sizeof(char));
 return pa;
}
// 初始化节点
pNode allocate_node(void *data, pChar char_func) {
 pNode node = allocate();
 node->data = char_func(data);
 return node;
}
// 释放资源
void free_list(pNode node) {
 pNode next = node;
 
 
 while (next != NULL) {
  if (next->data != NULL)
   free(next->data);
  pNode temp = next;
  next = next->next;
  free(temp);
 }
}
 
 
// 1.1 添加一个节点
void insert(pNode node) {
 if (head == NULL)
  head = node;
 else {
  node->next = head;
  head = node;
 }
}
 
 
//1.2查找
int str_search(void* data,pCompareFunc compare){
 pNode next = head;
 pNode prev = NULL;
 while (next != NULL ) {
  if (compare(data, next->data) == 0) {
   // 如果查找到了，就退出返回1
   return 1;
   break;
  }
  prev = next;
  next = next->next;
 }
 // 如果一直查找不到，就返回0
 return 0;
}
 
 
// 1.3删除节点
void remove(void* data,pCompareFunc compare) {
 pNode next = head;
 pNode prev = NULL;
 while (next != NULL) {
 
 
  if (compare(data, next->data) == 0) {
   if (prev == NULL) {
    head = next->next;
    next->next = NULL;
    free_list(next);
   } else {
    prev->next = next->next;
    next->next = NULL;
    free_list(next);
   }
   break;
  }
  prev = next;
  next = next->next;
 }
 
 
}
 
 
//1.4反转
void invert_order()
{
  node *This,*prev;
  p=head.next;
  This=NULL;
  while(p) {
    prev=This;
    This=p;
    p=p->next;
    This->next=prev;
 
 
  }
  head.next=This;
}

原文链接https://www.jb51.net/article/92981.htm