( •̀ ω •́ )y( •̀ ω •́ )y精心整理C两百例【60例-120例】，持续更新.....

曾经终败给现在 2022-09-16 00:25 85阅读 0赞

## 前言 ##

> 汉诺塔问题、哈夫曼编码、图的深度优先遍历、八皇后问题、骑士巡游、绘制余弦曲线和直线的迭加、计算高次方数的尾数、打鱼还是晒网、怎样存钱以获取最大利息、阿姆斯特朗数、亲密数、自守数…

[( •̀ ω •́ )y( •̀ ω •́ )y精心整理C两百例【1-60例】，持续更新… ][_ _ _ _y_ _ _ _ _y_C_1-60_]

### 文章目录 ###

*   *  前言
     *  61、二叉树遍历
     *  62、数字金额转为大写金额
     *  63、汉诺塔问题
     *  64、哈夫曼编码
     *  65、图的深度优先遍历
     *  66、图的广度优先遍历
     *  67、求解最优交通路径
     *  68、八皇后问题
     *  69、骑士巡游
     *  70、基于队列、栈的字符串翻译
     *  71、火车车厢重排
     *  72、队列实例
     *  73、K阶斐波那契序列
     *  74、绘制余弦曲线和直线的迭加
     *  75、计算高次方数的尾数
     *  76、打鱼还是晒网
     *  77、怎样存钱以获取最大利息
     *  78、阿姆斯特朗数
     *  79、亲密数
     *  80、自守数
     *  81、具有abcd=(ab+cd)2性质的数
     *  82、验证歌德巴赫猜想
     *  83、素数幻方
     *  84、百钱百鸡问题
     *  85、爱因斯坦数学题
     *  86、三色球问题
     *  87、马克思手稿中的数学题
     *  88、配对新郎和新娘
     *  89、邮票组合
     *  90、分糖果
     *  91、波瓦松的分酒趣题
     *  92、求π的近似值
     *  93、奇数平方的有趣性质
     *  94、角谷猜想
     *  95、四方定理
     *  96、卡布列克常数
     *  97、尼科彻斯定理
     *  98、扑克牌自动发牌
     *  99、常胜将军
     *  100、搬山游戏
     *  101、兔子产子（斐波那契数列）
     *  102、数字移动
     *  103、多项式乘法
     *  104、产生随机数
     *  105、堆栈四则运算
     *  106、递归整数四则运算
     *  107、复平面作图
     *  108、绘制彩色抛物线
     *  109、绘制正态分布曲线
     *  110、求解非线性方程
     *  111、实矩阵乘法运算
     *  112、求解线性方程
     *  113、阶方阵求逆
     *  114、复矩阵乘法
     *  115、求定积分
     *  116、求满足特异条件的数列
     *  117、超长正整数的加法
     *  118、绘制直线
     *  119、绘制圆
     *  120、绘制圆弧

## 61、二叉树遍历 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    typedef struct bitnode
    { 
    	char data;
    	struct bitnode *lchild, *rchild;
    }bitnode, *bitree;
    
    /** 创建二叉树 */
    void createbitree(bitnode ** t, int *n)
    { 
    	char x;
    	bitnode *q;
    
    	*n = *n + 1;
    	printf("Input %d DATA: ", *n);
    	x = getchar();
    	if (x != '\n') getchar();
    
    	if (x == '^')
    		return;
    	/* 创建根节点 */
    	q = (bitnode*)malloc(sizeof(bitnode));
    	q->data = x;
    	q->lchild = NULL;
    	q->rchild = NULL;
    	*t = q;
    
    	printf("This Address is:%o,Data is:%c, Left Pointer is:%o,Right Pointer is: %o\n", q, q->data, q->lchild, q->rchild);
    
    	createbitree(&q->lchild, n);	// 创建左子树
    	createbitree(&q->rchild, n);	// 创建右子树
    	return;
    }
    
    /** 打印 */
    void visit(bitnode *e)
    { 
    	printf("Address: %o, Data: %c, Left Pointer: %o, Right Pointer: %o\n", e, e->data, e->lchild, e->rchild);
    }
    
    /** 前序遍历 */
    void preordertraverse(bitnode *t)
    { 
    	if (t)
    	{ 
    		visit(t);
    		preordertraverse(t->lchild);
    		preordertraverse(t->rchild);
    		return;
    	}
    	return;
    }
    
    /** 计算二叉树叶子数 */
    void countleaf(bitnode *t, int *c)
    { 
    	if (t != NULL)
    	{ 
    		if (t->lchild == NULL && t->rchild == NULL)
    			*c = *c + 1;
    
    		countleaf(t->lchild, c);
    		countleaf(t->rchild, c);
    	}
    	return;
    }
    
    /** 二叉树高度 */
    int tree_high(bitnode *t)
    { 
    	int lh, rh, h;
    	if (t == NULL)
    		h = 0;
    	else
    	{ 
    		lh = tree_high(t->lchild);
    		rh = tree_high(t->rchild);
    		h = (lh > rh ? lh : rh) + 1;
    	}
    
    	return h;
    }
    
    void main()
    { 
    	bitnode *t; int count = 0;
    	int n = 0;
    	printf("Please initialize the TREE!");
    	createbitree(&t, &n);
    
    	printf("This is TREE Struct:");
    	preordertraverse(t);
    
    	countleaf(t, &count);
    	printf("This TREE has %d leaves.", count);
    
    	printf("High of The TREE is: %d\n", tree_high(t));
    	system("pause");
    }

## 62、数字金额转为大写金额 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    
    char c_je[51] = { 0};  /* 大写金额字符变量 */
    
    /** 数字金额转换为大写金额子程序 */
    char* conversion(double x)                     
    { 
    	int i = 0, n = 0, bz = 1;
    	char money[14];        /* 数字金额的字符变量 */
    	char temp[13];
    
    	char f1[10][3] = {  "零", "壹", "贰", "叁", "肆", "伍",
    		"陆", "柒", "捌", "玖" };			 /*数字对应的大写数组变量*/
    
    	char f2[11][3] = {  "亿", "仟", "佰", "拾", "万",
    		"仟", "佰", "拾", "元", "角", "分" }; /*每位数字对应单位数组变量*/
    	sprintf(money, "%.01f", 100 * x);		 /* 转换成字符,精确到分 */
    	n = strlen(money);
    	for (i = 0; i < n; i++)
    	{ 
    		strcpy(temp, &money[i]);  /* 复制到临时数组 */
    
    		if (atoi(temp) == 0)      /* 判断第i位后是否全为0 */
    		{ 
    			bz = 2;
    			break;
    		}
    		if (money[i] != '0')
    		{ 
    			if (bz == 0)
    				strcat(c_je, f1[0]);
    			strcat(c_je, f1[money[i] - '0']); /* 数字串转化字符串 */
    			bz = 1;
    			strcat(c_je, f2[13 - n + i]);	/* 单位转换 */
    		}
    		else
    		{ 
    			if (n - i == 7 && (money[i - 1] != '0' || money[i - 2] != '0' || money[i - 3] != '0')) /* 判断万位位置 */
    				strcat(c_je, "万");
    			if (n - i == 3)					/* 判断个位数的元位置 */
    				strcat(c_je, "元");
    			bz = 0;
    		}
    	}
    	if (bz == 2)
    	{ 
    		if (n - i >= 7 && n - i < 10)
    			strcat(c_je, "万"); /* 万位数字为0，加‘万’ */
    		if (n - i >= 3)
    			strcat(c_je, "元");
    		strcat(c_je, "正");		/* 最后不是分位，加“正” */
    	}
    	return c_je;				/* 返回大写金额 */
    }
    
    void main()
    { 
    	double count;
    	printf("*********************************************************\n");
    	printf("* *\n");
    	printf("* 数字金额转换为大写金额程序 Ver.1.0 *\n");
    	printf("* *\n");
    	printf("* *\n");
    	printf("* 请输入要转换的金额： *\n");
    	printf("* ");
    	scanf("%lf", &count);
    	printf("* 您输入的金额为：%10.2lf 。 *\n", count);
    	printf("* *\n");
    	printf("*转换为大写金额是：%s\n", conversion(count));
    	printf("* *\n");
    	system("pause");
    }

## 63、汉诺塔问题 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    /* 实现将n个盘子从a移动到c */
    void hanoil(int n, char a, char b, char c)
    { 
    	if (n == 1)			/* 递归调用的出口，n=1 */
    		printf(" >> Move Plate No.%d from Stick %c to Stick %c.\n", n, a, c);
    	else
    	{ 
    		hanoil(n - 1, a, c, b);  /* 递归调用 */
    		printf(" >> Move Plate No.%d from Stick %c to Stick %c.\n", n, a, c);
    		hanoil(n - 1, b, a, c);
    	}
    }
    
    
    void main()
    { 
    	int n;
    	char a = 'A';
    	char b = 'B';
    	char c = 'C';
    	printf("This is a hanoil program.\nPlease input number of the plates:");
    	scanf("%d", &n);
    	if (n <= 0)
    	{ 
    		puts("n must no less than 1!");
    		exit(1);
    	}
    	puts("The steps of moving plates are:");
    	hanoil(n, a, b, c);
    	system("pause");
    }

## 64、哈夫曼编码 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    #define MAX 1000
    #define MAXSYMBS 30
    #define MAXNODE 59
    
    typedef struct
    { 
    	int weight;
    	int flag;
    	int parent;
    	int lchild;
    	int rchild;
    }huffnode;
    
    typedef struct
    { 
    	int bits[MAXSYMBS];
    	int start;
    }huffcode;
    
    void main()
    { 
    	huffnode huff_node[MAXNODE];
    	huffcode huff_code[MAXSYMBS], cd;
    	int i, j, m1, m2, x1, x2, n, c, p;
    
    	/* 数组huff_node初始化 */
    	printf("please input the leaf num of tree:");
    	scanf("%d", &n);
    	for (i = 0; i<2 * n - 1; i++)
    	{ 
    		huff_node[i].weight = 0;
    		huff_node[i].parent = 0;
    		huff_node[i].flag = 0;
    		huff_node[i].lchild = -1;
    		huff_node[i].rchild = -1;
    	}
    
    	printf("please input the weight of every leaf:");
    	for (i = 0; i<n; i++)
    		scanf("%d", &huff_node[i].weight);
    
    	/* 构造哈夫曼树 */
    	for (i = 0; i<n - 1; i++)
    	{ 
    		m1 = m2 = MAX;
    		x1 = x2 = 0;
    		for (j = 0; j<n + i; j++)
    		{ 
    			if (huff_node[j].weight<m1&&huff_node[j].flag == 0)
    			{ 
    				m2 = m1;
    				x2 = x1;
    				m1 = huff_node[j].weight;
    				x1 = j;
    			}
    			else if (huff_node[j].weight<m2&&huff_node[j].flag == 0)
    			{ 
    				m2 = huff_node[j].weight;
    				x2 = j;
    			}
    		}
    
    		huff_node[x1].parent = n + i;    /*将找出的两棵子树合并为一棵子树*/
    		huff_node[x2].parent = n + i;
    		huff_node[x1].flag = 1;
    		huff_node[x2].flag = 1;
    		huff_node[n + i].weight = huff_node[x1].weight + huff_node[x2].weight;
    		huff_node[n + i].lchild = x1;
    		huff_node[n + i].rchild = x2;
    	}
    
    	/* 求字符的哈夫曼编码 */
    	for (i = 0; i<n; i++)
    	{ 
    		cd.start = n;
    		c = i;
    		p = huff_node[c].parent;
    		while (p != 0)
    		{ 
    			if (huff_node[p].lchild == c)
    
    				cd.bits[cd.start] = 0;
    			else
    				cd.bits[cd.start] = 1;
    			cd.start = cd.start - 1;
    			c = p;
    			p = huff_node[p].parent;
    		}
    		cd.start++;
    		for (j = cd.start; j <= n; j++)
    			huff_code[i].bits[j] = cd.bits[j];
    		huff_code[i].start = cd.start;
    	}
    
    	/* 输出字符的哈夫曼编码 */
    	puts("The Hafman code are:");
    	for (i = 0; i<n; i++)
    	{ 
    		for (j = huff_code[i].start; j <= n; j++)
    			printf("%10d", huff_code[i].bits[j]);
    		printf("\n");
    	}
    	system("pause");
    }

## 65、图的深度优先遍历 ##

#include<stdlib.h>
    #include<string.h>
    #include<stdio.h>
    
    struct node                       /* 图顶点结构定义 */
    { 
    	int vertex;                    /* 顶点数据信息 */
    	struct node *nextnode;         /* 指下一顶点的指标 */
    };
    
    typedef struct node *graph;       /* 图形的结构新型态 */
    struct node head[9];              /* 图形顶点数组 */
    int visited[9];                   /* 遍历标记数组 */
    
    
    
    /** 根据已有的信息建立邻接表 */
    void creategraph(int node[20][2], int num)
    { 	/* num指的是图的边数 */
    	graph newnode;								/* 指向新节点的指针定义 */
    	graph ptr;
    	int start;									/* 边的起点 */
    	int end;									/* 边的终点 */
    	int i;
    
    	/* 读取边线信息，插入邻接表*/
    	for (i = 0; i < num; i++)		
    	{ 
    		start = node[i][0];         /* 边线的起点 */
    		end = node[i][1];           /* 边线的终点 */
    
    		/* 建立新顶点 */
    		newnode = (graph)malloc(sizeof(struct node));
    		newnode->vertex = end;       /* 建立顶点内容 */
    		newnode->nextnode = NULL;    /* 设定指标初值 */
    		ptr = &(head[start]);        /* 顶点位置 */
    
    		/* 遍历至链表尾 */
    		while (ptr->nextnode != NULL)
    			ptr = ptr->nextnode;     /* 下一个顶点 */
    		ptr->nextnode = newnode;     /* 插入节点 */
    	}
    }
    
    
    /** 图的深度优先搜寻法 */
    void dfs(int current)
    { 
    	graph ptr;
    
    	visited[current] = 1;					/* 记录已遍历过 */
    	printf("vertex[%d]\n", current);		/* 输出遍历顶点值 */
    	ptr = head[current].nextnode;			/* 顶点位置 */
    	while (ptr != NULL)						/* 遍历至链表尾 */
    	{ 
    		if (visited[ptr->vertex] == 0)		/* 如过没遍历过 */
    			dfs(ptr->vertex);				/* 递回遍历呼叫 */
    		ptr = ptr->nextnode;				/* 下一个顶点 */
    	}
    }
    
    
    void main()
    { 
    	graph ptr;
    	int node[20][2] = {  {  1, 2 }, {  2, 1 },  /* 边线数组 */
    	{  1, 3 }, {  3, 1 },
    	{  1, 4 }, {  4, 1 },
    	{  2, 5 }, {  5, 2 },
    	{  2, 6 }, {  6, 2 },
    	{  3, 7 }, {  7, 3 },
    	{  4, 7 }, {  4, 4 },
    	{  5, 8 }, {  8, 5 },
    	{  6, 7 }, {  7, 6 },
    	{  7, 8 }, {  8, 7 } };
    
    	int i;
    	/* 顶点数组初始化 */
    	for (i = 1; i <= 8; i++)					
    	{ 
    		head[i].vertex = i;						/* 设定顶点值 */
    		head[i].nextnode = NULL;				/* 指针为空 */
    		visited[i] = 0;							/* 设定遍历初始标志 */
    	}
    
    	/* 建立邻接表 */
    	creategraph(node, 20);						
    	printf("Content of the gragh's ADlist is:\n");
    	for (i = 1; i <= 8; i++)
    	{ 
    		printf("vertex%d ->", head[i].vertex);  /* 顶点值 */
    		ptr = head[i].nextnode;					/* 顶点位置 */
    		while (ptr != NULL)						/* 遍历至链表尾 */
    		{ 
    			printf(" %d ", ptr->vertex);		/* 印出顶点内容 */
    			ptr = ptr->nextnode;				/* 下一个顶点 */
    		}
    		printf("\n");              
    	}
    
    	/* 打印输出遍历过程 */
    	printf("The end of the dfs are:\n");
    	dfs(1);                      
    	printf("\n");                  
    	system("pause");
    }

## 66、图的广度优先遍历 ##

#include <stdlib.h>
    #include <stdio.h>
    #define MAXQUEUE 10 /* 队列的最大容量 */
    
    /* 图的顶点结构定义 */
    struct node                       
    { 
    	int vertex;
    	struct node *nextnode;
    };
    
    typedef struct node *graph;       /* 图的结构指针 */
    struct node head[9];              /* 图的顶点数组 */
    int visited[9];                   /* 遍历标记数组 */
    
    int queue[MAXQUEUE];              /* 定义序列数组 */
    int front = -1;                   /* 序列前端 */
    int rear = -1;                    /* 序列后端 */
    
    
    /** 二维数组向邻接表的转化 */
    void creategraph(int node[20][2], int num)
    { 
    	graph newnode;					/* 顶点指针 */
    	graph ptr;
    
    	int start;                      /* 边起点 */
    	int end;                        /* 边终点 */
    	int i;
    
    	for (i = 0; i < num; i++)		/* 第i条边的信息处理 */
    	{ 
    		start = node[i][0];         /* 边的起点 */
    		end = node[i][1];           /* 边的终点 */
    
    		/* 建立新顶点 */
    		newnode = (graph)malloc(sizeof(struct node));
    		newnode->vertex = end;			/* 顶点内容 */
    		newnode->nextnode = NULL;		/* 设定指针初值 */
    		ptr = &(head[start]);			/* 顶点位置 */
    
    		/* 遍历至链表尾 */
    		while (ptr->nextnode != NULL)	
    			ptr = ptr->nextnode;        /* 下一个顶点 */
    		ptr->nextnode = newnode;        /* 插入第i个节点的链表尾部 */
    	}
    }
    
    
    /** 数值入队列 */
    int enqueue(int value)
    { 
    	if (rear >= MAXQUEUE)			/* 检查伫列是否全满 */
    		return -1;                  /* 无法存入 */
    	rear++;                         /* 后端指标往前移 */
    	queue[rear] = value;            /* 存入伫列 */
    }
    
    
    /** 数值出队列 */
    int dequeue()
    { 
    	if (front == rear)				/* 队列是否为空 */
    		return -1;                  /* 为空，无法取出 */
    	front++;						/* 前端指标往前移 */
    	return queue[front];			/* 从队列中取出信息 */
    }
    
    
    /** 图形的广度优先遍历 */
    void bfs(int current)
    { 
    	graph ptr;
    
    	/* 处理第一个顶点 */
    	enqueue(current);						/* 将顶点存入队列 */
    	visited[current] = 1;					/* 已遍历过记录标志置疑1 */
    	printf(" Vertex[%d]\n", current);		/* 打印输出遍历顶点值 */
    	while (front != rear)					/* 队列是否为空 */
    	{ 
    		current = dequeue();				/* 将顶点从队列列取出 */
    		ptr = head[current].nextnode;		/* 顶点位置 */
    		while (ptr != NULL)					/* 遍历至链表尾 */
    		{ 
    			if (visited[ptr->vertex] == 0)	/* 顶点没有遍历过 */
    			{ 
    				enqueue(ptr->vertex);		/* 奖定点放入队列 */
    				visited[ptr->vertex] = 1;	/* 置遍历标记为1 */
    
    				printf(" Vertex[%d]\n", ptr->vertex);/* 印出遍历顶点值 */
    			}
    			ptr = ptr->nextnode;     /* 下一个顶点 */
    		}
    	}
    }
    
    
    void main()
    { 
    	graph ptr;
    	int node[20][2] = {  {  1, 2 }, {  2, 1 },  /* 边信息数组 */
    	{  6, 3 }, {  3, 6 },
    	{  2, 4 }, {  4, 2 },
    	{  1, 5 }, {  5, 1 },
    	{  3, 7 }, {  7, 3 },
    	{  1, 7 }, {  7, 1 },
    	{  4, 8 }, {  8, 4 },
    	{  5, 8 }, {  8, 5 },
    	{  2, 8 }, {  8, 2 },
    	{  7, 8 }, {  8, 7 } };
    	int i;
    	puts("This is an example of Width Preferred Traverse of Gragh.\n");
    	/* 顶点结构数组初始化 */
    	for (i = 1; i <= 8; i++)        
    	{ 
    		head[i].vertex = i;
    		head[i].nextnode = NULL;
    		visited[i] = 0;
    	}
    	/* 图信息转换，邻接表的建立 */
    	creategraph(node, 20);       
    	printf("The content of the graph's allist is:\n");
    	for (i = 1; i <= 8; i++)
    	{ 
    		printf(" vertex%d =>", head[i].vertex); /* 顶点值 */
    		ptr = head[i].nextnode;					/* 顶点位置 */
    		while (ptr != NULL)						/* 遍历至链表尾 */
    		{ 
    			printf(" %d ", ptr->vertex);		/* 打印输出顶点内容 */
    			ptr = ptr->nextnode;				/* 下一个顶点 */
    		}
    		printf("\n");               
    	}
    	printf("The contents of BFS are:\n");
    	bfs(1);										/* 打印输出遍历过程 */
    	printf("\n");                 
    	system("pause");
    }

## 67、求解最优交通路径 ##

#include <stdlib.h>
    #include <stdio.h>
    
    /** 定义边的类型 */
    typedef struct ArcCell{ 
    	int adj;  /*相邻接的城市序号*/
    }ArcCell; 
    
    /** 定义顶点的类型 */
    typedef struct VertexType{ 
    	int number;		/*城市序号*/
    	char *city;		/*城市名称*/
    }VertexType; 
    
    /** 定义图的类型 */
    typedef struct{ 
    	VertexType vex[25];   /* 图中的顶点，即为城市 */
    	ArcCell arcs[25][25]; /* 图中的边，即为城市间的距离 */
    	int vexnum, arcnum;   /* 顶点数，边数 */
    }MGraph; 
    
    MGraph G; /* 把图定义为全局变量 */
    
    int P[25][25] = {  0 };	// 城市之间是否可到达
    long int D[25] = {  0 };	// 存储距离
    
    /** 造图函数 */
    void CreateUDN(int v, int a)
    {  
    	int i, j;
    	G.vexnum = v;		// 25个城市
    	G.arcnum = a;		// 30条边
    	// 初始化城市序号
    	for (i = 0; i<G.vexnum; ++i) G.vex[i].number = i;
    
    	/*下边是城市名*/
    	G.vex[0].city = "乌鲁木齐";
    	G.vex[1].city = "西宁";
    	G.vex[2].city = "兰州";
    	G.vex[3].city = "呼和浩特";
    	G.vex[4].city = "北京";
    	G.vex[5].city = "天津";
    	G.vex[6].city = "沈阳";
    	G.vex[7].city = "长春";
    	G.vex[8].city = "哈尔滨";
    	G.vex[9].city = "大连";
    	G.vex[10].city = "西安";
    	G.vex[11].city = "郑州";
    	G.vex[12].city = "徐州";
    	G.vex[13].city = "成都";
    	G.vex[14].city = "武汉";
    	G.vex[15].city = "上海";
    	G.vex[16].city = "昆明";
    	G.vex[17].city = "贵州";
    	G.vex[18].city = "株洲";
    	G.vex[19].city = "南昌";
    	G.vex[20].city = "福州";
    	G.vex[21].city = "柳州";
    	G.vex[22].city = "南宁";
    	G.vex[23].city = "广州";
    	G.vex[24].city = "深圳";
    
    	/* 这里把所有的边假定为20000，含义是城市间不可到达 */
    	for (i = 0; i< G.vexnum; ++i)
    		for (j = 0; j< G.vexnum; ++j)
    			G.arcs[i][j].adj = 20000;
    	/*下边是可直接到达的城市间的距离，由于两个城市间距离是互相的，所以要对图中对称的边同时赋值。*/
    	G.arcs[0][2].adj = G.arcs[2][0].adj = 1892;
    	G.arcs[1][2].adj = G.arcs[2][1].adj = 216;
    	G.arcs[2][3].adj = G.arcs[3][2].adj = 1145;
    	G.arcs[2][10].adj = G.arcs[10][2].adj = 676;
    	G.arcs[3][4].adj = G.arcs[4][3].adj = 668;
    	G.arcs[4][5].adj = G.arcs[5][4].adj = 137;
    	G.arcs[5][6].adj = G.arcs[6][5].adj = 704;
    	G.arcs[6][7].adj = G.arcs[7][6].adj = 305;
    	G.arcs[7][8].adj = G.arcs[8][7].adj = 242;
    	G.arcs[6][9].adj = G.arcs[9][6].adj = 397;
    	G.arcs[4][11].adj = G.arcs[11][4].adj = 695;
    	G.arcs[5][12].adj = G.arcs[12][5].adj = 674;
    	G.arcs[10][13].adj = G.arcs[13][10].adj = 842;
    	G.arcs[11][14].adj = G.arcs[14][11].adj = 534;
    	G.arcs[12][15].adj = G.arcs[15][12].adj = 651;
    	G.arcs[13][16].adj = G.arcs[16][13].adj = 1100;
    	G.arcs[13][17].adj = G.arcs[17][13].adj = 967;
    	G.arcs[14][18].adj = G.arcs[18][14].adj = 409;
    	G.arcs[17][18].adj = G.arcs[18][17].adj = 902;
    	G.arcs[15][19].adj = G.arcs[19][15].adj = 825;
    	G.arcs[18][19].adj = G.arcs[19][18].adj = 367;
    	G.arcs[19][20].adj = G.arcs[20][19].adj = 622;
    	G.arcs[17][21].adj = G.arcs[21][17].adj = 607;
    	G.arcs[18][21].adj = G.arcs[21][18].adj = 672;
    	G.arcs[21][22].adj = G.arcs[22][21].adj = 255;
    	G.arcs[18][23].adj = G.arcs[23][18].adj = 675;
    	G.arcs[23][24].adj = G.arcs[24][23].adj = 140;
    	G.arcs[16][17].adj = G.arcs[17][16].adj = 639;
    	G.arcs[10][11].adj = G.arcs[11][10].adj = 511;
    	G.arcs[11][12].adj = G.arcs[12][11].adj = 349;
    }
    
    void narrate() 
    { 
    	int i, k = 0;
    	printf("\n*****************欢迎使用最优交通路径程序!***************\n");
    	printf("\n城市列表如下:\n\n");
    	for (i = 0; i<25; i++)
    	{ 
    		printf("(%2d)%-10s", i, G.vex[i].city); /*输出城市列表*/
    		k = k + 1;
    		if (k % 4 == 0) printf("\n");
    	}
    }
    
    /** 最短路径函数 */
    void ShortestPath(int city) 
    { 
    	int v, w, i, t;
    	int final[25];
    	int min;
    	for (v = 0; v<25; ++v)
    	{ 
    		final[v] = 0; 
    		D[v] = G.arcs[city][v].adj;	// 所以与该城市有关的距离
    
    		if (D[v]<20000) {  P[v][city] = 1; P[v][v] = 1; }
    	}
    	D[city] = 0; final[city] = 1;	// 将该城市做上标记
    	for (i = 0; i<25; ++i)
    	{ 
    		min = 20000;
    		for (w = 0; w<25; ++w)
    			if (!final[w])	// 判断是否为city
    				if (D[w]<min){  v = w; min = D[w]; }// 为可到达的城市
    
    		final[v] = 1;	// 可到达
    
    		for (w = 0; w<25; ++w)
    			if (!final[w] && ((min + G.arcs[v][w].adj) < D[w]))
    			{ 
    				D[w] = min + G.arcs[v][w].adj;
    				for (t = 0; t<25; t++) P[w][t] = P[v][t];
    				P[w][w] = 1;
    			}
    	}
    }
    
    /** 输出函数 */
    void output(int city1, int city2) 
    { 
    	int a, b, c, d, q = 0;
    	a = city2;
    	if (a != city1)
    	{ 
    		printf("\n从%s到%s的最短路径是", G.vex[city1].city, G.vex[city2].city);
    		printf("(最短距离为 %dkm.)\n\t", D[a]);
    		printf("%s", G.vex[city1].city);
    		d = city1;
    		for (c = 0; c<25; ++c)
    		{ 
    		gate:;	/* 标号，可以作为goto语句跳转的位置 */
    			P[a][city1] = 0;
    			for (b = 0; b<25; b++)
    			{ 
    				if (G.arcs[d][b].adj<20000 && P[a][b])
    				{ 
    					printf("-->%s", G.vex[b].city); q = q + 1;
    					P[a][b] = 0;
    					d = b;
    					if (q % 8 == 0) printf("\n");
    					goto gate;
    				}
    			}
    		}
    	}
    
    }
    void main() /*主函数*/
    { 
    	int v0, v1;
    	CreateUDN(25, 30);
    
    	narrate();
    	printf("\n请选择起点城市（0～24）：\n");
    	scanf("%d", &v0);
    	printf("请选择终点城市（0～24）：\n");
    	scanf("%d", &v1);
    	ShortestPath(v0);  /*计算两个城市之间的最短路径*/
    	output(v0, v1);     /*输出结果*/
    	printf("\n");
    	system("pause");
    }

## 68、八皇后问题 ##

#include <math.h>
    #include <stdlib.h>
    #include <stdio.h>
    
    #define MAX 8 /* 棋子数及棋盘大小MAXxMAX */
    int board[MAX];
    
    /** 印出結果 */
    void show_result()
    { 
    	int i;
    	for (i = 0; i<MAX; i++)
    		printf("(%d,%d)", i, board[i]);
    	printf("\n");
    }
    
    /** 检查是否在同一直橫斜线上有其它棋子 */
    int check_cross(int n)
    { 
    	int i;
    	for (i = 0; i<n; i++){ 
    		if (board[i] == board[n] || (n - i) == abs(board[i] - board[n]))return 1;
    	}
    	return 0;
    }
    
    /** 放棋子到棋盘上 */
    void put_chess(int n)
    { 
    	int i;
    	for (i = 0; i<MAX; i++){ 
    		board[n] = i;
    		if (!check_cross(n)){ 
    			if (n == MAX - 1) show_result();/* 找到其中一种放法了...印出結果 */
    			else put_chess(n + 1);
    		}
    	}
    }
    
    void main()
    { 
    	puts("The possible placements are:");
    	put_chess(0);
    	puts("\n Press any key to quit...");
    	system("pause");
    }

## 69、骑士巡游 ##

#include <stdlib.h>
    #include <stdio.h>
    
    int f[11][11];                      /*定义一个矩阵来模拟棋盘*/
    int adjm[121][121];					/*标志矩阵，即对于上述棋盘，依次进行编号 1--121(行优先）可以从一个棋盘格i跳到棋盘格j时，adjm[i][j]=1*/
    
    void creatadjm(void);                     /* 创建标志矩阵函数声明 */
    void mark(int, int, int, int);            /* 将标志矩阵相应位置置1 */
    void travel(int, int);                    /* 巡游函数声明 */
    int n, m;                                 /* 定义矩阵大小及标志矩阵的大小 */
    
    
    int main()
    { 
    	int i, j, k, l;
    	printf("Please input size of the chessboard: ");		/*输入矩阵的大小值*/
    	scanf("%d", &n);
    	m = n*n;
    	creatadjm();											/*创建标志矩阵*/
    	puts("The sign matrix is:");
    	for (i = 1; i <= m; i++)                                /*打印输出标志矩阵*/
    	{ 
    		for (j = 1; j <= m; j++)
    			printf("%2d", adjm[i][j]);
    		printf("\n");
    	}
    
    	printf("Please input the knight's position (i,j): ");	/*输入骑士的初始位置*/
    	scanf("%d %d", &i, &j);
    	l = (i - 1)*n + j;										/*骑士当前位置对应的标志矩阵的横坐标*/
    	while ((i>0) || (j>0))									/*对骑士位置的判断*/
    	{ 
    		for (i = 1; i <= n; i++)                            /*棋盘矩阵初始化*/
    		for (j = 1; j <= n; j++)
    			f[i][j] = 0;
    		k = 0;												/*所跳步数计数*/
    		travel(l, k);										/*从i,j出发开始巡游*/
    		puts("The travel steps are:");
    		for (i = 1; i <= n; i++)							/*巡游完成后输出巡游过程*/
    		{ 
    			for (j = 1; j <= n; j++)
    				printf("%4d", f[i][j]);
    			printf("\n");
    		}
    
    		printf("Please input the knight's position (i,j): ");/*为再次巡游输入起始位置*/
    		scanf("%d %d", &i, &j);
    		l = (i - 1)*n + j;
    	}
    	system("pause");
    }
    
    
    
    /** 创建标志矩阵子函数 **/
    void creatadjm()
    { 
    	int i, j;
    	/*巡游矩阵初始化*/
    	for (i = 1; i <= n; i++)		
    		for (j = 1; j <= n; j++)
    			f[i][j] = 0;
    	/*标志矩阵初始化*/
    	for (i = 1; i <= m; i++)		
    		for (j = 1; j <= m; j++)
    			adjm[i][j] = 0;
    	for (i = 1; i <= n; i++)
    		/*对所有符合条件的标志矩阵种元素置1*/
    		for (j = 1; j <= n; j++)
    			if (f[i][j] == 0)				
    			{ 
    				f[i][j] = 1;
    				if ((i + 2 <= n) && (j + 1 <= n)) mark(i, j, i + 2, j + 1);
    				if ((i + 2 <= n) && (j - 1 >= 1)) mark(i, j, i + 2, j - 1);
    				if ((i - 2 >= 1) && (j + 1 <= n)) mark(i, j, i - 2, j + 1);
    				if ((i - 2 >= 1) && (j - 1 >= 1)) mark(i, j, i - 2, j - 1);
    				if ((j + 2 <= n) && (i + 1 <= n)) mark(i, j, i + 1, j + 2);
    				if ((j + 2 <= n) && (i - 1 >= 1)) mark(i, j, i - 1, j + 2);
    				if ((j - 2 >= 1) && (i + 1 <= n)) mark(i, j, i + 1, j - 2);
    				if ((j - 2 >= 1) && (i - 1 >= 1)) mark(i, j, i - 1, j - 2);
    			}
    }
    
    
    /** 巡游子函数 */
    void travel(int p, int r)
    { 
    	int i, j, q;
    	for (i = 1; i <= n; i++)
    	for (j = 1; j <= n; j++)
    	if (f[i][j]>r) f[i][j] = 0;					/*棋盘矩阵的置〉r时，置0*/
    	r = r + 1;									/*跳步计数加1*/
    	i = ((p - 1) / n) + 1;						/*还原棋盘矩阵的横坐标*/
    	j = ((p - 1) % n) + 1;						/*还原棋盘矩阵的纵坐标*/
    	f[i][j] = r;								/*将f[i][j]做为第r跳步的目的地*/
    
    
    	/* 从所有可能的情况出发，开始进行试探式巡游 */
    	for (q = 1; q <= m; q++)          
    	{ 
    		i = ((q - 1) / n) + 1;
    		j = ((q - 1) % n) + 1;
    		if ((adjm[p][q] == 1) && (f[i][j] == 0))
    			travel(q, r);						/*递归调用自身*/              
    	}
    	return;
    }
    
    /** 赋值子函数 */
    void mark(int i1, int j1, int i2, int j2)
    { 
    	adjm[(i1 - 1)*n + j1][(i2 - 1)*n + j2] = 1;
    	adjm[(i2 - 1)*n + j2][(i1 - 1)*n + j1] = 1;
    }

## 70、基于队列、栈的字符串翻译 ##

#include <stdio.h> 
    #include <string.h> 
    #include <stdlib.h> 
    #include <conio.h> 
    
    /*定义全局变量*/
    #define TRUE 1 
    #define FALSE 0 
    #define OK 1 
    #define ERROR 0 
    #define NULL 0 
    #define OVERFLOW -2 
    #define MAXSIZE 100 
    #define stack_init_size 100 
    #define stackincrement 10 
    typedef   char   selemType;
    typedef   char   qelemType;
    typedef   char   elemType;
    typedef   int   status;
    char   e;
    char   demon[MAXSIZE];
    
    /* 类型及其基本操作*/
    typedef struct
    { 
    	selemType *base;
    	selemType *top;
    	int stacksize;
    }sqstack;
    
    /** 初始化栈 */
    status initstack(sqstack *s)
    { 
    	s->base = (selemType *)malloc(stack_init_size*sizeof(selemType));
    	if (!s->base)   exit(OVERFLOW);
    	s->top = s->base;
    	s->stacksize = stack_init_size;
    	return   OK;
    }
    
    /** 入栈 */
    status push(sqstack *s, selemType e)
    { 
    	if (s->top - s->base >= s->stacksize)
    	{ 
    		s->base = (elemType*)realloc(s->base, (s->stacksize + stackincrement)*sizeof(elemType));
    		if (!s->base)   exit(OVERFLOW);
    		s->top = s->base + s->stacksize;
    		s->stacksize += stackincrement;
    	}
    	*(s->top++) = e;
    	return   OK;
    }
    
    /** 出栈 */
    status pop(sqstack   *s, selemType   *e)
    { 
    	if (s->top == s->base)   return   ERROR;
    	*e = *(--(s->top));
    	return   OK;
    }
    
    /** 队列类型及其基本操作 */
    typedef struct qnode
    { 
    	qelemType   data;
    	struct   qnode   *next;
    }qnode, *queueptr;
    
    typedef struct
    { 
    	queueptr   front;
    	queueptr   rear;
    }linkqueue;
    
    /** 初始化队列 */
    status initqueue(linkqueue   *q)
    { 
    	q->front = q->rear = (queueptr)malloc(sizeof(qnode));
    	if (!q->front)   exit(OVERFLOW);
    	q->front->next = NULL;
    	return   OK;
    }
    
    /** 入队 */
    status enqueue(linkqueue *q, qelemType e)
    { 
    	queueptr   p;
    	p = (queueptr)malloc(sizeof(qnode));
    	if (!p)   exit(OVERFLOW);
    	p->data = e;
    	p->next = NULL;
    	q->rear->next = p;
    	q->rear = p;
    	return   OK;
    }
    
    /** 出队 */
    status dequeue(linkqueue *q, qelemType *e)
    { 
    	queueptr p;
    	if (q->front == q->rear) return ERROR;
    	p = q->front->next;
    	*e = p->data;
    	q->front->next = p->next;
    	if (q->rear == p)
    	{ 
    		q->rear = q->front;
    	}
    	free(p);
    	return   OK;
    }
    
    /** 临时栈 */
    void tempstack(sqstack *temps)
    { 
    	int   i = 0;
    	char   t;
    	char   c;
    	c = demon[i];
    	for (i = 0; c != '#'; i++)	/* 遍历数组 */
    	{ 
    		c = demon[i];
    		if (c == '(')			/* 遇到开括号 */
    		{ 
    			t = demon[i + 1];	/* 取括号中的首字母 */
    			push(temps, t);		/* 入栈 */
    			i++;				/* 指向首字母 */
    			do
    			{ 
    				i++;
    				c = demon[i];
    				push(temps, c)	/* 第一次循环将次字母入栈 */;
    				push(temps, t);	/* 再将首字母进栈 */
    			} while (c != ')');	/* 直到括号中元素全部进栈 */
    			pop(temps, &t);		/* 将多余进栈的首字母t出栈 */
    			pop(temps, &t);		/* 将多余进栈的')'出栈 */
    		}
    	}
    }
    
    /** 特殊入队函数 */
    void spenqueue(linkqueue   *q, char   key)
    { 
    	int j = 0;
    	char a[5];
    	switch (key)   /* 判断大写字母对应的字符串 */
    	{ 
    		case'A':strcpy(a, "ase"); break;
    		case'B':strcpy(a, "tAdA"); break;
    		case'C':strcpy(a, "abc"); break;
    		case'D':strcpy(a, "def"); break;
    		case'E':strcpy(a, "ghi"); break;
    		case'F':strcpy(a, "klm"); break;
    		case'H':strcpy(a, "mop"); break;
    		default:strcpy(a, "???");   /* 不能翻译的魔王语言以"???"输出 */
    	}
    	while (a[j] != '\0')   /* 如果数组还有字母 */
    	{ 
    		enqueue(q, a[j]);/*进队*/
    		j++;
    	}
    }
    
    /** 排序入队处理函数 */
    status sort(sqstack   *s, linkqueue   *q)
    { 
    	qnode b;
    	int flag = 0;						/* 大写字母监视哨置零 */
    	int i;	
    	for (i = 0; demon[i] != '#'; i++)	/*遍历数组*/
    	{ 
    		b.data = demon[i];
    		if (('a' <= b.data&&b.data <= 'z') || b.data == '?')   /* 如果是小写字母或者'?'　则直接进栈 */
    		{ 
    			enqueue(q, b.data);
    		}
    		else
    		{ 
    			if ('A' <= b.data&&b.data <= 'Z')   /*如果是大写字母,则调用特殊进栈函数,*/
    			{ 
    				spenqueue(q, b.data);
    				flag = 1;					/*发现大写字母监视哨置1*/
    			}
    			else
    			{ 
    				if (b.data == '(')			/* 如果是括号 */
    				{ 
    					do
    					{ 
    						pop(s, &e);
    						enqueue(q, e);
    					} while (!(s->top == s->base));   /* 只要栈不为空,则出栈进队 */
    					while (b.data != ')')	 /* 只要还指向括号内元素,就继续往后移,保证原括号内的元素不再进栈*/
    					{ 
    						i++;
    						b.data = demon[i];
    					}
    				}
    			}
    		}
    	}
    	return   flag;
    }
    
    void main()
    { 
    	sqstack   s1;
    	linkqueue   q1;
    	int   k = 0;
    	int   flag = 1;
    	printf("Please Input the Demon's Words:\n");
    	printf("!: Less Than 30 Letters: )\n");
    	printf("!: End with '#': )\n");
    	scanf("%s", demon);
    	printf("\n***************************************");
    	initstack(&s1);		/* 创建栈 */
    	initqueue(&q1);		/* 创建队 */
    	tempstack(&s1);		/* 调用函数 */
    	while (flag == 1)   /* 如果有大写字母 */
    	{ 
    		k = 0;
    		flag = sort(&s1, &q1);
    		while (q1.front != q1.rear)   /*重写demon[i ]*/
    		{ 
    			dequeue(&q1, &e);
    			demon[k] = e;
    			k++;
    		}
    		demon[k] = '#';
    	}
    	demon[k] = '\0';
    	printf("\n***************************************");
    	printf("\nThe Human Words:\n\t%s", demon);
    	printf("\n***************************************");
    	system("pause");
    }

## 71、火车车厢重排 ##

#include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <string.h>
    
    #define StackSize 100 // 假定预分配的栈空间最多为100个元素 
    #define MaxLength 100 // 最大的字符串长度 
    typedef int DataType;	// 假定栈元素的数据类型为整数 
    
    typedef struct{ 
    	DataType data[StackSize];
    	int top;
    }SeqStack;
    
    /** 初始化栈 */
    void Initial(SeqStack *S)
    { 
    	S->top = -1;
    }
    
    /** 判断栈是否为空 */
    int IsEmpty(SeqStack *S)
    { 
    	return S->top == -1;
    }
    
    /** 判断栈是否满 */
    int IsFull(SeqStack *S)
    { 
    	return S->top == StackSize - 1;
    }
    
    /** 进栈 */
    void Push(SeqStack *S, DataType x)
    { 
    	if (IsFull(S))
    	{ 
    		printf("栈上溢"); 
    		exit(1);
    	}
    	S->data[++S->top] = x;//栈顶指针加1后将x入栈
    }
    
    /** 出栈 */
    DataType Pop(SeqStack *S)
    { 
    	if (IsEmpty(S))
    	{ 
    		printf("栈为空"); 
    		return -1;
    	}
    	return S->data[S->top--];// 栈顶元素返回后将栈顶指针减1
    }
    
    /** 取栈顶元素 */ 
    DataType Top(SeqStack *S)
    { 
    	if (IsEmpty(S))
    	{ 
    		printf("栈为空"); 
    		exit(1);
    	}
    	return S->data[S->top];
    }
    
    /** 在一个缓冲铁轨中放入车厢c, 为车厢c寻找最优的缓冲铁轨, 初始化 如果没有可用的缓冲铁轨，则返回0,如果空间不足，则引发异常否则返回1 */
    int Hold(int c, int *minH, int *minS, SeqStack H[], int k, int n)
    { 
    	int BestTrack = 0, i;	// 目前最优的铁轨
    	int BestTop = n + 1;	// 最优铁轨上的头辆车厢
    	int x;					// 车厢索引
    	//扫描缓冲铁轨
    	for (i = 1; i <= k; i++)
    
    	// 铁轨i 不空
    	if (IsEmpty(&H[i]))
    	{ 
    		x = Top(&H[i]);
    		if (c<x && x < BestTop)
    		{ //铁轨i 顶部的车厢编号最小
    			BestTop = x;
    			BestTrack = i;
    		}
    	}
    	else // 铁轨i 为空
    	if (!BestTrack)
    		BestTrack = i;
    	if (!BestTrack)
    		return 0; //没有可用的铁轨
    	//把车厢c 送入缓冲铁轨
    	Push(&H[BestTrack], c);
    	printf("Move car %d from input to holding track %d\n", c, BestTrack);
    	//必要时修改minH 和minS
    	if (c<*minH) { 
    		*minH = c;
    		*minS = BestTrack;
    	}
    	return 1;
    }
    
    //把车厢从缓冲铁轨送至出轨处，同时修改mins和minh
    void Output(int* minH, int* minS, SeqStack H[], int k, int n)
    {  
    	int c, i; // 车厢索引
    	// 从堆栈m i n S中删除编号最小的车厢minH
    	c = Pop(&H[*minS]);
    	printf("Move car %d from holding track %d to output\n", *minH, *minS);
    	// 通过检查所有的栈顶，搜索新的m i n H和m i n S
    	*minH = n + 2;
    	for (i = 1; i <= k; i++)
    	if (!IsEmpty(&H[i]) && (c = Top(&H[i])) < *minH) { 
    		*minH = c;
    		*minS = i;
    	}
    }
    
    /** k个缓冲铁轨，车厢初始排序为p [1:n]; 如果重排成功，返回1，否则返回0; 如果内存不足，则引发异常NoMem 。 创建与缓冲铁轨对应的堆栈 */
    int Railroad(int p[], int n, int k)
    { 
    	SeqStack *H;
    	int NowOut = 1;		// 下一次要输出的车厢
    	int minH = n + 1;	// 缓冲铁轨中编号最小的车厢
    	int minS, i;		// minH号车厢对应的缓冲铁轨
    	H = (SeqStack*)calloc((k + 1), sizeof(SeqStack)*(k + 1));
    
    	/* 车厢重排 */
    	for (i = 1; i <= n; i++)
    	if (p[i] == NowOut) { 
    		printf("移动车厢%d从出口到入口", p[i]);// 直接输出t
    		NowOut++;
    		/* 从缓冲铁轨中输出 */ 
    		while (minH == NowOut) { 
    			Output(&minH, &minS, H, k, n);
    			NowOut++;
    		}
    	}
    	// 将p[i] 送入某个缓冲铁轨
    	else { 
    		if (!Hold(p[i], &minH, &minS, H, k, n))
    			return 0;
    	}
    	return 1;
    }
    void main(void)
    { 
    	int p[8] = {  2, 4, 1, 6, 5, 3, 8, 7 };
    	Railroad(p, 8, 4);
    	system("pause");
    }

## 72、队列实例 ##

#include <string.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <ctype.h>
    
    #define MAX 100
    
    char *p[MAX], *qretrieve(void);
    int spos = 0;
    int rpos = 0;
    void enter(void), qstore(char *q), review(void), delete_ap(void);
    
    int main(void)
    { 
    	char s[80];
    	register int t;
    
    	for (t = 0; t < MAX; ++t) p[t] = NULL; /* init array to nulls */
    
    	for (;;) { 
    		printf("Enter, List, Remove, Quit: ");
    		gets(s);
    		*s = toupper(*s);
    
    		switch (*s) { 
    		case 'E':
    			enter();
    			break;
    		case 'L':
    			review();
    			break;
    		case 'R':
    			delete_ap();
    			break;
    		case 'Q':
    			exit(0);
    		}
    	}
    	system("pause");
    	return 0;
    }
    
    /** 入队 */
    void enter(void)
    { 
    	char s[256], *p;
    
    	do { 
    		printf("Enter appointment %d: ", spos + 1);
    		gets(s);
    		if (*s == 0) break; /* no entry */
    		p = (char *)malloc(strlen(s) + 1);
    		if (!p) { 
    			printf("Out of memory.\n");
    			return;
    		}
    		strcpy(p, s);
    		if (*s) qstore(p);
    	} while (*s);
    }
    
    /** 查看队列 */
    void review(void)
    { 
    	register int t;
    
    	for (t = rpos; t < spos; ++t)
    		printf("%d. %s\n", t + 1, p[t]);
    }
    
    /** 出队 */
    void delete_ap(void)
    { 
    	char *p;
    
    	if ((p = qretrieve()) == NULL) return;
    	printf("%s\n", p);
    }
    
    /* 入队 */
    void qstore(char *q)
    { 
    	if (spos == MAX) { 
    		printf("List Full\n");
    		return;
    	}
    	p[spos] = q;
    	spos++;
    }
    
    /* 检索队列 */
    char *qretrieve(void)
    { 
    	if (rpos == spos) { 
    		printf("No more appointments.\n");
    		return NULL;
    	}
    	rpos++;
    	return p[rpos - 1];
    }

## 73、K阶斐波那契序列 ##

#include <stdio.h>
    #include <stdlib.h>
    
    #define enoughsize 100 //最大队列长度
    typedef struct
    { 
    	int *base;		//初始化的动态分配存储空间
    	int front;      //头指针,若队列不空,指向队列头元素
    	int rear;		//尾指针,若队列不空,指向队列尾元素的下一个位置
    }SqQueue;
    
    
    int AddSum(int n, int *q)
    { 
    	int sum = 0;
    	int i;
    	for (i = 0; i<n; i++)  sum += q[i];
    	return sum;
    }
    
    void main()
    { 
    	SqQueue Q;
    	int k, max, i, n, *store;
    	printf("请输入斐波那奇的阶数:");
    	scanf("%d", &k);
    	printf("请输入序列中允许的最大数:");
    	scanf("%d", &max);
    	Q.base = (int*)malloc(k*sizeof(int));
    	store = (int*)malloc(enoughsize*sizeof(int));
    	if ((!Q.base) || (!store))
    	{ 
    		printf("Error!");
    		return;
    	}
    	for (i = 0; i<k; i++)
    	{ 
    		store[i] = 0;
    		Q.base[i] = 0;
    	}
    	store[k - 1] = 1;
    	Q.base[k - 1] = 1;   //初始化fib序列
    	store[k] = AddSum(k, Q.base);
    	Q.front = 0;
    	Q.rear = k - 1;
    	n = k;
    	while (store[n] <= max)
    	{ 
    		Q.rear = (Q.rear + 1) % k;
    		Q.base[Q.rear] = store[n];
    		n++;
    		store[n] = AddSum(k, Q.base);
    	}
    	printf("The first %d%s%d%c%s", n, " numbers are less than ", max, '.', "\n");
    	printf("The numbers are:\n");
    	for (i = 0; i<n; i++)  printf("%d%c", store[i], ' ');
    	printf("\n");
    
    	system("pause");
    }

## 74、绘制余弦曲线和直线的迭加 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    void main()
    { 
    	double y;
    	int x, m, n, yy;
    	puts("========This program shows the curve of cos(x) and a line.========");
    	puts(" ******* f(x)=cos(x) +++++++ g(x)=45*(y-1)+31");
    
    	/*对于第一个y坐标进行计算并在一行中打印图形*/
    	for (yy = 0; yy <= 20; yy++) 
    	{ 
    		y = 0.1*yy;							/* y：屏幕行方向坐标 */
    		m = acos(1 - y) * 10;				/* m: cos(x)曲线上y点对应的屏幕列坐标 */
    		n = 45 * (y - 1) + 31;				/* n: 直线上y点对应的列坐标 */
    		for (x = 0; x <= 62; x++)           /*x: 屏幕列方向坐标 */
    		if (x == m&&x == n) printf("+");	/* 直线与cos(x)相交时打印"+" */
    		else if (x == n) printf("+");		/* 打印不相交时的直线图形 */
    		else if (x == m || x == 62 - m) printf("*");  /* 打印不相交时的cos(x)图形 */
    		else  printf(" ");					/* 其它情况打印空格 */
    		printf("\n");
    	}
    	system("pause");
    }

## 75、计算高次方数的尾数 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int i, x, y, last = 1;    /* 变量last保存求X的Y次方过程中的部分乘积的后三位 */
    	puts("**********************************************************");
    	puts("* This is a program to calculate the last 3 digits of *");
    	puts("* high order value, e.g., 13^15. *");
    	puts("**********************************************************");
    	printf("\n >> Input X and Y(X^Y): ");
    	scanf("%d%d", &x, &y);
    	for (i = 1; i <= y; i++)                /*X自乘Y次*/
    		last = last*x % 1000;     /*将last乘X后对1000取模，即求积的后三位*/
    	printf("\n >> The last 3 digits of %d^%d is: %d\n", x, y, last % 1000); /*打印结果*/
    	system("pause");
    }

## 76、打鱼还是晒网 ##

#include<stdio.h>
    #include<stdlib.h>
    
    struct date{ 
    	int year;
    	int month;
    	int day;
    };
    int days(struct date day);
    
    void main()
    { 
    	struct date today, term;
    	int yearday, year, day;
    	puts("◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇");
    	puts("◇ 打鱼还是晒网 ◇");
    	puts("◇ 中国有句俗语叫【三天打鱼两天晒网】。 ◇");
    	puts("◇某人20岁从1990年1月1日起开始【三天打鱼两天晒网】，◇");
    	puts("◇问这个人在以后的某一天中是【打鱼】还是【晒网】？ ◇");
    	puts("◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇\n");
    	while (1)
    	{ 
    		printf(" >> 请输入年/月/日【输入1990 1 1 退出】：");
    		scanf("%d%d%d", &today.year, &today.month, &today.day);  /*输入日期*/
    		if (today.year<1990)
    		{ 
    			if (today.year<1970)
    				puts(" >> 对不起，那一年那还没出生呢！按任意键继续...");
    			else
    				puts(" >> 对不起，那一年他还没开始打鱼呢！按任意键继续...");
    			getchar();
    			continue;
    		}
    		if (today.year == 1990 && today.month == 1 && today.day == 1)
    			break;
    		term.month = 12;               /*设置变量的初始值：月*/
    		term.day = 31;                 /*设置变量的初始值：日*/
    		for (yearday = 0, year = 1990; year<today.year; year++)
    		{ 
    			term.year = year;
    			yearday += days(term);     /*计算从1990年至指定年的前一年共有多少天*/
    		}
    		yearday += days(today);       /*加上指定年中到指定日期的天数*/
    		day = yearday % 5;               /*求余数*/
    		if (day>0 && day<4) printf(" >> %d年%d月%d日，他正在打鱼。\n", today.year, today.month, today.day);   /*打印结果*/
    		else printf(" >> %d年%d月%d日，他正在晒网。\n", today.year, today.month, today.day);
    
    	}
    	system("pause");
    }
    
    int days(struct date day)
    { 
    	static int day_tab[2][13] =
    	{  {  0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, },      /*平均每月的天数*/
    	{  0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, },
    	};
    	int i, lp;
    	lp = day.year % 4 == 0 && day.year % 100 != 0 || day.year % 400 == 0;
    	/*判定year为闰年还是平年，lp=0为平年，非0为闰年*/
    	for (i = 1; i<day.month; i++)            /*计算本年中自1月1日起的天数*/
    		day.day += day_tab[lp][i];
    	return day.day;
    }

## 77、怎样存钱以获取最大利息 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    void main()
    { 
    	int i8, i5, i3, i2, i1, n8, n5, n3, n2, n1;
    	float max = 0, term;
    
    	/* 穷举所有可能的存款方式 */
    	for (i8 = 0; i8<3; i8++)       
    	for (i5 = 0; i5 <= (20 - 8 * i8) / 5; i5++)
    	for (i3 = 0; i3 <= (20 - 8 * i8 - 5 * i5) / 3; i3++)
    	for (i2 = 0; i2 <= (20 - 8 * i8 - 5 * i5 - 3 * i3) / 2; i2++)
    	{ 
    		i1 = 20 - 8 * i8 - 5 * i5 - 3 * i3 - 2 * i2;
    		term = 2000.0*pow((double)(1 + 0.0063 * 12), (double)i1)
    			*pow((double)(1 + 2 * 0.0063 * 12), (double)i2)
    			*pow((double)(1 + 3 * 0.0069 * 12), (double)i3)
    			*pow((double)(1 + 5 * 0.0075 * 12), (double)i5)
    			*pow((double)(1 + 8 * 0.0084 * 12), (double)i8);
    
    		/* 计算到期时的本利合计 */
    		if (term>max)
    		{ 
    			max = term; n1 = i1; n2 = i2; n3 = i3; n5 = i5; n8 = i8;
    		}
    	}
    	printf("For maxinum profit,he should so save his money in a bank:\n");
    	printf(" made fixed deposit for 8 year: %d times\n", n8);
    	printf(" made fixed deposit for 5 year: %d times\n", n5);
    	printf(" made fixed deposit for 3 year: %d times\n", n3);
    	printf(" made fixed deposit for 2 year: %d times\n", n2);
    	printf(" made fixed deposit for 1 year: %d times\n", n1);
    	printf(" Toal: %.2f\n", max);
    	/*输出存款方式*/
    	system("pause");
    }

## 78、阿姆斯特朗数 ##

#include<stdio.h>
    #include<stdlib.h>
    #define MAX 255
    
    void main()
    { 
    	int i, j, t, k, m, a[MAX];
    	long n;
    	puts(" This program will find the Armstrong number.\n");
    	printf(" >> Please input the range you want to find (2~n):\n >> ");
    	scanf("%ld", &n);
    	m = n;
    	j = 10;
    	while (m >= 10)
    	{ 
    		m = m / 10;
    		j *= 10;
    	}
    	printf(" >> There are follwing Armstrong number smaller than %d:\n", n);
    	for (i = 2; i<n; i++)         /*穷举要判定的数i的取值范围2~1000*/
    	{ 
    		for (t = 0, k = 10; k <= j; t++)     /*截取整数i的各位(从高向低位)*/
    		{ 
    			a[t] = (i%k) / (k / 10);        /*分别赋于a[0]~a[2}*/
    			k *= 10;
    		}
    		for (m = 0, t--; t >= 0; t--)
    			m += a[t] * a[t] * a[t];
    		if (m == i)
    			/*判断i是否为阿姆斯特朗数*/
    			printf("%5d", i);            /*若满足条件，则输出*/
    
    	}
    	system("pause");
    }

## 79、亲密数 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int a, i, b, n, m;
    	printf("================================================================\n");
    	printf(" This is a program to find friendly numbers pair.\n");
    	printf(" Which means the sum of integer A's all factors (except A)\n");
    	printf(" equals to the sum of integer B's all factors (except B).\n");
    	printf(" < e.g. sum of integer 6's all factors are:1+2+3=6 >\n");
    	printf("================================================================\n");
    	printf("\n Please input the scale you want to find n: ");
    	scanf("%d", &n);
    	printf("\n There are following friendly--numbers pair smaller than %d:\n", n);
    	for (a = 1; a<n; a++)        /*穷举1000以内的全部整数*/
    	{ 
    		for (b = 0, i = 1; i <= a / 2; i++)    /*计算数a的各因子，各因子之和存放于b*/
    		if (!(a%i))b += i;        /*计算b的各因子，各因子之和存于m*/
    		for (m = 0, i = 1; i <= b / 2; i++)
    		if (!(b%i))m += i;
    		if (m == a&&a<b)
    			printf("%4d..%4d ", a, b);     /*若n=a，则a和b是一对亲密数，输出*/
    	}
    	system("pause");
    }

## 80、自守数 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	long mul, number, k, ll, kk, n;
    	puts("============================================================");
    	puts("|| This program will find the automorphic numbers. ||");
    	puts("|| The defination of a automorphic number is: the mantissa||");
    	puts("|| of a natural number's square equals to itself. ||");
    	puts("|| e.g., 25^2=625, 76^2=5776, 9376^2=87909376. ||");
    	puts("============================================================");
    	printf("\n >> Please input the scale n you want to find : ");
    	scanf("%ld", &n);
    	printf("\n >> The automorphic numbers small than %ld are:\n\n", n);
    	for (number = 0; number<n; number++)
    	{ 
    		for (mul = number, k = 1; (mul /= 10)>0; k *= 10);
    		/*由number的位数确定截取数字进行乘法时的系数k*/
    		kk = k * 10;      /*kk为截取部分积时的系数*/
    		mul = 0;        /*积的最后n位*/
    		ll = 10;        /*ll为截取乘数相应位时的系数*/
    		while (k>0)
    		{ 
    			mul = (mul + (number % (k * 10))*(number%ll - number % (ll / 10))) % kk;
    			/*(部分积+截取被乘数的后N位*截取乘数的第M位)，%kk再截取部分积*/
    			k /= 10;               /*k为截取被乘数时的系数*/
    			ll *= 10;
    		}
    		if (number == mul)         /*判断若为自守数则输出*/
    			printf("%ld ", number);
    	}
    	system("pause");
    }

## 81、具有abcd=(ab+cd)2性质的数 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<stdio.h>
    
    void main()
    { 
    	int n, a, b;
    	puts("==========================================================");
    	puts("|| This program will find the four figures which have ||");
    	puts("|| the characteristic as follows: abcd=(ab+cd)^2. ||");
    	puts("|| e.g., 3025=(30+25)*(30+25). ||");
    	puts("==========================================================");
    	printf("\n >> There are following numbers with satisfied condition:\n\n");
    	for (n = 1000; n<10000; n++)				/* 四位数N的取值范围1000~9999 */
    	{ 
    		a = n / 100;							/* 截取N的前两位数存于a */
    		b = n % 100;							/* 截取N的后两位存于b */
    		if ((a + b)*(a + b) == n)				/* 判断N是否为符合题目所规定的性质的四位数 */
    			printf(" %d ", n);
    	}
    	system("pause");
    }

## 82、验证歌德巴赫猜想 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    /* 判断是否为素数 */
    int IsPrime(int i)
    { 
    	int j;
    	// 是否满足条件
    	if (i <= 1) return 0;
    	if (i == 2) return 1;
    	if (!(i % 2)) return 0;  
    
    	for (j = 3; j <= (int)(sqrt((double)i) + 1); j += 2)
    		if (!(i%j)) return 0;
    	return 1;              
    }
    
    /* 任何正偶数都可以分解成两个质数的和 */
    void main()
    { 
    	int i, j, n;
    	long max;
    	puts("============================================================");
    	puts("|| This program will verify the Goldbach Guess. ||");
    	puts("|| That is any positive even number can be broken up into ||");
    	puts("|| the sum of two prime numbers. ||");
    	puts("|| e.g., 4=2+2, 6=3+3, 8=3+5, 10=3+7, 12=5+7,... ||");
    	puts("============================================================");
    	printf("\n >> Please input the scale n you want to verify : ");
    	scanf("%ld", &max);
    	printf("\n >> Now the program starts to verify the even number\n");
    	printf(" >> less than %ld equals to sum of two prime numbers.\n\n", max);
    	for (i = 4, j = 0; i <= max; i += 2)
    	{ 
    		/* 将偶数i分解为两个整数 */
    		for (n = 2; n<i; n++)			
    			/* 分别判断两个整数是否均为素数 */
    			if (IsPrime(n))					 
    				if (IsPrime(i - n))
    				{ 
    					printf("%4d=%2d+%2d ", i, n, i - n);        /* 若均是素数则输出 */
    					j++;
    					if (j == 5)
    					{ 
    						printf("\n");
    						j = 0;
    					}
    					break;
    			}
    		if (n == i)  printf("error %d\n", i);
    	}
    	system("pause");
    }

## 83、素数幻方 ##

int number[210][5];     /* 存放可逆素数及素数分解后的各位数字 */
    int select[110];        /* 可以放在矩阵第一行和最后一行的素数的下标 */
    int array[4][5];        /* 4X4的矩阵，每行0号元素存可逆素数对应的数组下标 */
    int count;              /* 可逆素数的数目 */
    int selecount;          /* 可以放在矩阵第一行和最后一行的可逆素数的数目 */
    int larray[2][200];     /* 存放素数前二、三位数的临时数组所对应的数量计数器 */
    int lcount[2];
    
    /* 函数声明 */
    int num(int number); 
    int ok(int number);
    void process(int i);
    void copy_num(int i);
    int comp_num(int n);
    int find1(int i);
    int find2(void);
    int find0(int num);
    void p_array(void);
    
    FILE *fp;
    
    void main()
    { 
    	int i, k, flag, cc = 0, i1, i4;
    	if ((fp = fopen("Exa70data.dat", "w+")) == NULL)
    	{ 
    		printf("\n Can't create file Exa70data.dat !\n");
    		exit(0);
    	}
    	printf("there are magic squares with invertable primes as follw:\n");
    	for (i = 1001; i<9999; i += 2)                  /* 求满足条件的可逆素数 */
    	{ 
    		k = i / 1000;
    		if (k % 2 != 0 && k != 5 && num(i))			/* 若可逆素数的第一位不是偶数或5 */
    		{ 
    			number[count][0] = i;					/* 存入数组 */
    			process(count++);						/* 分解素数的各位数字 */
    			if (number[count - 1][2] % 2 != 0 &&    /* 若可逆素数满足放在矩阵第一行 */
    				number[count - 1][3] % 2 != 0 &&    /* 和最后一行的条件，记录可逆素数的 */
    				number[count - 1][2] != 5 &&		/* 下标，计数器加1 */
    				number[count - 1][3] != 5)
    				select[selecount++] = count - 1;
    		}
    	}
    	larray[0][lcount[0]++] = number[0][0] / 100;     /* 临时数组的第一行存前二位 */
    	larray[1][lcount[1]++] = number[0][0] / 10;      /* 临时数组的第二行存前三位 */
    	/* 将素数不重复的前二、三位存入临时数组中 */
    	for (i = 1; i<count; i++)						 
    	{ 
    		if (larray[0][lcount[0] - 1] != number[i][0] / 100)
    			larray[0][lcount[0]++] = number[i][0] / 100;
    		if (larray[1][lcount[1] - 1] != number[i][0] / 10)
    			larray[1][lcount[1]++] = number[i][0] / 10;
    	}
    	for (i1 = 0; i1<selecount; i1++)                    /* 在第一行允许的汇聚围内穷举 */
    	{ 
    		array[0][0] = select[i1];						/* 取对应的素数下标 */
    		copy_num(0);									/* 复制分解的素数 */
    		for (array[1][0] = 0; array[1][0]<count; array[1][0]++)    /* 穷举第二行 */
    		{ 
    			copy_num(1);                /* 复制分解的数字 */
    			if (!comp_num(2))
    				continue;         /* 若每列的前两位的组成与素数相矛盾，则试探下一个数 */
    			for (array[2][0] = 0; array[2][0]<count; array[2][0]++)     /* 穷举第三行 */
    			{ 
    				copy_num(2);           /* 复制分解的数字 */
    				if (!comp_num(3))
    					continue;          /* 若每列的前三位的组成与素数相矛盾，则试探下一个数 */
    				for (i4 = 0; i4<selecount; i4++)     /* 在最后一行允许的范围内穷举 */
    				{ 
    					array[3][0] = select[i4];
    					copy_num(3);					 /* 复制分解的数字 */
    					for (flag = 1, i = 1; flag&&i <= 4; i++)    /* 判断每列是否可逆素数 */
    					if (!find1(i))flag = 0;
    					if (flag&&find2())				 /* 判断对角线是否为可逆素数 */
    					{ 
    						printf("No.%d\n", ++cc);
    						fprintf(fp, "No.%d\n", cc);
    						p_array();
    					}    /* 输出幻方矩阵 */
    				}
    			}
    		}
    	}
    	fclose(fp);
    	system("pause");
    }
    
    /* 判断是否可逆素数 */
    int num(int number)              
    { 
    	int j;
    	if (!ok(number)) return 0;
    
    	for (j = 0; number>0; number /= 10)     /* 将素数变为反序数 */
    		j = j * 10 + number % 10;
    
    	if (!ok(j)) return 0;					/* 判断反序数是否为素数 */
    	return 1;
    }
    
    /* 判断是否为素数 */
    int ok(int number)                
    { 
    	int i, j;
    	if (number % 2 == 0) return 0;
    
    	j = sqrt((double)number) + 1;
    
    	for (i = 3; i <= j; i += 2)
    		if (number%i == 0) return 0;
    	return 1;
    }
    
    /* 将第i个整数分解为数字并存入数组 */
    void process(int i)                 
    { 
    	int j, num;
    	num = number[i][0];
    	for (j = 4; j >= 1; j--, num /= 10)
    		number[i][j] = num % 10;
    }
    
    /* 将array[i][0]指向的素数的各位数字复制到array[i]中 */
    void copy_num(int i)        
    { 
    	int j;
    	for (j = 1; j <= 4; j++)
    		array[i][j] = number[array[i][0]][j];
    }
    
    /* 判断array中每列的前n位是否与可逆素数允许的前n位矛盾 */
    int comp_num(int n)           
    { 
    	static int ii;           /* 用内部静态变量保存前一次查找到的元素下标 */
    	static int jj;			 /* ii:前一次查找前二位的下标，jj:前一次查找前三位的下标 */
    	int i, num, k, *p;		 /* p:指向对应的要使用的前一次下标ii或jj */
    	int *pcount;			 /* pcount:指向要使用的临时数组数量的计数器 */
    	switch (n){               /* 根据n的值选择对应的一组控制变量 */
    		case 2:pcount = &lcount[0]; p = &ii; break;
    		case 3:pcount = &lcount[1]; p = &jj; break;
    		default:return 0;
    	}
    	/* 对四列分别进行处理 */
    	for (i = 1; i <= 4; i++)          
    	{ 
    		for (num = 0, k = 0; k<n; k++)       /* 计算前n位数字代表的数值 */
    			num = num * 10 + array[k][i];
    		if (num <= larray[n - 2][*p])        /* 与前一次最后查找到的元素进行比较 */
    		for (; *p >= 0 && num<larray[n - 2][*p]; (*p)--);/* 若前次查找到的元素大，则向前找 */
    		else
    		for (; p<pcount&&num>larray[n - 2][*p]; (*p)++);  /* 否则向后找 */
    		if (*p<0 || *p >= *pcount)
    		{ 
    			*p = 0; return 0;
    		}
    		if (num != larray[n - 2][*p])
    			return 0;            /* 前n位不是可逆素数允许的值则返回0 */
    	}
    	return 1;
    }
    
    /* 判断列方向是否是可逆素数 */
    int find1(int i)               
    { 
    	int num, j;
    	for (num = 0, j = 0; j<4; j++)
    		num = num * 10 + array[j][i];
    	return find0(num);
    }
    
    /* 判断对角线方向是否是可逆素数 */
    int find2(void)                
    { 
    	int num1, num2, i, j;
    	for (num1 = 0, j = 0; j<4; j++)
    		num1 = num1 * 10 + array[j][j + 1];
    	for (num2 = 0, j = 0, i = 4; j<4; j++, i--)
    		num2 = num2 * 10 + array[j][i];
    	if (find0(num1)) return(find0(num2));
    	else return 0;
    }
    
    /* 查找是否为满足要求的可逆素数 */
    int find0(int num)               
    { 
    	static int j;
    	if (num <= number[j][0])for (; j >= 0 && num<number[j][0]; j--);
    	else for (; j<count&&num>number[j][0]; j++);
    	if (j<0 || j >= count){  j = 0; return 0; }
    	if (num == number[j][0]) return 1;
    	else return 0;
    }
    
    /* 输出矩阵 */
    void p_array(void)                
    { 
    	int i, j;
    	for (i = 0; i<4; i++)
    	{ 
    		for (j = 1; j <= 4; j++)
    		{ 
    			printf("%d ", array[i][j]);
    			fprintf(fp, "%d ", array[i][j]);
    		}
    		printf("\n");
    		fprintf(fp, "\n");
    	}
    }

## 84、百钱百鸡问题 ##

#include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    #include<stdio.h>
    
    void main()
    { 
    	int x, y, z, j = 0;
    	puts("************************************************");
    	puts("* This program is to solve Problem of *");
    	puts("* Hundred Yuan Hundred Fowls. *");
    	puts("* Which is presented by Zhang Qiujiang, *");
    	puts("* a Chinese ancient mathematician, in his work *");
    	puts("* Bible of Calculation: 5 Yuan can buy 1 cock, *");
    	puts("* 3 Yuan can buy 1 hen, 1 Yuan buy 3 chickens, *");
    	puts("* now one has 100 Yuan to buy 100 fowls, the *");
    	puts("* question is how many cocks, hens, chickens *");
    	puts("* to buy? *");
    	puts("************************************************");
    	printf("\nThe possible plans to buy 100 fowls with 100 Yuan are:\n\n");
    	for (x = 0; x <= 20; x++)               /* 外层循环控制鸡翁数 */
    	for (y = 0; y <= 33; y++)				/* 内层循环控制鸡母数y在0~33变化 */
    	{ 
    		z = 100 - x - y;					/* 内外层循环控制下，鸡雏数z的值受x,y的值的制约 */
    		if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100)
    			/* 验证取z值的合理性及得到一组解的合理性 */
    			printf("%2d: cock=%2d hen=%2d chicken=%2d\n", ++j, x, y, z);
    	}
    	system("pause");
    }

## 85、爱因斯坦数学题 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int i = 1;                  /*i为所设的阶梯数*/
    	puts("**************************************************");
    	puts("* This program is to solve *");
    	puts("* Einstein's interesting math question, *");
    	puts("* which is presented by Albert Einstein, *");
    	puts("* a famous theoretical physicist. *");
    	puts("* The Problem is as follows: there is a long *");
    	puts("* ladder, if one step strides 2 stages, 1 stages *");
    	puts("* left, if one step strides 3 stages, 2 stages *");
    	puts("* left, if one step strides 5 stages, 4 stages *");
    	puts("* left, if one step strides 7 stages, 0 stages *");
    	puts("* left, the question is, how many stages has *");
    	puts("* the ladder? *");
    	puts("**************************************************");
    	while (!((i % 2 == 1) && (i % 3 == 2) && (i % 5 == 4) && (i % 6 == 5) && (i % 7 == 0)))
    		++i;                  /*满足一组同余式的判别*/
    	printf("\n >> The ladder has %d stages.\n", i);
    	system("pause");
    }

## 86、三色球问题 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int i, j, count = 0;
    	puts("****************************************************************");
    	puts("* This program is to solve Problem of Three Color Ball. *");
    	puts("* The Problem is as follows: There are 12 balls in the pocket. *");
    	puts("* Amony them, 3 balls are red,3 balls are white and 6 balls *");
    	puts("* are black. Now take out any 8 balls from the pocket,how *");
    	puts("* many color combinations are there? *");
    	puts("****************************************************************");
    	puts(" >> The solutions are:");
    	printf(" No. RED BALL WHITE BALL BLACK BALL\n");
    	printf("-----------------------------------------------------\n");
    	for (i = 0; i <= 3; i++)               /*循环控制变量i控制任取红球个数0￣3*/
    	for (j = 0; j <= 3; j++)           /*循环控制变量j控制任取白球个数0￣3*/
    	if ((8 - i - j) <= 6)
    		printf(" %2d | %d | %d | %d\n", ++count, i, j, 8 - i - j);
    
    	printf("-----------------------------------------------------\n");
    	system("pause");
    }

## 87、马克思手稿中的数学题 ##

#include<stdio.h>
    #include<stdlib.h>
    void main()
    { 
    	int x, y, z, count = 0;
    	puts("****************************************************************");
    	puts("* This program is to solve an interesting math question in *");
    	puts("* Karl Marx's manuscript. *");
    	puts("* The Problem is as follows: 30 persons spent 50 yuan in a *");
    	puts("* restaurant, amony them, each man spent 3 yuan, each woman *");
    	puts("* spent 2 yuan, and each child spent 1 yuan. The question is *");
    	puts("* how many men, women and children are there? *");
    	puts("****************************************************************");
    	puts(" >> The solutions are:");
    	printf(" No. Men Women Children\n");
    	printf("---------------------------------------------\n");
    	for (x = 0; x <= 10; x++)
    	{ 
    		y = 20 - 2 * x;                     /* x定值据(3)式求y */
    		z = 30 - x - y;                     /* 由(1)式求z */
    		if (3 * x + 2 * y + z == 50)        /* 当前得到的一组解是否满足式(2) */
    			printf(" <%2d> | %2d | %2d | %2d\n", ++count, x, y, z);
    	}
    	printf("---------------------------------------------\n");
    	system("pause");
    }

## 88、配对新郎和新娘 ##

#include<stdio.h>
    #include<stdlib.h>
    void main()
    { 
    	int x, y, z;
    	puts("****************************************************************");
    	puts("* This program is to solve Problem of Bridegroom and Bride. *");
    	puts("* The Problem is as follows: Someone goes to 3 couples lovers' *");
    	puts("* wedding. The bridegrooms are A,B,C and the brides are X,Y,Z. *");
    	puts("* He wants to know who marries who and asks them. A says he *");
    	puts("* will marry to X, X says her fiance is C, C says he will marry*");
    	puts("* to Z. The man knows that they are all kidding. What they said*");
    	puts("* is not true. So try to find who will marry to who? *");
    	puts("****************************************************************");
    	puts(" >> The solutions are:");
    	printf("---------------------------------------------\n");
    	for (x = 1; x <= 3; x++)			/* 穷举x的全部可能配偶 */
    		for (y = 1; y <= 3; y++)		/* 穷举y的全部可能配偶 */
    			for (z = 1; z <= 3; z++)    /* 穷举z的全部可能配偶 */
    				if (x != 1 && x != 3 && z != 3 && x != y&&x != z&&y != z)  /* 判断配偶是否满足题意 */
    				{ 
    					printf(" X will marry to %c.\n", 'A' + x - 1);  
    					printf(" Y will marry to %c.\n", 'A' + y - 1);
    					printf(" Z will marry to %c.\n", 'A' + z - 1);
    				}
    	printf("---------------------------------------------\n");
    	system("pause");
    }

## 89、邮票组合 ##

#include<stdio.h>
    #include<stdlib.h>
    #define M 255
    int a[M];
    
    void main()
    { 
    	int i, j, k, s, n = 0;
    	puts("****************************************************************");
    	puts("* This program is to solve Problem of Stamp Combination. *");
    	puts("* The Problem is as follows. John has 4 stamps with value of 3 *");
    	puts("* cents and 3 stamps with value of 5 cents. Use one or more of *");
    	puts("* these stamps, how many kinds of postages can John provide? *");
    	puts("****************************************************************");
    	puts("\n >> The solution is: \n");
    	printf("---------------------------------------------\n\n");
    	for (i = 0; i <= 4; i++)            /* i:取三分邮票的张数 */
    		for (j = 0; j <= 3; j++)		/* j:取5分邮票的张数 */
    		{ 
    			s = i * 3 + j * 5;			/* 计算组成的邮票面值 */
    			for (k = 0; a[k]; k++)      /* 查找是否有相同的邮资 */
    			if (s == a[k])break;
    			if (!a[k] && s)				/* 没有找到相同的邮资则满足要求存入数组 */
    			{ 
    				a[k] = s; n++;
    			}
    		}
    	printf(" >> There are %d kinds of postages:\n\n", n);      /* 输出结果 */
    	for (k = 0; a[k]; k++)
    		printf(" %d", a[k]);
    	printf("\n");
    	printf("\n---------------------------------------------\n");
    	system("pause");
    }

## 90、分糖果 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void print(int s[]);
    int judge(int c[]);
    int j = 0;
    
    void main()
    { 
    	static int sweet[10] = {  10, 2, 8, 22, 16, 4, 10, 6, 14, 20 };   /*初始化数组数据*/
    	int i, t[10], l;
    	printf(" Child No. 1 2 3 4 5 6 7 8 9 10\n");
    	printf("------------------------------------------------------\n");
    	printf(" Round No.|\n");
    	print(sweet);          /*输出每个人手中糖的块数*/
    	while (judge(sweet))      /*若不满足要求则继续进行循环*/
    	{ 
    		for (i = 0; i<10; i++)    /*将每个人手中的糖分成一半*/
    		if (sweet[i] % 2 == 0)     /*若为偶数则直接分出一半*/
    			t[i] = sweet[i] = sweet[i] / 2;
    		else               /*若为奇数则加1后再分出一半*/
    			t[i] = sweet[i] = (sweet[i] + 1) / 2;
    		for (l = 0; l<9; l++)         /*将分出的一半糖给右(后)边的孩子*/
    			sweet[l + 1] = sweet[l + 1] + t[l];
    		sweet[0] += t[9];
    		print(sweet);             /*输出当前每个孩子中手中的糖数*/
    	}
    	printf("------------------------------------------------------\n");
    	system("pause");
    }
    
    int judge(int c[])
    { 
    	int i;
    	for (i = 0; i<10; i++)          /*判断每个孩子手中的糖是否相同*/
    	if (c[0] != c[i]) return 1;          /*不相同返回 1*/
    	return 0;
    }
    
    void print(int s[])      /*输出数组中每个元素的值*/
    { 
    	int k;
    	printf(" <%2d> | ", j++);
    	for (k = 0; k<10; k++)   printf("%4d", s[k]);
    	printf("\n");
    }

## 91、波瓦松的分酒趣题 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void getti(int a, int y, int z);
    int i;           /* 最后需要分出的重量 */
    
    void main()
    { 
    	int a, y, z;
    	puts("***************************************************************");
    	puts("* This program is to solve Problem of Poisson Beer Division. *");
    	puts("* The Problem is as follows: Someone has a bottle of 12 pints *");
    	puts("* beer. He wants to get 6 pints, but he does not has a bottle *");
    	puts("* of 6 pints. He only has a bottle of 8 pints and a bottle of *");
    	puts("* 5 pints. So how can he get 6 pints? *");
    	puts("***************************************************************");
    	printf(" >> Input Full bottle a,Empty b,c, and Get volumes:\n"); /* a 满瓶的容量 y:第一个空瓶的容量 z:第二个空瓶的容量 */
    	printf(" >> ");
    	scanf("%d%d%d%d", &a, &y, &z, &i);
    	getti(a, y, z);           /*按a -> y -> z -> a的操作步骤*/
    	/*getti(a,z,y); /*按a -> z -> y -> a的步骤*/
    	system("pause");
    }
    
    /* a:满瓶的容量 y:第一个空瓶的容量 z:第二个空瓶的容量 */
    void getti(int a, int y, int z)   
    { 
    	int b = 0, c = 0, j = 0;			 /* b:第一瓶实际的重量 c:第二瓶实际的重量 j: 倒的步数 */
    	puts(" >> The division steps are as follows.\n");
    
    	printf(" Bottle: a<%d> b<%d> c<%d>\n", a, y, z);
    	printf("-----------------------------\n");
    	printf(" Step No.|\n");
    	printf(" <%d> | %4d %4d %4d\n", j++, a, b, c);
    
    	/* 当满瓶!=i或另两瓶都!=i */
    	while (a != i || b != i&&c != i)      
    	{ 
    		if (!b)
    		{ 
    			a -= y; b = y;
    		}    /* 如果第一瓶为空，则将满瓶倒入第一瓶中 */
    		else if (c == z)
    		{ 
    			a += z; c = 0;
    		}    /* 如果第二瓶满，则将第二瓶倒入满瓶中 */
    		else if (b>z - c)    /* 如果第一瓶的重量>第二瓶的剩余空间 */
    		{ 
    			b -= (z - c); c = z;
    		}    /* 则将装满第二瓶，第一瓶中保留剩余部分 */
    		else{  c += b; b = 0; }   /* 否则，将第一瓶全部倒入第二瓶中 */
    		printf(" <%d> | %4d %4d %4d\n", j++, a, b, c);
    	}
    	printf("-----------------------------\n");
    }

## 92、求π的近似值 ##

#include<stdio.h>
    #include<math.h>
    #include<time.h>
    #include<stdlib.h>
    #define N 30000
    
    void main()
    { 
    	double e = 0.1, b = 0.5, c, d;
    	long int i;                /*i: 正多边形边数*/
    	float x, y;
    	int c2 = 0, d2 = 0;
    	puts("***********************************************************");
    	puts("* This program is to calculate PI approximatively *");
    	puts("* in two methods. *");
    	puts("* One method is Regular Polygon Approximating, *");
    	puts("* the other is Random Number Method. *");
    	puts("***********************************************************");
    	puts("\n >> Result of Regular Polygon Approximating:");
    	for (i = 6;; i *= 2)            /*正多边形边数加倍*/
    	{ 
    		d = 1.0 - sqrt(1.0 - b*b);     /*计算圆内接正多边形的边长*/
    		b = 0.5*sqrt(b*b + d*d);
    		if (2 * i*b - i*e<1e-15) break;         /*精度达1e-15则停止计算*/
    		e = b;      /*保存本次正多边形的边长作为下一次精度控制的依据*/
    	}
    	printf("---------------------------------------------------------\n");
    	printf(" >> pi=%.15lf\n", 2 * i*b);       /*输出π值和正多边形的边数*/
    	printf(" >> The number of edges of required polygon:%ld\n", i);
    	printf("---------------------------------------------------------\n");
    	srand(time(0));
    	while (c2++ <= N)
    	{ 
    		x = rand() % 100;      /*x:坐标。产生0到100之间共101个的随机数*/
    		y = rand() % 100;      /*y:坐标。产生0到100之间共101个的随机数*/
    		if (x*x + y*y <= 10000)     /*利用圆方程判断点是否落在圆内*/
    			d2++;
    	}
    	puts("\n >> Result of Random Number Method:");
    	printf("---------------------------------------------------------\n");
    	printf(" >> pi=%f\n", 4.*d2 / N);    /*输出求出的π值*/
    	printf("---------------------------------------------------------\n");
    	system("pause");
    }

## 93、奇数平方的有趣性质 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	long int a, n = 0;
    	puts("***********************************************************");
    	puts("* >> This program is to verify << *");
    	puts("* >> odd number's characteristic. << *");
    	puts("* That is square of an odd number larger than 1000 minus *");
    	puts("* 1 can be divided exactly by 8. *");
    	puts("* For example, 2001^2-1=4004000=500500*8. *");
    	puts("***********************************************************");
    	while (n<1001)
    	{ 
    		printf(" >> Please input the range you want to verify: ");
    		scanf("%ld", &n);
    	}
    	puts(" >> Now start to verify:");
    	for (a = 1001; a <= n; a += 2)
    	{ 
    		printf("%ld:", a);						/* 输出奇数本身 */
    		printf("(%ld*%ld-1)/8", a, a);			/* 输出(奇数的平方减1)/8 */
    		printf("=%ld", (a*a - 1) / 8);			/* 输出被8除后的商 */
    		printf("+%ld\n", (a*a - 1) % 8);		/* 输出被8除后的余数 */
    	}
    	system("pause");
    }

## 94、角谷猜想 ##

#include<stdio.h>
    #include<stdlib.h>
    
    
    void main()
    { 
    	int n = 1, count = 0;
    	puts("*********************************************************");
    	puts("* >> This program is to verify Jiaogu Guess << *");
    	puts("* That is given any natural number, if it is an even, *");
    	puts("* divides 2, if it is an odd, multiple 3 and add 1, the *");
    	puts("* result continues to be calculated analogously. After *");
    	puts("* some times, the result is always 1. *");
    	puts("*********************************************************");
    	while (n != 0)
    	{ 
    		printf(" >> Please input a number to verify(0 to quit): ");
    		scanf("%d", &n);      /* 输入任一整数 */
    		if (n == 0)
    			break;
    		printf(" >> ------ Results of verification: ------------\n");
    		do{ 
    			if (n % 2)
    			{ 
    				n = n * 3 + 1;           /* 若为奇数，n乘3加1 */
    				printf(" >> Step No.%d: %d*3+1=%d\n", ++count, (n - 1) / 3, n);
    			}
    			else
    			{ 
    				n /= 2;          /* 若为偶数n除以2 */
    				printf(" >> Step No.%d: %d/2=%d\n", ++count, 2 * n, n);
    			}
    		} while (n != 1);             /* n不等于1则继续以上过程 */
    		printf(" >> ---------------------------------------------\n");
    	}
    	system("pause");
    }

## 95、四方定理 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void verify_four_squares(int number)
    { 
    	int i, j, k, l;
    	for (i = 1; i<number / 2; i++)         /*试探法。试探i,j,k,k的不同值*/
    	for (j = 0; j <= i; j++)
    	for (k = 0; k <= j; k++)
    	for (l = 0; l <= k; l++)
    	if (number == i*i + j*j + k*k + l*l)    /*若满足定理要求则输出结果*/
    	{ 
    		printf(" >> %d=%d*%d+%d*%d+%d*%d+%d*%d\n", number, i, i, j, j, k, k, l, l);
    		return;
    	}
    }
    void main()
    { 
    	int number = 1;
    
    	puts("*****************************************************");
    	puts("* This program is to verify Theorem of Four Squares.*");
    	puts("* That is all natural numbers can be represented as *");
    	puts("* sum of no more than 4 squares of the numbers. *");
    	puts("*****************************************************");
    	while (number != 0)
    	{ 
    		printf(" >> Please input a number to verify(0 to quit): ");
    		scanf("%d", &number);      /* 输入任一整数 */
    		if (number == 0)
    			break;
    		printf(" >> ------ Results of verification: ------------\n");
    		verify_four_squares(number);
    		printf(" >> ---------------------------------------------\n");
    	}
    	system("pause");
    }

## 96、卡布列克常数 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void vr6174(int);
    void parse_sort(int num, int *each);
    void max_min(int *each, int *max, int *min);
    void parse_sort(int num, int *each);
    int count = 0;
    void main()
    { 
    
    	int n = 1;
    	puts("**************************************************************");
    	puts("* This program is to verify Comgrich Content. *");
    	puts("* That is any 4-digit number whose digitals are not the same *");
    	puts("* has the rule: (1) range the 4 digits to get the maximum *");
    	puts("* 4-digit number, (2) range the 4 digits to get the minimum *");
    	puts("* 4-digit number, (3) get the difference of these two numbers*");
    	puts("* that is a new 4-digit number. Continute to calculate with *");
    	puts("* (1)-(3),the result in the end is 6174,the Comgrich Content.*");
    	puts("**************************************************************");
    	while (n != 0)
    	{ 
    		printf(" >> Please input a 4-digit number to verify(0 to quit): ");
    		scanf("%d", &n);      /*输入任一整数*/
    		if (n == 0)
    			break;
    		printf(" >> ------ Results of verification: ------------\n");
    		count = 0;
    		vr6174(n);           /*调用函数进行验证*/
    		printf(" >> ---------------------------------------------\n");
    	}
    	system("pause");
    }
    void vr6174(int num)
    { 
    	int each[4], max, min;
    	if (num != 6174 && num)    /*若不等于74且不等于0则进行卡布列克运算*/
    	{ 
    		parse_sort(num, each);         /*将整数分解，数字存入each数组中*/
    		max_min(each, &max, &min);      /*求数字组成的最大值和最小值*/
    		num = max - min;          /*求最大值和最小值的差*/
    		printf(" >> Step No.%d: %d-%d=%d\n", ++count, max, min, num); /*输出该步计算过程*/
    		vr6174(num);         /*递归调用自身继续进行卡布列克运算*/
    	}
    }
    void parse_sort(int num, int *each)
    { 
    	int i, *j, *k, temp;
    	for (i = 0; i <= 4; i++)         /*将NUM分解为数字*/
    	{ 
    		j = each + 3 - i;
    		*j = num % 10;
    		num /= 10;
    	}
    	for (i = 0; i<3; i++)     /*对各保数字从小到大进行排序*/
    	for (j = each, k = each + 1; j<each + 3 - i; j++, k++)
    	if (*j>*k) {  temp = *j; *j = *k; *k = temp; }
    	return;
    }
    void max_min(int *each, int *max, int *min)    /*将分解的数字还原为最大整数和最小整数*/
    { 
    	int *i;
    	*min = 0;
    	for (i = each; i<each + 4; i++)     /*还原为最小的整数*/
    		*min = *min * 10 + *i;
    	*max = 0;
    	for (i = each + 3; i >= each; i--)    /*还原为最大的整数*/
    		*max = *max * 10 + *i;
    	return;
    }

## 97、尼科彻斯定理 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void vrNico(int a)
    { 
    	int b, c, d;
    	b = a*a*a;                  /*求整数的三次方*/
    	printf(" >> %d*%d*%d=%d=", a, a, a, b);
    	for (d = 0, c = 0; c<a; c++)       /*输出数列，首项为a*a-a+1,等差值为2*/
    	{ 
    		d += a*a - a + 1 + c * 2;       /*求数列的前a项的和*/
    		printf(c ? "+%d" : "%d", a*a - a + 1 + c * 2);
    	}
    	if (d == b)printf(" Satisfy!\n");    /*若条件满足则输出"Y"*/
    	else printf(" Dissatisfy!\n");       /*否则输出"N"*/
    }
    
    
    void main()
    { 
    
    	int n = 1;
    	puts("******************************************************");
    	puts("* This program is to verify Theorem of Nicoqish. *");
    	puts("* That is the cube of any integer can be represented *");
    	puts("* as the sum of some continue odd numbers. *");
    	puts("* For example, 8^3=512=57+58+59+61+63+65+67+69+71. *");
    	puts("******************************************************");
    	while (n != 0)
    	{ 
    		printf(" >> Please input a integer to verify(0 to quit): ");
    		scanf("%d", &n);      /*输入任一整数*/
    		if (n == 0)
    			break;
    		printf(" >> ------ Results of verification: ------------\n");
    		vrNico(n);           /*调用函数进行验证*/
    		printf(" >> ---------------------------------------------\n");
    	}
    	system("pause");
    }

## 98、扑克牌自动发牌 ##

#include<stdlib.h>
    #include<stdio.h>
    
    int comp(const void *j, const void *i);
    void p(int p, int b[], char n[]);
    
    void main()
    { 
    	static char n[] = {  '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K', 'A' };
    	int a[53], b1[13], b2[13], b3[13], b4[13];
    	int b11 = 0, b22 = 0, b33 = 0, b44 = 0, t = 1, m, flag, i;
    	puts("******************************************************");
    	puts("* This is an Automatic Dealing Card program! *");
    	puts("* In one game, 52 cards are divided into 4 groups. *");
    	puts("******************************************************");
    	printf(" >> ----- Each person's cards are as follows. -------");
    	while (t <= 52)					/* 控制发52张牌 */
    	{ 
    		m = (rand() % 5) + 1;       /* 产生0到51之间的随机数 */
    		for (flag = 1, i = 1; i <= t&&flag; i++)   /* 查找新产生的随机数是否已经存在 */
    		if (m == a[i]) flag = 0;      /* flag=1:产生的是新的随机数 flag=0:新产生的随机数已经存在 */
    		/* 如果产生了新的随机数，则存入数组 */
    		if (flag)
    		{ 
    			a[t++] = m;       
    			if (t % 4 == 0) b1[b11++] = a[t - 1];        /* 根据t的模值，判断当前 */
    			else if (t % 4 == 1) b2[b22++] = a[t - 1];   /* 的牌应存入哪个数组中 */
    			else if (t % 4 == 2) b3[b33++] = a[t - 1];
    			else if (t % 4 == 3) b4[b44++] = a[t - 1];
    		}
    	}
    	/* 将每个人的牌进行排序 */
    	qsort(b1, 13, sizeof(int), comp);      
    	qsort(b2, 13, sizeof(int), comp);
    	qsort(b3, 13, sizeof(int), comp);
    	qsort(b4, 13, sizeof(int), comp);
    	p(1, b1, n); p(2, b2, n); p(3, b3, n); p(4, b4, n);     /* 分别打印每个人的牌 */
    	system("pause");
    }
    
    void p(int p, int b[], char n[])
    { 
    	int i;
    	printf("\n Person No.%d \006 ", p);			/* 打印黑桃标记 */
    	for (i = 0; i<13; i++)							/* 将数组中的值转换为相应的花色 */
    	if (b[i] / 13 == 0) printf(" %c", n[b[i] % 13]);      /* 该花色对应的牌 */
    	printf("\n \003 ");				/* 打印红桃标记 */
    	for (i = 0; i<13; i++)
    	if ((b[i] / 13) == 1) printf(" %c", n[b[i] % 13]);
    	printf("\n \004 ");				/* 打印方块标记 */
    	for (i = 0; i<13; i++)
    	if (b[i] / 13 == 2) printf(" %c", n[b[i] % 13]);
    	printf("\n \005 ");				/* 打印梅花标记 */
    	for (i = 0; i<13; i++)
    	if (b[i] / 13 == 3 || b[i] / 13 == 4) printf(" %c", n[b[i] % 13]);
    	printf("\n");
    }
    
    /* qsort调用的排序函数 */
    int comp(const void *j, const void *i) {  return(*(int*)i - *(int*)j); }

## 99、常胜将军 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int a = 21, i;
    	puts("*****************************************************");
    	puts("* This is a Matchstick Taken Game. *");
    	puts("* There are 21 machsticks, two persons take them in *");
    	puts("* turn. Each one each time takes 1 to 4 sticks. The *");
    	puts("* one who takes the last stick will lose the game. *");
    	puts("*****************************************************");
    	printf(" >> --------------- Game Begin ---------------------\n");
    	while (a>0)
    	{ 
    		do{ 
    			printf(" >> How many sticks do you wish to take(1~%d)?", a>4 ? 4 : a);
    			scanf("%d", &i);
    		} while (i>4 || i<1 || i>a);      /* 接收正在确的输入 */
    		if (a - i>0) printf(" >> %d stick left in the pile.\n", a - i);
    		if ((a - i) <= 0)
    		{ 
    			printf(" >> You have taken the last stick.\n");
    			printf(" >> ******* You lose! ******* \n");			/* 输出取胜标记 */
    			printf(" >> --------------- Game Over! ---------------------\n");
    			break;
    		}
    		else
    			printf(" >> Compute take %d stick.\n", 5 - i);		/* 输出计算机取的子数 */
    		a -= 5;
    		printf(" >> %d stick left in the pile.\n", a);
    	}
    	system("pause");
    }

## 100、搬山游戏 ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int n, k, x, y, cc, pc, g;
    	puts("*******************************************************");
    	puts("* This is a Mountain Moveing Game. *");
    	puts("* There are n mountains, two persons move them in *");
    	puts("* turn. Each one each time moves 1 to k mountains, the*");
    	puts("* one who takes the last stick will lose the game. *");
    	puts("*******************************************************");
    	printf(" >> --------------- Game Begin ---------------------\n");
    	pc = cc = 0;
    	g = 1;
    	for (;;)
    	{ 
    		printf(" >> No.%2d game \n", g++);
    		printf(" >> ---------------------------------------\n");
    		printf(" >> How many mountains are there? ");
    		scanf("%d", &n);
    		if (!n) break;
    		printf(" >> How many mountains are allowed to each time? ");
    		do{ 
    			scanf("%d", &k);
    			if (k>n || k<1) printf(" >> Repeat again!\n");
    		} while (k>n || k<1);
    		do{ 
    			printf(" >> How many mountains do you wish move ? ");
    			scanf("%d", &x);
    			if (x<1 || x>k || x>n)      /* 判断搬山数是否符合要求 */
    			{ 
    				printf(" >> Illegal,again please!\n");
    				continue;
    			}
    			n -= x;
    			printf(" >> There are %d mountains left now.\n", n);
    			if (!n)
    			{ 
    				printf(" >> ---- I win. You are failure.----------\n\n"); cc++;
    			}
    			else
    			{ 
    				y = (n - 1) % (k + 1);      /*求出最佳搬山数*/
    				if (!y) y = 1;
    				n -= y;
    				printf(" >> Copmputer move %d mountains away.\n", y);
    				if (n) printf(" >> There are %d mountains left now.\n", n);
    				else
    				{ 
    					printf(" >> ---- I am failure. You win.-----------\n\n");
    					pc++;
    				}
    			}
    		} while (n);
    
    	}
    	printf(" >> Games in total have been played %d.\n", cc + pc);
    	printf(" >> You score is win %d,lose %d.\n", pc, cc);
    	printf(" >> My score is win %d,lose %d.\n", cc, pc);
    	printf(" >> --------------- Game Over! ---------------------\n");
    	system("pause");
    }

## 101、兔子产子（斐波那契数列） ##

#include<stdio.h>
    #include<stdlib.h>
    
    void main()
    { 
    	int n, i, j, un1, un2, un;
    	puts("********************************************************");
    	puts("* This is a program to Calculate Rabbits Numbers. *");
    	puts("* There is a rabbit couple procreats 2 rabbits 1 month,*");
    	puts("* and the young rabbits group and can procreats in the *");
    	puts("* end of the second month. In this way,how many rabbits*");
    	puts("* are there after n generations? *");
    	puts("********************************************************");
    	for (n = 2; n<3;)
    	{ 
    		printf(" >> Please input number of generations (n>2): ");
    		scanf("%d", &n);
    		if (n<3) printf("\n >> Input error!\n");     /* 控制输入正确的N值 */
    	}
    	un = un2 = 1;
    	printf(" >> The numbers of rabbits in first %d generation are as follows:\n", n);
    	printf(" l\t l\t");
    
    	for (i = 3, j = 0; i <= n; i++)
    	{ 
    		un1 = un2;
    		un2 = un;
    		un = un1 + un2;							/* 利用通项公式求解N项的值 */
    		printf(i % 8 ? " %d\t" : "%d\n", un);
    	}
    	printf("\n");
    	system("pause");
    }

## 102、数字移动 ##

#include<stdio.h>
    #include<stdlib.h>
    
    int a[] = {  0, 1, 2, 5, 8, 7, 6, 3 };   /* 指针数组.依次存入矩阵中构成环的元素下标 */
    int b[9];								/* 表示3X3矩阵,b[4]为空格 */
    int c[9];								/* 确定1所在的位置后,对环进行调整的指针数组 */
    int count = 0;							/* 数字移动步数计数器 */
    
    void main()
    { 
    	int i, j, k, t;
    	void print();
    	puts("*****************************************************");
    	puts("* This is a program to Move Numbers. *");
    	puts("*****************************************************");
    	printf(" >> Please enter original order of digits 1~8: ");
    	for (i = 0; i<8; i++)
    		scanf("%d", &b[a[i]]);
    	/* 顺序输入矩阵外边的8个数字,矩阵元素的顺序由指针数组的元素a[i]控制 */
    	printf("The sorting process is as felow:\n");
    	print();
    	for (t = -1, j = 0; j<8 && t == -1; j++)			/* 确定数字1所在的位置 */
    	if (b[a[j]] == 1) t = j;							/* t:记录数字1所在的位置 */
    	/* 调整环的指针数组,将数字1所在的位置定为环的首 */
    	for (j = 0; j<8; j++)								
    		c[j] = a[(j + t) % 8];
    	/* 从2开始依次调整数字的位置 */
    	for (i = 2; i<9; i++)         
    		/* i:正在处理的数字,i对应在环中应当的正确位置就是i-1 */
    		for (j = i - 1; j<8; j++)     
    			/* 从i应处的正确位置开始顺序查找 */
    			if (b[c[j]] == i&&j != i - 1)      /* 若i不在正确的位置 */
    			{ 
    				b[4] = i;					/* 将i移到中心的空格中 */
    				b[c[j]] = 0; print();		/* 空出i原来所在的位置,输出 */
    				for (k = j; k != i - 1; k--)    /* 将空格以前到i的正确位置之间的数字依次向后移动一格 */
    				{ 
    					b[c[k]] = b[c[k - 1]];		/* 数字向后移动 */
    					b[c[k - 1]] = 0;
    					print();
    				}
    				b[c[k]] = i;         /* 将中间的数字i移入正确的位置 */
    				b[4] = 0;            /* 空出中间的空格 */
    				print();
    				break;
    			}
    	else if (b[c[j]] == i) break;       /* 数字i在正确的位置 */
    	system("pause");
    }
    
    /* 按格式要求输出矩阵 */
    void print(void)        
    { 
    	int c;
    	printf(" >> Step No.%2d ", count++);
    	for (c = 0; c<9; c++)
    	if (c % 3 == 2) printf("%2d ", b[c]);
    	else  printf("%2d", b[c]);
    	printf("\n");
    }

## 103、多项式乘法 ##

#include <stdio.h>
    #include <math.h>
    #include <stdlib.h>
    #define MAX 50
    /* 下面的两个数组可以根据具体要求解的多项式来决定其值 */
    static double p[6] = {  4, -6, 3, 1, -1, 5 };	/* 表示多项式4x^5 - 6x^4 + 3x^3 + x^2 - x + 5 */
    static double q[4] = {  3, 2, -5, 1 };			/* 表示多项式3x^3 + 2x^2 - 5x + 1 */
    static double result[9] = {  0, 0, 0, 0, 0, 0, 0, 0, 0 };		/* 存放乘积多项式 */
    
    void npmul(double p[], int m, double q[], int n, double s[])
    { 
    	int i, j;
    	for (i = 0; i <= m - 1; i++)
    	for (j = 0; j <= n - 1; j++)
    		s[i + j] = s[i + j] + p[i] * q[j];		/* 迭带计算各项系数 */
    	return;
    }
    
    /* 计算所给多项式的值 */
    double compute(double s[], int k, float x)					
    { 
    	int i;
    	float multip = 1;
    	double sum = 0;
    	for (i = 0; i<k; i++) 
    		multip = multip * x;			/* 先求出x的最高次项的值 */
    	for (i = k - 1; i >= 0; i--)
    	{ 
    		sum = sum + s[i] * multip;		/* 依次从高到低求出相对应次项的值 */
    		if (x != 0)
    			multip = multip / x;
    	}
    	return sum;
    }
    
    void main()
    { 
    	int i, j, m, n;
    	double  px[MAX], qx[MAX], rx[MAX];
    	float x;
    	for (i = 0; i<MAX; i++)
    		rx[i] = 0;
    	puts(" This is a polynomial multiplication program.");
    	puts("It calculate the product of two polynomials: P(x) and Q(x)");
    	puts(" P(x)=Pm-1*x^(m-1)+Pm-2*x^(m-2)+...+P1*x+P0");
    	puts(" Q(x)=Qn-1*x^(n-1)+Qn-2*x^(n-2)+...+Q1*x+Q0");
    	printf("\n >> Please input m (>=1): ");
    	scanf("%d", &m);
    	printf(" >> Please input P%d, P%d, ... P1, P0 one by one:\n", m - 1, m - 2);
    	for (i = 0; i<m; i++)
    		scanf("%f", &px[i]);
    	printf("\n >> Please input n (>=1): ");
    	scanf("%d", &n);
    	printf(" >> Please input Q%d, Q%d, ... Q1, Q0 one by one:\n", n - 1, n - 2);
    	for (i = 0; i<n; i++)
    		scanf("%f", &qx[i]);
    	npmul(p, m, q, n, rx);
    	printf("\nThe product of two polynomials R(x) is :\n");
    	for (i = m + n - 1, j = 0; i >= 1; i--)					/*逐行逐项打印出结果多项式*/
    	{ 
    		printf(" (%f*x^%d) + ", rx[m + n - 1 - i], i - 1);
    		if (j == 2)
    		{ 
    			printf("\n");
    			j = 0;
    		}
    		else
    			j++;
    	}
    	printf("\n");
    	printf("Input the value of x: ");
    	scanf("%f", &x);
    	printf("\nThe value of the R(%f) is: %13.7f", x, compute(rx, m + n - 1, x));
    	system("pause");
    }

## 104、产生随机数 ##

#include <stdio.h>
    #include <sys\timeb.h>
    #include <stdlib.h>
    #define Alpha 3.90
    
    double initvalue();
    
    /** 返回一个(0,1)之间的随机数 */
    double random(void)
    { 
    	static double f = -1.0;
    	double initvlaue();
    	if (f == -1.0) f = initvalue();
    	else f = Alpha*f*(1.0 - f);
    	return f;
    }
    
    /* 返回随机数序列初值 */
    double initvalue()
    { 
    	double f0;
    	struct timeb *pr;
    	while (1)
    	{ 
    		ftime(pr);
    		f0 = pr->millitm*0.9876543*0.001;
    		if (f0<0.001) continue;
    		break;
    	}
    	return f0;
    }
    
    void main()
    { 
    	double test;
    	int i;
    	puts("This is a random number generator.");
    	puts("\n The random number are: ");
    	for (i = 0; i < 3; i++)
    	{ 
    		test = random();
    		printf(" >> rand%d:%f\n", i, test);
    	}
    	system("pause");
    }

## 105、堆栈四则运算 ##

#include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <conio.h>
    
    #define TRUE 1
    #define FALSE 0
    #define STACK_INIT_SIZE 100 /* 存储空间初始分配量 */
    #define STACKINCREMENT 20 /* 存储空间分配增量 */
    
    typedef struct
    { 
    	int *pBase;		/* 在构造之前和销毁之后,base的值为NULL */
    	int *pTop;		/* 栈顶指针 */
    	int StackSize;	/* 当前已分配的存储空间,以元素为单位 */
    }Stack;
    
    typedef int BOOLEAN;
    
    char Operator[8] = "+-*/()#";	/* 合法的操作符存储在字符串中 */
    char Optr;						/* 操作符 */
    int Opnd = -1;					/* 操作符 */
    int Result;						/* 操作结果 */
    
    /* 算符间的优先关系 */
    char PriorityTable[7][7] =
    { 
    	{  '>', '>', '<', '<', '<', '>', '>' },
    	{  '>', '>', '<', '<', '<', '>', '>' },
    	{  '>', '>', '>', '>', '<', '>', '>' },
    	{  '>', '>', '>', '>', '<', '>', '>' },
    	{  '<', '<', '<', '<', '<', '=', 'o' },
    	{  '>', '>', '>', '>', 'o', '>', '>' },
    	{  '<', '<', '<', '<', '<', 'o', '=' },
    };
    
    //数据对象的操作方法
    //构造一个空栈,如果返回值为0,则表示初始化失败
    Stack InitStack()
    { 
    	Stack S;
    	S.pBase = (int*)malloc(STACK_INIT_SIZE*sizeof(int));
    	if (!S.pBase)
    	{ 
    		printf("内存分配失败,程序中止运行\n");
    		exit(-1);
    	}
    	else
    	{ 
    		S.pTop = S.pBase;
    		S.StackSize = STACK_INIT_SIZE;
    	}
    	return S;
    }
    
    /* 销毁栈S,S不再存在 */
    void DestoryStack(Stack *S)
    { 
    	if (S->pBase)
    	{ 
    		free(S->pBase);
    		S->pTop = S->pBase = NULL;
    
    	}
    }
    
    //若栈不空,则用e返回S的栈顶元素
    //注:由于应用的特殊,可以不检查栈是否为空
    int GetTop(Stack S)
    { 
    	return *(S.pTop - 1);
    }
    
    /** 插入元素e为新的栈顶元素,如果成功则返回1,否则返回0 */
    int Push(Stack *S, int e)
    { 
    	if (S->pTop - S->pBase == S->StackSize)
    	{ //栈满,追加存储空间
    		S->pBase = (int*)realloc(S->pBase, S->StackSize + STACKINCREMENT*sizeof(int));
    		if (!S->pBase)
    			return 0;//存储分配失败
    		S->pTop = S->pBase + S->StackSize;
    		S->StackSize += STACKINCREMENT;
    	}
    	*(S->pTop++) = e;
    	return 1;
    }
    
    int Pop(Stack *S, int *e)
    { 
    	//若栈不空,则删除S的栈顶元素,用e 返回其值,并返回1;否则返回0
    	if (S->pTop == S->pBase)
    		return 0;
    	*e = *--(S->pTop);
    	return 1;
    
    }
    
    // 主函数及其它函数的实现
    // 比较两个数学符号operator_1,operator_2的计算优先权,在算符优先关系表中查找相应的关系并返回'<','=',或'>'
    char CheckPriority(char operator_1, char operator_2)
    { 
    	int i, j;// 用来查询算符间优先关系表的下标
    	//char *ptr;
    	i = strchr(Operator, operator_1) - Operator;// 找到传入操作符在字符串Operators中的相对位置
    	j = strchr(Operator, operator_2) - Operator;
    	// 返回算符优先关系表中相应值
    	return PriorityTable[i][j];
    }
    
    BOOLEAN IsOperator(char ch)
    { 
    	// 判断一个字符是否为打操作符
    	if (strchr(Operator, ch))
    		return TRUE;
    	else
    		return FALSE;
    
    }
    
    // 从键盘获得输入
    void GetInput(void)
    { 
    	char Buffer[20];	// 键盘输入缓冲区,用来处理输入多位数的情况
    	char ch;			// 存放键盘输入
    	int index;			// 存放Buffer的下标
    	index = 0;
    	ch = getch();		// 从键盘读入一个字符
    	while (ch != 13 && !IsOperator(ch))
    	{ // 如果输入的字符是回车符或是操作符,循环结束
    		if (ch >= '0'&&ch <= '9')
    		{ // 将字符回显到屏幕
    			printf("%c", ch);
    			Buffer[index] = ch;
    			index++;
    
    		}
    		ch = getch();
    	}
    	if (ch == 13)
    		Optr = '#';// 输入的表达式以回车符结束
    	else
    	{ 
    		Optr = ch;
    		printf("%c", ch);
    
    	}
    	if (index>0)
    	{ 
    		Buffer[index] = '\0';
    		Opnd = atoi((Buffer));
    	}
    	else
    		Opnd = -1;// 程序不支持输入负数,当Opnd为负数时,表示输入的字符为操作符
    }
    
    /** 计算形如a+b之类的表达式,theta为操作符,a,b为操作数 */ 
    int Calc(int a, char theta, int b)
    { 
    	switch (theta)
    	{ 
    	case '+':
    		return a + b;
    	case '-':
    		return a - b;
    	case '*':
    		return a*b;
    	default:
    		if (b == 0)	// 除数为零的情况
    		{ 
    			printf("除数不能为");
    			return 0;// 返回0用以显示
    		}
    		else
    			return a / b;
    	}
    }
    /* 表达式求值 */
    BOOLEAN EvaluateExpression()
    { 
    	int temp;		// 临时变量
    	char theta;		// 存放操作符的变量
    	int itheta;		// 存放出栈的操作符的变量add by me
    	int a, b;		// 存放表达式运算时的中间值
    	int topOpnd;	// 栈顶操作数
    	char topOptr;	// 栈顶操作符
    
    	Stack OPTR = InitStack();// 操作符栈
    	Stack OPND = InitStack();// 操作数栈
    
    	if (!Push(&OPTR, '#'))// 操作符栈中的第一个为#字符
    		return FALSE;
    
    	GetInput();// 从键盘获得输入
    
    	while (Optr != '#' || GetTop(OPTR) != '#')
    	{ // 如果Optr>=0,表示有操作数输入
    		if (Opnd >= 0)Push(&OPND, Opnd);
    		switch (CheckPriority(GetTop(OPTR), Optr))
    		{ 
    		case '<':// 栈顶元素优先权低
    			if (!Push(&OPTR, Optr))return FALSE;
    			GetInput();
    			break;
    		case '=':// 脱括号并接收键盘输入
    			Pop(&OPTR, &temp); GetInput();
    			break;
    		case '>':// 退栈并将运算结果入栈
    			// 先用itheta得到操作符在赋给theta
    			Pop(&OPTR, &itheta);
    			Pop(&OPND, &b);
    			Pop(&OPND, &a);
    			theta = (char)(itheta);
    			Push(&OPND, Calc(a, itheta, b));
    			Opnd = -1;
    			break;
    
    		}
    	}
    	//本算法中,当输入只有一个操作数然后就输入回车符时,
    	//OPND.pTop==OPND.pBase
    	//如果OPND.pTop==OPND.pBase并且Opnd<0,则说明用户
    	//未输入任何操作和操作符而直接输入[回车],程序直接
    	//退出运行
    	if (OPND.pTop == OPND.pBase&&Opnd<0)
    	{ 
    		printf("\n\n感谢使用!\n");
    		exit(1);
    
    	}
    	else if (OPND.pTop == OPND.pBase)
    		Result = Opnd;
    	else
    	{ 
    		Result = GetTop(OPND);
    		DestoryStack(&OPND);
    		DestoryStack(&OPTR);
    	}
    	return TRUE;
    
    }
    
    void Message(void)
    { 
    	printf("\n四则运算表达式求值演示\n");
    	printf("-------------------------------\n");
    	printf("使用方法:请从键盘上直接输入表达式,以回车键结束.如45*(12-2)[回车]\n");
    	printf("注0:不输入任何数而直接按[回车]键,将退出程序.\n");
    	printf("注1:本程序暂时不接受除数字键及四则运算符之外的任何其它键盘输入.\n");
    	printf("注2:本程序暂时只能处理正确的表达式,不支持输入负数.\n");
    	printf("-------------------------------\n\n");
    }
    void main(void)
    { 
    	int i;	// 用来一些说明性信息
    	Message();
    	for (i = 1;; i++)
    	{ 
    		printf("表达式%d:", i);
    		if (EvaluateExpression())
    			printf("=%d\n", Result);
    		else
    			printf("计算中遇到错误\n");
    	}
    	system("pause");
    }

## 106、递归整数四则运算 ##

/* 对四则混合运算所提取的形式化表达式(生成式) <exp> -> <term> { <addop> <term> } <addop> -> + | - <term> -> <factor> { <mulop> <factor> } <mulop> -> * | / <factor> -> ( <exp> ) | Number */
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <ctype.h>
    
    char token; /* 全局标志变量 */
    
    /* 递归调用的函数原型 */
    int exp(void);
    int term(void);
    int factor(void);
    
    /* 报告出错信息的函数 */
    void error(void) 
    { 
    	fprintf(stderr, "错误\n");
    	exit(1);
    }
    
    /* 对当前的标志进行匹配 */
    void match(char expectedToken) 
    { 
    	if (token == expectedToken) token = getchar(); /* 匹配成功，获取下一个标志 */
    	else error();				/* 匹配不成功，报告错误 */
    }
    
    void Message(void)
    { 
    	printf("================================================================\n");
    	printf("* 递归实现的四则运算表达式求值程序 *\n");
    	printf("****************************************************************\n");
    	printf("使用方法:请从键盘上直接输入表达式,以回车键结束.如45*(12-2)[回车]\n");
    	printf("*****************************************************************\n\n");
    }
    
    void main()
    { 
    	int result;  /* 运算的结果 */
    	Message();
    	printf(" >> 请输入表达式: ");
    	token = getchar();		/* 载入第一个符号 */
    
    	result = exp();			/*进行计算*/
    	if (token == '\n')		/* 是否一行结束 */
    		printf(" >> 表达式的计算结果为 : %d\n", result);
    	else error();			/* 出现了例外的字符 */
    	system("pause");
    }
    
    int exp(void)
    { 
    	int temp = term();			/* 计算比加减运算优先级别高的部分 */
    	while ((token == '+') || (token == '-'))
    		switch (token) { 
    		case '+': match('+');    /*加法*/
    			temp += term();
    			break;
    		case '-': match('-');
    			temp -= term();		 /*减法*/
    			break;
    	}
    	return temp;
    }
    
    int term(void)
    { 
    	int div; /*除数*/
    	int temp = factor();   /*计算比乘除运算优先级别高的部分*/
    	while ((token == '*') || (token == '/'))
    		switch (token) { 
    		case '*': match('*');  /*乘法*/
    			temp *= factor();
    			break;
    		case '/': match('/');   /*除法*/
    			div = factor();
    			if (div == 0) /*需要判断除数是否为0*/
    			{ 
    				fprintf(stderr, "除数为0.\n");
    				exit(1);
    			}
    			temp /= div;
    			break;
    	}
    	return temp;
    }
    
    int factor(void)
    { 
    	int temp;
    	if (token == '(') /*带有括号的运算*/
    	{ 
    		match('(');
    		temp = exp();
    		match(')');
    	}
    	else if (isdigit(token)) /*实际的数字*/
    	{ 
    		ungetc(token, stdin); /*将读入的字符退还给输入流*/
    		scanf("%d", &temp); /*读出数字*/
    		token = getchar();  /*读出当前的标志*/
    	}
    	else error(); /*不是括号也不是数字*/
    	return temp;
    }

## 107、复平面作图 ##

#include <stdio.h>
    #include <math.h>
    #include <string.h>
    #include <stdlib.h>
    
    
    void oplot(int n, double x[], double y[]) /*作图函数，这里使用DOS的文本模式画图*/
    { 
    	int i, j;
    	char screen[25][80]; /*声明一个字符型数组，用来表示屏幕的输出*/
    	memset(screen, ' ', 25 * 80);  /*将数组整体赋值为空格*/
    	/*画x轴*/
    	for (i = 0; i <79; i++)
    		screen[10][i] = '-';
    	screen[10][79] = 'X';
    	/*画y轴*/
    	for (i = 1; i <25; i++)
    		screen[i][40] = '|';
    	screen[0][40] = 'Y';
    	/*将符合条件的点(x,y)赋值成星号*/
    	for (i = 0; i < n; i++)
    		screen[(int)(x[i] + 10)][(int)(y[i] * 2 + 40)] = '*';
    	/*输出数组，在屏幕上画图*/
    	for (i = 0; i < 25; i++)
    	for (j = 0; j <80; j++)
    		printf("%c", screen[i][j]);
    }
    
    void main()
    { 
    	int points, k;
    	double x[50], y[50], angle, portion;
    
    	points = 40; /*一共画40个点*/
    	portion = 4.0 * 360 / points; /*将720度分成40份。*/
    	/*下边是求点的计算*/
    	for (k = 0; k<points; k++)
    	{ 
    		angle = k * portion; /*求出角度*/
    		x[k] = 2.0 + angle*cos(angle); /*x，也就是复数的实部*/
    		y[k] = angle*sin(angle); /*y，即复数的虚部*/
    	}
    	oplot(points, x, y); /*对所求出的点作图*/
    
    	system("pause");
    }

## 108、绘制彩色抛物线 ##

#include <graphics.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    
    /*画抛物线的子函数spara()*/
    /*row,col代表抛物线顶点的坐标，x1,y1是抛物线起点相对顶点的坐标*/
    /*t为抛物线绕顶点旋转的角度*/
    void spara(int row, int col, int x1, int y1, int t, int color)
    { 
    	int n, dx, dy, x, y, x2, y2;
    	double ct, st;
    	double f, fx, fy, b, a, rx;
    	st = (double)t*3.1415926 / 180.0;		/*把角度转化为弧度*/
    	ct = cos(st); st = sin(st);
    	n = abs(x1) + abs(y1); n = n + n;
    	dx = 1; dy = 1; f = 0.0;				/*初始化工作*/
    	if (x1>0) dx = -1;
    	if (y1>0) dy = -1;
    	a = y1; b = x1; b = b*b;
    	rx = -a - a; fx = 2.0*x1*dx + 1.0;
    	fx = -a*fx; fy = b;
    	if (dy<0) fy = -fy;
    	x = x1; y = y1;
    	x2 = (double)x*ct - (double)y*st + 2000.5;
    	y2 = (double)x*st + (double)y*ct + 2000.5;
    	x2 = x2 - 2000; y2 = y2 - 2000;
    	putpixel(row - y2, col + x2, color);
    	while (n>0)						/*具体的运算法则见上面的公式*/
    	{ 
    		n = n - 1;
    		if (f >= 0.0)
    		{ 
    			x = x + dx;
    			x2 = (double)x*ct - (double)y*st + 2000.5;
    			y2 = (double)x*st + (double)y*ct + 2000.5;
    			x2 = x2 - 2000; y2 = y2 - 2000;
    			putpixel(row - y2, col + x2, color);
    			if (fx>0.0) f = f - fx;
    			else f = f + fx;
    			fx = fx + rx;
    			if (fx == 0.0 || (fx<0.0&&fx - rx>0.0) || (fx>0.0&&fx - rx<0.0))
    			{ 
    				dy = -dy; fy = -fy; f = -f;
    			}
    		}
    		else
    		{ 
    			y = y + dy;
    			x2 = (double)x*ct - (double)y*st + 2000.5;
    			y2 = (double)x*st + (double)y*ct + 2000.5;
    			x2 = x2 - 2000; y2 = y2 - 2000;
    			putpixel(row - y2, col + x2, color);
    			if (fy>0.0) f = f + fy;
    			else f = f - fy;
    		}
    	}
    	return;
    }
    
    void main()
    { 
    	int i, color;
    	int gdriver = DETECT, gmode;
    	color = 1;
    	registerbgidriver(EGAVGA_driver);
    	initgraph(&gdriver, &gmode, "..\\bgi");			/*初始化图形界面*/
    	for (i = 1; i <= 4; i++)							/*先画出四个互成90度的抛物线*/
    	{ 
    		spara(200, 200, 100, 100, i * 90, color);
    		color += 3;
    		getch();
    	}
    	color = 1;
    	for (i = 1; i <= 11; i++)							/*再画12个互成30度的抛物线*/
    	{ 
    		spara(200, 200, 100, 100, i * 30, color);
    		color++;
    	}
    	getch();
    	closegraph();
    	system("pause");
    }

## 109、绘制正态分布曲线 ##

#include <stdio.h>
    #include <math.h>
    #include <graphics.h>
    
    double lgam1(double x) /*Gamma函数的计算*/
    { 
    	int i;
    	double y, t, s, u;
    	static double a[11] = {  0.0000677106, -0.0003442342,
    		0.0015397681, -0.0024467480, 0.0109736958,
    		-0.0002109075, 0.0742379071, 0.0815782188,
    		0.4118402518, 0.4227843370, 1.0 };
    	if (x <= 0.0)
    	{ 
    		printf("err**x<=0!\n"); return(-1.0);
    	}
    	y = x;
    	if (y <= 1.0)
    	{ 
    		t = 1.0 / (y*(y + 1.0)); y = y + 2.0;
    	}
    	else if (y <= 2.0)
    	{ 
    		t = 1.0 / y; y = y + 1.0;
    	}
    	else if (y <= 3.0) t = 1.0;
    	else
    	{ 
    		t = 1.0;
    		while (y>3.0)
    		{ 
    			y = y - 1.0; t = t*y;
    		}
    	}
    	s = a[0]; u = y - 2.0;
    	for (i = 1; i <= 10; i++)
    		s = s*u + a[i];
    	s = s*t;
    	return(s);
    }
    double lgam2(double a, double x) /*不完全Gamma函数*/
    { 
    	int n;
    	double p, q, d, s, s1, p0, q0, p1, q1, qq;
    	if ((a <= 0.0) || (x<0.0))
    	{ 
    		if (a <= 0.0) printf("err**a<=0!\n");
    		if (x<0.0) printf("err**x<0!\n");
    		return(-1.0);
    	}
    	if (x + 1.0 == 1.0) return(0.0);
    	if (x>1.0e+35) return(1.0);
    	q = log(x); q = a*q; qq = exp(q);
    	if (x<1.0 + a)
    	{ 
    		p = a; d = 1.0 / a; s = d;
    		for (n = 1; n <= 100; n++)
    		{ 
    			p = 1.0 + p; d = d*x / p; s = s + d;
    			if (fabs(d)<fabs(s)*1.0e-07)
    			{ 
    				s = s*exp(-x)*qq / lgam1(a);
    				return(s);
    			}
    		}
    	}
    	else
    	{ 
    		s = 1.0 / x; p0 = 0.0; p1 = 1.0; q0 = 1.0; q1 = x;
    		for (n = 1; n <= 100; n++)
    		{ 
    			p0 = p1 + (n - a)*p0; q0 = q1 + (n - a)*q0;
    			p = x*p0 + n*p1; q = x*q0 + n*q1;
    			if (fabs(q) + 1.0 != 1.0)
    			{ 
    				s1 = p / q; p1 = p; q1 = q;
    				if (fabs((s1 - s) / s1)<1.0e-07)
    				{ 
    					s = s1*exp(-x)*qq / lgam1(a);
    					return(1.0 - s);
    				}
    				s = s1;
    			}
    			p1 = p; q1 = q;
    		}
    	}
    	printf("a too large !\n");
    	s = 1.0 - s*exp(-x)*qq / lgam1(a);
    	return(s);
    }
    
    double lerrf(double x) /*误差函数*/
    { 
    	double y;
    	if (x >= 0.0)
    		y = lgam2(0.5, x*x);
    	else
    		y = -lgam2(0.5, x*x);
    	return(y);
    }
    double lgass(double a, double d, double x) /*正态分布函数*/
    { 
    	double y;
    	if (d <= 0.0) d = 1.0e-10;
    	y = 0.5 + 0.5*lerrf((x - a) / (sqrt(2.0)*d));
    	return(y);
    }
    
    void main()
    { 
    	int i;
    	double j;
    	double a, d;
    
    	int gdriver = DETECT, gmode;
    	printf("This program will draw the Normal Distribution Graph.\n");
    	printf("Please input the mathematical expectation (Alpha): ");
    	scanf("%lf", &a);
    	printf("Please input the variance (Sita >0): ");
    	scanf("%lf", &d);
    	/*registerbgidriver( EGAVGA_driver );*/
    	initgraph(&gdriver, &gmode, "e:\\tc\\bgi");
    
    	setbkcolor(BLUE);
    	moveto(50, 430);
    	lineto(590, 430);
    	outtextxy(600, 425, "X");
    	moveto(200, 50);
    	lineto(200, 450);
    	outtextxy(200, 30, "Y");
    	outtextxy(185, 435, "O");
    
    	setcolor(RED);
    	moveto(51, 430 - 100 * lgass(a, d, -150.0));
    	for (i = 51; i <= 590; i++)
    	{ 
    		j = 430 - 360 * lgass(a, d, (double)(i - 200));
    		lineto(i, j);
    	}
    	getch();
    	closegraph();
    
    	system("pause");
    }

## 110、求解非线性方程 ##

#include <math.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    
    int BinSearchRoot(double a, double b, double h, double eps, double x[], int m) /*用二法计算非线性方程的实根*/
    /*参数意义： a 要求的根的下界 b 要求的根的上界，即：所求的根落在区间 [a,b]之内 h 递进的步长 eps 精度 x 根的值 m 预计的根的个数*/
    { 
    	extern double Equation(double x); /*要求解的非线性方程*/
    	int n, js;
    	double z, y, z1, y1, z0, y0;
    	n = 0; z = a; y = Equation(z);
    	while ((z <= b + h / 2.0) && (n != m)) /*对给定步长的子区间进行搜索*/
    	{ 
    		if (fabs(y)<eps)  /*当前的判定点是方程的根*/
    		{ 
    			n = n + 1;
    			x[n - 1] = z;
    			z = z + h / 2.0;
    			y = Equation(z);
    		}
    		else /*当前点不是方程的根*/
    		{ 
    			z1 = z + h;
    			y1 = Equation(z1);
    			if (fabs(y1)<eps) /*下一个点是方程的根*/
    			{ 
    				n = n + 1;
    				x[n - 1] = z1;
    				z = z1 + h / 2.0;
    				y = Equation(z);
    			}
    			else if (y*y1>0.0) /*该区间内无根*/
    			{ 
    				y = y1; z = z1;
    			}
    			else   /*该区间内有根*/
    			{ 
    				js = 0;/*标志，0表示未找到根，1表示已经确定了根*/
    				while (js == 0)
    				{ 
    					if (fabs(z1 - z)<eps) /*区间的长度小于给定的精度，可以当作已经找到了根*/
    					{ 
    						n = n + 1;
    						x[n - 1] = (z1 + z) / 2.0; /*把区间的中位值作为根*/
    						z = z1 + h / 2.0; /*把寻找的位置放到下一个区间内*/
    						y = Equation(z);
    						js = 1; /*在当前区间内已经找到了根*/
    					}
    					else /*区间比给定的精度大，则进行二分*/
    					{ 
    						z0 = (z1 + z) / 2.0;  /*区间二分*/
    						y0 = Equation(z0);
    						if (fabs(y0)<eps) /*z0位置为根*/
    						{ 
    							x[n] = z0;
    							n = n + 1;
    							js = 1;
    							z = z0 + h / 2.0;
    							y = Equation(z);
    						}
    						else if ((y*y0)<0.0) /*[z,z0]内有根*/
    						{ 
    							z1 = z0; y1 = y0;
    						}
    						else {  z = z0; y = y0; }
    					}
    				}
    			}
    		}
    	}
    	return(n); /*返回根的个数*/
    }
    
    void main()
    { 
    	int i, n;
    	static int m = 6;
    	static double x[6];
    
    	puts("This is a program to solve Nonlinear function\n by Binary Divisive Procedure.");
    	puts("\n The Nonlinear function is:");
    	puts("\n f(x)=(((((x-5.0)*x+3.0)*x+1.0)*x-7.0)*x+7.0)*x-20.0\n");
    	n = BinSearchRoot(-2.0, 5.0, 0.2, 0.000001, x, m);
    	puts("\n >> Solve successfully!\n >> The results are:");
    	printf(" >> The function has %d roots, they are:\n", n);/*输出根的个数*/
    	for (i = 0; i <= n - 1; i++)
    		printf(" >> x(%d)=%13.7e\n", i, x[i]);
    	system("pause");
    }
    
    double Equation(double x)
    { 
    	double z;
    	z = (((((x - 5.0)*x + 3.0)*x + 1.0)*x - 7.0)*x + 7.0)*x - 20.0;
    	return(z);
    }

## 111、实矩阵乘法运算 ##

#include <stdio.h>
    #include <stdlib.h>
    
    #define MAX 255
    
    /* 实矩阵相乘 */
    void MatrixMul(double a[], double b[], int m, int n, int k, double c[]) 
    /* m:矩阵A的行数 n:矩阵B的行数 k:矩阵B的列数 a为A矩阵 b为B矩阵 c为结果，即c = AB */
    { 
    	int i, j, l, u;
    	/* 逐行逐列计算乘积 */
    	for (i = 0; i <= m - 1; i++)
    	for (j = 0; j <= k - 1; j++)
    	{ 
    		u = i*k + j; c[u] = 0.0;
    		for (l = 0; l <= n - 1; l++)
    			c[u] = c[u] + a[i*n + l] * b[l*k + j];
    	}
    	return;
    }
    
    
    void main()
    { 
    	int i, j, m, n, k;
    	double A[MAX];
    	double B[MAX];
    	double C[MAX];
    	for (i = 0; i<MAX; i++)
    		C[i] = 1.0;
    	puts("This is a real-matrix-multiplication program.\n");
    	puts("It calculate the two matrixes C(m*k)=A(m*n)B(n*k).\n");
    	printf(" >> Please input the number of rows in A, m= ");
    	scanf("%d", &m);
    	printf(" >> Please input the number of cols in A, n= ");
    	scanf("%d", &n);
    	printf(" >> Please input the number of cols in B, k= ");
    	scanf("%d", &k);
    	printf(" >> Please input the %d elements in A one by one:\n", m*n);
    	for (i = 0; i<m*n; i++)
    		scanf("%lf", &A[i]);
    	printf(" >> Please input the %d elements in B one by one:\n", n*k);
    	for (i = 0; i<n*k; i++)
    		scanf("%lf", &B[i]);
    
    	MatrixMul(A, B, m, n, k, C); /*计算C的结果*/
    	/*格式化输出结果*/
    	printf("\n >> The result of C(%d*%d)=A(%d*%d)B(%d*%d) is:\n", m, k, m, n, n, k);
    	for (i = 0; i<m; i++)
    	{ 
    		for (j = 0; j<k; j++)
    			printf("%10.5f ", C[i*k + j]);
    		printf("\n");
    	}
    	system("pause");
    }

## 112、求解线性方程 ##

#include <stdlib.h>
    #include <math.h>
    #include <stdio.h>
    
    #define MAX 255
    
    int Guass(double a[], double b[],int n)
    { 
    	int *js, l, k, i, j, is, p, q;
    	double d, t;
    	js = (int *)malloc(n*sizeof(int));
    	l = 1;
    	for (k = 0; k <= n - 2; k++)
    	{ 
    		d = 0.0;
    		/*下面是换主元部分，即从系数矩阵A的第K行，第K列之下的部分选出 绝对值最大的元，交换到对角线上。*/
    		for (i = k; i <= n - 1; i++)
    		for (j = k; j <= n - 1; j++)
    		{ 
    			t = fabs(a[i*n + j]); /*fabs()定义在math.h中，含义是求一个浮点数的绝对值。*/
    			if (t>d) {  d = t; js[k] = j; is = i; }
    		}
    		if (d + 1.0 == 1.0) l = 0;  /*主元为0*/
    		/*主元不为0的时候*/
    		else
    		{ 
    			if (js[k] != k)
    			for (i = 0; i <= n - 1; i++)
    			{ 
    				p = i*n + k; q = i*n + js[k];
    				t = a[p]; a[p] = a[q]; a[q] = t;
    			}
    			if (is != k)
    			{ 
    				for (j = k; j <= n - 1; j++)
    				{ 
    					p = k*n + j; q = is*n + j;
    					t = a[p]; a[p] = a[q]; a[q] = t;
    				}
    				t = b[k]; b[k] = b[is]; b[is] = t;
    			}
    		}
    		if (l == 0)
    		{ 
    			free(js); printf("fail\n");
    			return(0);
    		}
    		d = a[k*n + k];
    		/* 下面为归一化部分 */
    		for (j = k + 1; j <= n - 1; j++)
    		{ 
    			p = k*n + j; a[p] = a[p] / d;
    		}
    		b[k] = b[k] / d;
    		/* 下面为矩阵A,B消元部分 */
    		for (i = k + 1; i <= n - 1; i++)
    		{ 
    			for (j = k + 1; j <= n - 1; j++)
    			{ 
    				p = i*n + j;
    				a[p] = a[p] - a[i*n + k] * a[k*n + j];
    			}
    			b[i] = b[i] - a[i*n + k] * b[k];
    		}
    	}
    
    	d = a[(n - 1)*n + n - 1];
    	/* 矩阵无解或有无限多解 */
    	if (fabs(d) + 1.0 == 1.0)
    	{ 
    		free(js); printf("该矩阵为奇异矩阵\n");
    		return(0);
    	}
    	b[n - 1] = b[n - 1] / d;
    	/* 下面为迭代消元 */
    	for (i = n - 2; i >= 0; i--)
    	{ 
    		t = 0.0;
    		for (j = i + 1; j <= n - 1; j++)
    			t = t + a[i*n + j] * b[j];
    		b[i] = b[i] - t;
    	}
    	js[n - 1] = n - 1;
    	for (k = n - 1; k >= 0; k--)
    	if (js[k] != k)
    	{ 
    		t = b[k]; b[k] = b[js[k]]; b[js[k]] = t;
    	}
    	free(js);
    	return(1);
    }
    
    void main()
    { 
    	int i, n;
    	double A[MAX];
    	double B[MAX];
    	puts("This is a program to solve N order linear equation set Ax=B.");
    	puts("\n It use Guass Elimination Method to solve the equation set:");
    	puts("\n a(0,0)x0+a(0,1)x1+a(0,2)x2+...+a(0,n-1)xn-1=b0");
    	puts(" a(1,0)x0+a(1,1)x1+a(1,2)x2+...+a(1,n-1)xn-1=b1");
    	puts(" ......");
    	puts(" a(n-1,0)x0+a(n-1,1)x1+a(n-1,2)x2+...+a(n-1,-1)xn-1=bn-1\n");
    	printf(" >> Please input the order n (>1): ");
    	scanf("%d", &n);
    	printf(" >> Please input the %d elements of matrix A(%d*%d) one by one:\n", n*n, n, n);
    	for (i = 0; i<n*n; i++)
    		scanf("%lf", &A[i]);
    	printf(" >> Please input the %d elements of matrix B(%d*1) one by one:\n", n, n);
    	for (i = 0; i<n; i++)
    		scanf("%lf", &B[i]);
    	if (Guass(A, B, n) != 0) /*调用Guass消去，1为计算成功*/
    		printf(" >> The solution of Ax=B is x(%d*1):\n", n);
    
    	for (i = 0; i<n; i++) /*打印结果*/
    		printf("x(%d)=%f ", i, B[i]);
    	system("pause");
    }

## 113、阶方阵求逆 ##

#include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #define MAX 255
    
    void MatrixMul(double a[], double b[], int m, int n, int k, double c[])  /*实矩阵相乘*/
    /* m:矩阵A的行数 n:矩阵B的行数 k:矩阵B的列数 a为A矩阵 b为B矩阵, c为结果，即c = AB */
    { 
    	int i, j, l, u;
    	/* 逐行逐列计算乘积 */
    	for (i = 0; i <= m - 1; i++)
    	for (j = 0; j <= k - 1; j++)
    	{ 
    		u = i*k + j; c[u] = 0.0;
    		for (l = 0; l <= n - 1; l++)
    			c[u] = c[u] + a[i*n + l] * b[l*k + j];
    	}
    	return;
    }
    /* 求矩阵的逆矩阵 */
    int brinv(double a[], int n) 
    /* n: 矩阵的阶数, a: 矩阵A */
    { 
    	int *is, *js, i, j, k, l, u, v;
    	double d, p;
    	is = (int *)malloc(n*sizeof(int));
    	js = (int *)malloc(n*sizeof(int));
    	for (k = 0; k <= n - 1; k++)
    	{ 
    		d = 0.0;
    		for (i = k; i <= n - 1; i++)
    			/*全选主元，即选取绝对值最大的元素*/
    		for (j = k; j <= n - 1; j++)
    		{ 
    			l = i*n + j; p = fabs(a[l]);
    			if (p>d) {  d = p; is[k] = i; js[k] = j; }
    		}
    		/*全部为0，此时为奇异矩阵*/
    		if (d + 1.0 == 1.0)
    		{ 
    			free(is); free(js); printf(" >> This is a singular matrix, can't be inversed!\n");
    			return(0);
    		}
    		/*行交换*/
    		if (is[k] != k)
    		for (j = 0; j <= n - 1; j++)
    		{ 
    			u = k*n + j; v = is[k] * n + j;
    			p = a[u]; a[u] = a[v]; a[v] = p;
    		}
    		/*列交换*/
    		if (js[k] != k)
    		for (i = 0; i <= n - 1; i++)
    		{ 
    			u = i*n + k; v = i*n + js[k];
    			p = a[u]; a[u] = a[v]; a[v] = p;
    		}
    		l = k*n + k;
    		a[l] = 1.0 / a[l]; /*求主元的倒数*/
    		/* a[kj]a[kk] -> a[kj] */
    		for (j = 0; j <= n - 1; j++)
    		if (j != k)
    		{ 
    			u = k*n + j; a[u] = a[u] * a[l];
    		}
    		/* a[ij] - a[ik]a[kj] -> a[ij] */
    		for (i = 0; i <= n - 1; i++)
    		if (i != k)
    		for (j = 0; j <= n - 1; j++)
    		if (j != k)
    		{ 
    			u = i*n + j;
    			a[u] = a[u] - a[i*n + k] * a[k*n + j];
    		}
    		/* -a[ik]a[kk] -> a[ik] */
    		for (i = 0; i <= n - 1; i++)
    		if (i != k)
    		{ 
    			u = i*n + k; a[u] = -a[u] * a[l];
    		}
    	}
    	for (k = n - 1; k >= 0; k--)
    	{ 
    		/*恢复列*/
    		if (js[k] != k)
    		for (j = 0; j <= n - 1; j++)
    		{ 
    			u = k*n + j; v = js[k] * n + j;
    			p = a[u]; a[u] = a[v]; a[v] = p;
    		}
    		/*恢复行*/
    		if (is[k] != k)
    		for (i = 0; i <= n - 1; i++)
    		{ 
    			u = i*n + k; v = i*n + is[k];
    			p = a[u]; a[u] = a[v]; a[v] = p;
    		}
    	}
    	free(is); free(js);
    	return(1);
    }
    
    /* 打印的方阵a的元素 */
    void print_matrix(double a[], int n)
    /* n：矩阵的阶数 a：矩阵a */
    { 
    	int i, j;
    	for (i = 0; i<n; i++)
    	{ 
    
    		for (j = 0; j<n; j++)
    			printf("%13.7f\t", a[i*n + j]);
    		printf("\n");
    	}
    }
    
    void main()
    { 
    	int i, j, n = 0;
    	double A[MAX], B[MAX], C[MAX];
    	static double a[4][4] = {  {  0.2368, 0.2471, 0.2568, 1.2671 },
    	{  1.1161, 0.1254, 0.1397, 0.1490 },
    	{  0.1582, 1.1675, 0.1768, 0.1871 },
    	{  0.1968, 0.2071, 1.2168, 0.2271 } };
    	static double b[4][4], c[4][4];
    	puts("**********************************************************");
    	puts("* This program is to inverse a square matrix A(nxn). *");
    	puts("**********************************************************");
    	while (n <= 0)
    	{ 
    		printf(" >> Please input the order n of the matrix (n>0): ");
    		scanf("%d", &n);
    	}
    
    	printf(" >> Please input the elements of the matrix one by one:\n >> ");
    	for (i = 0; i<n*n; i++)
    	{ 
    		scanf("%lf", &A[i]);
    		B[i] = A[i];
    	}
    	for (i = 0; i<4; i++)
    	for (j = 0; j<4; j++)
    		b[i][j] = a[i][j];
    
    	i = brinv(A, n);
    
    	if (i != 0)
    	{ 
    		printf(" Matrix A:\n");
    		print_matrix(B, n);
    		printf("\n");
    		printf(" A's Inverse Matrix A-:\n");
    		print_matrix(A, n);
    		printf("\n");
    		printf(" Product of A and A- :\n");
    		MatrixMul(B, A, n, n, n, C);
    		print_matrix(C, n);
    	}
    	system("pause");
    }

## 114、复矩阵乘法 ##

#include <stdio.h>
    #include <stdlib.h>
    #define MAX 255
    
    /* 复矩阵相乘 */
    void CMatrixMul(double ar[], double ai[], double br[], double bi[], int m, int n, int k, cr[], ci[])
    /* m是矩阵A的行数 n是矩阵B的行数 k是矩阵B的列数 ar,br,cr分别是矩阵A,B,C的实部 ai,bi,ci分别是矩阵A,B, C的虚部 */
    { 
    	int i, j, l, u, v, w;
    	double p, q, s;
    	for (i = 0; i <= m - 1; i++)
    	for (j = 0; j <= k - 1; j++)
    	{ 
    		u = i*k + j;
    		cr[u] = 0.0; ci[u] = 0.0;
    		for (l = 0; l <= n - 1; l++)
    		{ 
    			v = i*n + l; w = l*k + j;
    			p = ar[v] * br[w];
    			q = ai[v] * bi[w];
    			s = (ar[v] + ai[v])*(br[w] + bi[w]);
    			cr[u] = cr[u] + p - q;
    			ci[u] = ci[u] + s - p - q;
    		}
    	}
    	return;
    }
    /* 打印的矩阵A(m*n)的元素 */
    void print_matrix(double A[], int m, int n)
     /* m,n：矩阵的阶数 A: 矩阵A */
    { 
    	int i, j;
    	for (i = 0; i<m; i++)
    	{ 
    		for (j = 0; j<n; j++)
    			printf("%13.7f\t", A[i*n + j]);
    		printf("\n");
    	}
    }
    void main()
    { 
    	int i, j, n, m, k;
    	double Ar[MAX], Br[MAX], Cr[MAX], Ai[MAX], Bi[MAX], Ci[MAX];
    	static double cr[3][4], ci[3][4];
    	static double ar[3][4] = {  {  1.0, 2.0, 3.0, -2.0 }, /*矩阵A的实部*/
    	{  1.0, 5.0, 1.0, 3.0 },
    	{  0.0, 4.0, 2.0, -1.0 } };
    	static double ai[3][4] = {  {  1.0, -1.0, 2.0, 1.0 }, /*矩阵A的虚部*/
    	{  -1.0, -1.0, 2.0, 0.0 },
    	{  -3.0, -1.0, 2.0, 2.0 } };
    	static double br[4][4] = {  {  1.0, 4.0, 5.0, -2.0 }, /*矩阵B的实部*/
    	{  3.0, 0.0, 2.0, -1.0 },
    	{  6.0, 3.0, 1.0, 2.0 },
    	{  2.0, -3.0, -2.0, 1.0 } };
    	static double bi[4][4] = {  {  -1.0, -1.0, 1.0, 1.0 }, /*矩阵B的虚部*/
    	{  2.0, 1.0, 0.0, 5.0 },
    	{  -3.0, 2.0, 1.0, -1.0 },
    	{  -1.0, -2.0, 1.0, -2.0 } };
    	puts("**********************************************************");
    	puts("* This is a complex-matrix-multiplication program. *");
    	puts("* It calculate the two matrixes C(m*k)=A(m*n)B(n*k). *");
    	puts("**********************************************************");
    	printf(" >> Please input the number of rows in A, m= ");
    	scanf("%d", &m);
    	printf(" >> Please input the number of cols in A, n= ");
    	scanf("%d", &n);
    	printf(" >> Please input the number of cols in B, k= ");
    	scanf("%d", &k);
    	printf(" >> Please input the %d elements in Ar one by one:\n >> ", m*n);
    	for (i = 0; i<m*n; i++)
    		scanf("%lf", &Ar[i]);
    	printf(" >> Please input the %d elements in Ai one by one:\n >> ", m*n);
    	for (i = 0; i<m*n; i++)
    		scanf("%lf", &Ai[i]);
    	printf(" >> Please input the %d elements in Br one by one:\n >> ", n*k);
    	for (i = 0; i<n*k; i++)
    		scanf("%lf", &Br[i]);
    	printf(" >> Please input the %d elements in Bi one by one:\n >> ", n*k);
    	for (i = 0; i<n*k; i++)
    		scanf("%lf", &Bi[i]);
    	CMatrixMul(Ar, Ai, Br, Bi, m, n, k, Cr, Ci); /*进行计算*/
    	/*输出乘积结果的实部*/
    	printf(" Real part of C(%d*%d)=A(%d*%d)*B(%d*%d):\n", m, k, m, n, n, k);
    	print_matrix(Cr, m, k);
    	/*输出乘积结果的虚部*/
    	printf(" Complex part of C(%d*%d)=A(%d*%d)*B(%d*%d):\n", m, k, m, n, n, k);
    	print_matrix(Ci, m, k);
    	system("pause");
    }

## 115、求定积分 ##

#include <stdio.h>
    #include <math.h>
    #include <stdlib.h>
    
    
    /* 要进行计算的被积函数 */
    double fsimpf(double x) 
    { 
    	double y;
    	y = log(1.0 + x) / (1.0 + x*x);
    	return(y);
    }
    
    /* 辛普森算法 */
    double fsimp(double a, double b, double eps) 
    /*a为积分下限，b为积分上限，eps是希望达到的精度*/
    { 
    	int n, k;
    	double h, t1, t2, s1, s2, ep, p, x;
    	n = 1; h = b - a;
    	t1 = h*(fsimpf(a) + fsimpf(b)) / 2.0;  /* 用梯形公式求出一个大概的估值 */
    	s1 = t1;
    	ep = eps + 1.0;
    	while (ep >= eps)
    	{ 
    		/* 用梯形法则计算 */
    		p = 0.0;
    		for (k = 0; k <= n - 1; k++)
    		{ 
    			x = a + (k + 0.5)*h;
    			p = p + fsimpf(x);
    		}
    		t2 = (t1 + h*p) / 2.0;
    		/* 用辛普森公式求精 */
    		s2 = (4.0*t2 - t1) / 3.0;
    		ep = fabs(s2 - s1);
    		t1 = t2; s1 = s2; n = n + n; h = h / 2.0;
    	}
    	return(s2);
    }
    void main()
    { 
    	double a, b, eps, t;
    	a = 0.0; b = 1.0; eps = 0.0000001;
    	puts("**********************************************************");
    	puts("* This program is to calculat the Value of *");
    	puts("* a definite integral by Simpson Method. *");
    	puts("**********************************************************");
    	t = fsimp(a, b, eps);
    	puts("\n----------------------------------------------------------");
    	printf(" >> The result of definite integral is : \n");
    	printf(" >> SIGMA(0,1)ln(1+x)/(1+x^2)dx = ");
    	printf("%e\n", t);
    	puts("----------------------------------------------------------");
    	system("pause");
    }

## 116、求满足特异条件的数列 ##

#include <stdio.h>
    #include <stdlib.h>
    #define NUM 10 /* 允许分解的最大元素数量 */
    int i[NUM];        /* 记录分解出的数值的数组 */
    
    void main()
    { 
    	int sum, n, total, k, flag, count = 0;
    	puts("*********************************************************");
    	puts("* This is a program to get number sequence with *");
    	puts("* special characteristic. Input n and m,get the sequence*");
    	puts("* S1,S2,...,Sn, where S1+S2+...+Sn=m and S1>=S2>=...>=Sn*");
    	puts("* e.g.n=4,m=8,S: 5 1 1 1,4 2 1 1,3 3 1 1,3 2 2 1,2 2 2 2*");
    	puts("*********************************************************");
    	printf(" >> Input element number of the sequence (n<=10): ");
    	scanf("%d", &n);
    	printf(" >> Input the sum of the elements (m<=20): ");
    	scanf("%d", &total);
    	sum = 0;                 /*当前从后向前k个元素的和*/
    	k = n;                   /*从后向前正在处理的元素下标*/
    	i[n] = 1;             /*将最后一个元素的值置为1作为初始值*/
    	printf(" >> Possible sequences are as follows:\n");
    	while (1)
    	{ 
    		if (sum + i[k]<total)     /*若后k位的和小于指定的total*/
    		if (k <= 1)            /*若正要处理的是第一个元素*/
    		{ 
    			i[1] = total - sum; flag = 1;
    		}     /*则计算第一个元素的并置标记*/
    		else{ 
    			sum += i[k--];
    			i[k] = i[k + 1];        /*置第k位的值后k-1*/
    			continue;         /*继续向前处理其它元素*/
    		}
    		else if (sum + i[k]>total || k != 1)   /*若和已超过total或不是第一个元素*/
    		{ 
    			sum -= i[++k]; flag = 0;
    		}      /*k向后回退一个元素*/
    		else flag = 1;        /*sum+i[k]=total&&k=1 则设置flag标记*/
    		if (flag)
    		{ 
    			printf(" No.%2d: ", ++count);
    			for (flag = 1; flag <= n; ++flag)
    				printf("%d ", i[flag]);
    			printf("\n");
    		}
    		if (++k>n)     /*k向后回退一个元素后判断是否已退出最后一个元素*/
    			break;
    		sum -= i[k];
    		i[k]++;        /*试验下一个分解*/
    	}
    	system("pause");
    }

## 117、超长正整数的加法 ##

#include<stdio.h>
    #include<stdlib.h>
    
    #define HUNTHOU 10000
    typedef struct node{ 
    	int data;
    	struct node *next;
    }NODE;                 /*定义链表结构*/
    
    NODE *insert_after(NODE *u, int num);     /* 在u结点后插入一个新的NODE，其值为num */
    NODE *addint(NODE *p, NODE *q);           /* 完成加法操作返回指向*p+*q结果的指针 */
    void printint(NODE *s);
    NODE *inputint(void);
    
    void main()
    { 
    	NODE *s1, *s2, *s;
    	NODE *inputint(), *addint(), *insert_after();
    	puts("*********************************************************");
    	puts("* This program is to calculate *");
    	puts("* the addition of king sized positive integer. *");
    	puts("*********************************************************");
    	printf(" >> Input S1= ");
    	s1 = inputint();            /*输入被加数*/
    	printf(" >> Input S2= ");
    	s2 = inputint();            /*输入加数*/
    	printf(" >> The addition result is as follows.\n\n");
    	printf(" S1= "); printint(s1); putchar('\n');     /*显示被加数*/
    	printf(" S2= "); printint(s2); putchar('\n');     /*显示加数*/
    	s = addint(s1, s2);                                 /*求和*/
    	printf(" S1+S2="); printint(s); putchar('\n');    /*输出结果*/
    	system("pause");
    }
    NODE *insert_after(NODE *u, int num)
    { 
    	NODE *v;
    	v = (NODE *)malloc(sizeof(NODE));      /*申请一个NODE*/
    	v->data = num;                         /*赋值*/
    	u->next = v;                           /*在u结点后插入一个NODE*/
    	return v;
    }
    NODE *addint(NODE *p, NODE *q)         /*完成加法操作返回指向*p+*q结果的指针*/
    { 
    	NODE *pp, *qq, *r, *s, *t;
    	int total, number, carry;
    	pp = p->next; qq = q->next;
    	s = (NODE *)malloc(sizeof(NODE));     /*建立存放和的链表表头*/
    	s->data = -1;
    	t = s; carry = 0;                      /*carry:进位*/
    	while (pp->data != -1 && qq->data != -1)    /*均不是表头*/
    	{ 
    		total = pp->data + qq->data + carry;     /*对应位与前次的进位求和*/
    		number = total%HUNTHOU;             /*求出存入链中部分的数值 */
    		carry = total / HUNTHOU;              /*算出进位*/
    		t = insert_after(t, number);         /*将部分和存入s向的链中*/
    		pp = pp->next;                         /*分别取后面的加数*/
    		qq = qq->next;
    	}
    	r = (pp->data != -1) ? pp : qq;          /*取尚未自理完毕的链指针*/
    	while (r->data != -1)              /*处理加数中较大的数*/
    	{ 
    		total = r->data + carry;         /*与进位相加*/
    		number = total%HUNTHOU;        /*求出存入链中部分的数值*/
    		carry = total / HUNTHOU;         /*算出进位*/
    		t = insert_after(t, number);     /*将部分和存入s指向的链中*/
    		r = r->next;                   /*取后面的值*/
    	}
    	if (carry) t = insert_after(t, 1);     /*处理最后一次进位*/
    	t->next = s;                   /*完成和的链表*/
    	return s;                     /*返回指向和的结构指针*/
    }
    NODE *inputint(void)     /*输入超长正整数*/
    { 
    	NODE *s, *ps, *qs;
    	struct number { 
    		int num;
    		struct number *np;
    	}*p, *q;
    	int i, j, k;
    	long sum;
    	char c;
    	p = NULL;     /*指向输入的整数，链道为整数的最低的个位，链尾为整数的最高位*/
    	while ((c = getchar()) != '\n')     /*输入整数，按字符接收数字*/
    	if (c >= '0'&&c <= '9')           /*若为数字则存入*/
    	{ 
    		q = (struct number *)malloc(sizeof(struct number));    /*申请空间*/
    		q->num = c - '0';           /*存入一位整数*/
    		q->np = p;                /*建立指针*/
    		p = q;
    	}
    	s = (NODE *)malloc(sizeof(NODE));
    	s->data = -1;                  /*建立表求超长正整数的链头*/
    	ps = s;
    	while (p != NULL)        /*将接收的临时数据链中的数据转换为所要求的标准形式*/
    	{ 
    		sum = 0; i = 0; k = 1;
    		while (i<4 && p != NULL)          /*取出低四位*/
    		{ 
    			sum = sum + k*(p->num);
    			i++; p = p->np; k = k * 10;
    		}
    		qs = (NODE *)malloc(sizeof(NODE));          /*申请空间*/
    		qs->data = sum;                     /*赋值，建立链表*/
    		ps->next = qs;
    		ps = qs;
    	}
    	ps->next = s;
    	return s;
    }
    
    void printint(NODE *s)
    { 
    	if (s->next->data != -1)         /*若不是表头，则输出*/
    	{ 
    		printint(s->next);             /*递归输出*/
    		if (s->next->next->data == -1)
    			printf("%d", s->next->data);
    		else{ 
    			int i, k = HUNTHOU;
    			for (i = 1; i <= 4; i++, k /= 10)
    				putchar('0' + s->next->data % (k) / (k / 10));
    		}
    	}
    }

## 118、绘制直线 ##

#include <graphics.h>
    #include <stdlib.h>
    
    void main()
    { 
    	int gdriver = DETECT, gmode;
    	initgraph(&gdriver, &gmode, "c:\\tc");
    	cleardevice();
    	line(160, 120, 480, 120);
    	line(480, 120, 480, 360);
    	line(480, 360, 160, 360);
    	line(160, 360, 160, 120);
    	system("pause");
    	closegraph();
    }

## 119、绘制圆 ##

#include <graphics.h>
    #include <stdlib.h>
    
    void main()
    { 
    	int gdriver = DETECT, gmode;
    	initgraph(&gdriver, &gmode, "c:\\tc");
    	cleardevice();
    	moveto(160, 120);
    	lineto(480, 120);
    	lineto(480, 360);
    	lineto(160, 360);
    	lineto(160, 120);
    	system("pause");
    	closegraph();
    }

## 120、绘制圆弧 ##

#include <graphics.h>
    #include <stdlib.h>
    
    void main()
    { 
    	int gdriver = DETECT, gmode;
    	initgraph(&gdriver, &gmode, "c:\\tc");
    	cleardevice();
    	moveto(160, 120);
    	linerel(320, 0);
    	linerel(0, 240);
    	linerel(-320, 0);
    	linerel(0, -240);
    	system("pause");
    	closegraph();
    }

[_ _ _ _y_ _ _ _ _y_C_1-60_]: https://blog.csdn.net/weixin_45926547/article/details/120630529?spm=1001.2014.3001.5501