魔王语言解释

合集下载

魔王语言解释

魔王语言解释

实习报告题目:编制一个魔王语言解释的程序班级:06052711 姓名:曹旭学号:06057104 完成日期:2007.11.27一、需求分析[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没人能听的懂。

但他的语言是可以逐步解释成人能懂得语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α->β1β2...βn(2)(θδ1δ2...δn)->θδnθδn-1...θδ1θ在这两种形式中,从左到右均表示解释;从右到左表示抽象。

试写一个魔王解释系统,把他的话解释成人能听懂得话。

[基本要求]用下述两条具体规则和上述规则形式(2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母(a,b1,s,y1等)表示可以用大写或小写字母代换的变量。

魔王语言可含人的词汇。

(1)B->tAdA(2) A->sae[测试数据]B(einxgz)B解释成tsaedsaeezegexeneietsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是“天上一个鹅地上一个鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一个鹅地上一个鹅。

”t d s a e z G x n i天地上一个鹅追赶下蛋恨[实现提示]将魔王的语言自右至左进栈,总是处理栈顶。

若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列再处理后入栈。

其他情形较简单,请读者思考如何处理,应首先实现栈和队列的基本运算二、概要设计为实现上述程序功能,应以栈和队列来表示。

1.设定栈的抽象数据类型定义为:ADT Stack{数据对象:D={ai | ai∈CharSet,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |ai-1,ai∈D,I=1,2,......,n}基本操作:ListInitiate (&S)操作结果:构造一个空栈S。

魔鬼口语

魔鬼口语

(一):禽兽不如1.You seem subdued. Are you all right?你好像有点没精神。

有什么心事吗? subdue [səb'dju:]vt. 征服;抑制;减轻2.No spells no. 我说不行就不行(没必要再讨论了)。

3.Don't bulldoze me. 别逼我。

bulldoze ['buldəuz]vt. 强迫;恫吓;用推土机清除4.He got this zen look on his face. 他摆出一副一本正经/无所谓的样子。

zen [zen]n. 禅;禅宗;禅宗信徒(等于Zen Buddhism)5.Their smiles were plastic. 他们的笑太假了。

6.He lacks personality. 他没有个性。

7.Roger!收到!(OK,知道了)8.I couldn't find my bearings. 我有点找不着北。

bearing ['bεəriŋ]n. [机] 轴承;关系;方位;举止v. 忍受(bear的ing形式)9.They're lower than the animals. 他们禽兽不如。

10.Hey, that's mine. Fork it over! 喂,那是我的。

拿过来!(二):发什么神经1.What's come over you?你发什么神经啊?(怎么啦?)2.They enjoy being wined and dined.他们喜欢吃请。

3.My patience is running out.我等不及了。

4.Stop it! You could bite the dust.别瞎折腾。

当心摔个狗啃泥。

5.You don't have to mind your P's and Q's.你不必小心翼翼的。

6.Might is right.拳头大的是爷。

数据结构 课程设计报告 魔王语言解释

数据结构 课程设计报告 魔王语言解释

题目:魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α->β1β2……βm(2)(θδ1δ2……δn)—>θδnθδn-1……θδ1θ在这两种形式中,从左到右均表示解释。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话;[基本要求]用下述两条具体规则和上述规则形式(2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

(1)B->tAdA(2)A->sae[测试数据]B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

[实现提示]将魔王的语言自右至左进栈,总是处理栈顶字符。

若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列再处理后入栈。

其他情形较简单,请读者思考应如何处理。

应首先实现栈和队列的基本操作。

[源代码]#include<stdio.h>#include<stdlib.h>#define STACK_INIT_SIZE 100#define STACK_INCREMENT 10struct Stack{char* base;char* top;int stacksize;};void InitStack(struct Stack &s){//构造栈s.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));s.top=s.base;s.stacksize=STACK_INIT_SIZE;}void Push(struct Stack &s,char e){//压入元素if(s.top-s.base>=STACK_INIT_SIZE){s.base=(char*)realloc(s.base,(s.stacksize+STACK_INCREMENT)*sizeof(char));s.top=s.base+s.stacksize;s.stacksize+=STACK_INCREMENT;}*(s.top)=e;s.top++;}void Pop(struct Stack &s,char &e){//取出元素e=*--s.top;}int StackEmpty(struct Stack s){//栈是否为空if(s.top==s.base){return 1;}else{return 0;}}void ClearStack(struct Stack &s){s.top=s.base;}struct Queue{char data;struct Queue* next;};struct LinkQueue{struct Queue* front;struct Queue* rear;};void InitQueue(struct LinkQueue &q){//构造队q.front=q.rear=(struct Queue*)malloc(sizeof(struct Queue));q.front->next=NULL;}void EnQueue(struct LinkQueue &q,char e){//元素入队struct Queue* p;p=(struct Queue*)malloc(sizeof(struct Queue));p->data=e;p->next=NULL;q.rear->next=p;q.rear=p;}void DeQueue(struct LinkQueue &q,char &e){//元素出队struct Queue* p;p=q.front->next;e=p->data;q.front->next=p->next;if(q.rear==p){q.rear=q.front;}free(p);}int QueueEmpty(struct LinkQueue q){//队是否为空if(q.front==q.rear){return 1;}else{return 0;}}void InStack(char* ch,struct Stack &s){//把字符数组从右至左压入栈中int i,L=0;while(ch[L]!='\0'){L++;}for(i=L-1;i>=0;i--){Push(s,ch[i]);}}int main(){int i=0;char A[]="sae";char B[]="tsaedsae";char flag='0';//flag用来标记处理括号int mark=1;int f=0;struct Stack S;struct Stack temp;//用来处理括号外的元素InitStack(S);InitStack(temp);struct LinkQueue Q;InitQueue(Q);char MoWang[100]="\0";char e1,key,e2,e;printf("************************************************************** \n");printf("* * 欢迎光临广东工业大学**\n");printf("* **************************** *\n");printf("* * 魔王语言解释系统* *\n");printf("* **************************** *\n");printf("* 班级:计算机学院网络工程2007级4班*\n");printf("* 姓名: 黄文龙学号: 3107007087 *\n");printf("************************************************************** \n\n");printf("请输入你想要解释的魔王语言(最多含有一个括号):\n");gets(MoWang);InStack(MoWang,S);//把要解释的魔王语言压入栈中while(!StackEmpty(S)){Pop(S,e1);if(e1=='('){if(StackEmpty(S)){printf("魔王语言错误!\n");mark=0;break;}while(!StackEmpty(S)){Pop(S,e1);if(e1==')'){f=1;break;}else if(!(e1>='a'&&e1<='z')&&!(e1>='A'&&e1<='Z')){ printf("魔王语言错误!\n");mark=0;break;}}if(mark==0){break;}if(f!=1){printf("魔王语言错误!\n");break;}}else if(e1==')'){printf("魔王语言错误!\n");mark=0;break;}else if(!(e1>='a'&&e1<='z')&&!(e1>='A'&&e1<='Z')){printf("魔王语言错误!\n");mark=0;break;}}if(mark==1&&f==1){ClearStack(S);InStack(MoWang,S);while(!StackEmpty(S)){//栈不空时Pop(S,e1);if(e1=='B'){Push(temp,e1);}else if(e1=='A'){Push(temp,e1);}else if(e1=='('){//用队存储括号中的元素Push(temp,flag);//有括号的话就用flag标记Pop(S,e1);while(e1!=')'){EnQueue(Q,e1);Pop(S,e1);}if(!QueueEmpty(Q)){DeQueue(Q,key);}}else{Push(temp,e1);f=0;}}while(!StackEmpty(temp)){//边处理边进栈Pop(temp,e1);if(e1!=flag){//把括号外的元素压入中Push(S,e1);}else{while(!QueueEmpty(Q)){//处理括号中的元素进栈DeQueue(Q,e2);Push(S,key);Push(S,e2);}if(f!=0){//最后还要压一个keyPush(S,key);}}}printf("解释后的语言为:\n");while(!StackEmpty(S)){//依次出栈输出处理后的元素Pop(S,e);EnQueue(Q,e);//元素进队是为了输出对应汉字if(e=='B'){printf("%s",B);}else if(e=='A'){printf("%s",A);}else{printf("%c",e);}}printf("\n");while(!QueueEmpty(Q)){//输出对应汉字DeQueue(Q,e);switch(e){case 't': printf("天");break;case 'd' : printf("地"); break;case 's' : printf("上"); break;case 'a' : printf("一只"); break;case 'e' : printf("鹅"); break;case 'z' : printf("追"); break;case 'g' : printf("赶"); break;case 'x' : printf("下"); break;case 'n' : printf("蛋"); break;case 'h' : printf("恨"); break;case 'B' : printf("天上一只鹅地上一只鹅");break;case 'A' : printf("上一只鹅");break;default : printf("*");break;}}printf("\n");}system("pause");return 0;}[读者手册]1、本程序的运行环境为dos操作系统,执行文件为“魔王解释语言.exe”。

魔王语言解释

魔王语言解释

一.实验目的设计中要求综合运用所学知识,上机解决一些与实际应用结合紧密的、规模较大的问题。

通过分析、设计、编码、调试等各环节的训练,使学生深刻理解、牢固掌握数据结构和算法设计技术,掌握分析、解决实际问题的能力。

通过这次设计,要求在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面,加深对课程基本内容的理解。

同时,在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练二.实验内容主要功能:魔王总是使用自己的一种非常精练而抽象的语言讲话,没人能听懂,但他的语言是可逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:1)a---> (B1)(B2)....(Bm)2)[(op1)(p2)...(pn)]---->[o(pn)][o(p(n-1))].....[o(p1)o]在这两种形式中,从左到右均表示解释.试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话.基本要求:用下述两条具体规则和上述规则形式(2)实现.设大写字母表示魔王语言的词汇;小写字母表示人的语言的词汇;希腊字母表示可以用大写字母或小写字母代换的变量.魔王语言可含人的词汇.1) B --> tAdA2) A --> sa三.实验步骤(可选)声明:#include<iostream>using namespace std;#include<string>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10void EnQueue(struct LinkQueue &q,char e) //元素入队列void DeQueue(LinkQueue &q,char &e) //元素出队列int QueueEmpty(struct LinkQueue q) //判断栈是否为空void InStack(char *ch,stack &s) //把字符压入栈中void InQueue(char *ch, LinkQueue &q) //数组元素入队列void ClearQueue(LinkQueue &q, char e) //清空队列定义结构体:struct stack //栈结构体定义{char* base;char* top;int stacksize;};struct LinkQueue //队列结构体定义{struct Queue* front;struct Queue* rear;};初始化栈void InitStack(stack &s){s.base=(char*)malloc(STACK_INIT_SIZE*sizeof(char));if(!s.base)exit(-1);s.top=s.base;s.stacksize=STACK_INIT_SIZE;}程序主函数:void main(){int i=0,h;char a[100];char A[]="sae";char B[]="tsaedsae";int mark=1;struct stack S;InitStack(S);LinkQueue Q,Q1;InitQueue(Q);InitQueue(Q1);char mowang[100];char x,e;cout<<" *********************魔王语言********************"<<endl<<endl;cout<<" 请输入你要翻译的魔王语言";gets(mowang); //获取字符串存入mowang数组中InStack(mowang,S); //把要解释的魔王语言压入栈中(从右至左)cout<<endl<<" 魔王语言翻译为人语言为:";while(!StackEmpty(S)){Pop(S,e);if(e=='('){mark=0;if(StackEmpty(S)){cout<<" 你输入的魔王语言不合法"<<endl;ClearQueue(Q1,e);break;}Pop(S,e);while(mark==0){if(e!=')')EnQueue(Q,e); //将括号内的字符存入队列else{mark=1;break;}if(!StackEmpty(S))Pop(S,e);elsebreak;}if(mark==0){cout<<" 你输入的魔王语言不合法"<<endl;ClearQueue(Q1,e);break;}if(!QueueEmpty(Q)){DeQueue(Q,e); //规则2字符进栈x=e;Push(S,x);while(!QueueEmpty(Q)){DeQueue(Q,e);Push(S,e);Push(S,x);}}e='\0';}if((e!='\0' && e<'A') || (e>'Z' && e<'a') || (e>'z')) {cout<<" 你输入的魔王语言不合法";ClearQueue(Q1,e);break;}if(e){switch(e){case 'B' : cout<<B; InQueue(B,Q1); e='\0';break;case 'A' :cout<<A;InQueue(A,Q1); e='\0'; break;default : cout<<e;}}if(e)EnQueue(Q1,e);}cout<<endl<<endl<<" 与汉字建立关系输出为:"<<endl; cout<<" ";while(!QueueEmpty(Q1)){DeQueue(Q1,e);switch(e){case 't' : cout<<"天";break;case 'd' : cout<<"地"; break;case 's' : cout<<"上"; break;case 'a' : cout<<"一只"; break;case 'e' : cout<<"鹅"; break;case 'z' : cout<<"追"; break;case 'g' : cout<<"赶"; break;case 'x' : cout<<"下"; break;case 'n' : cout<<"蛋"; break;case 'h' : cout<<"恨"; break;case '\0': cout<<""; break;}}cout<<endl;}四.实验的结果及分析。

魔王语言解释

魔王语言解释

魔王语言解释
问题描述:
有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释承认能听懂的语言,因为他的语言是有以下两种形式的规则由人的语言逐步抽象上去的:
(1)α→β1β2…βm
(2)(θδ1δ2…δn)→θδnθδn-1…θδ1θ
在这两种形式中,从左到右均表示解释。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

基本要求:
用下述两条具体规则和上述规则形式(2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

(1)B→tAdA
(2)A→sae
测试数据:
B(ehnxgz) B解释成tsaedsaeezegexenehetsaedsae
若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

实现提示:
将魔王的语言自右至左进栈,总是处理栈顶字符。

若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列在处理后入栈。

其他情形较简单,请读者思考应如何处理。

应首先实现栈和队列的基本操作。

魔王语言实验报告

魔王语言实验报告

数据结构课程设计报告题目:魔王语言系部名称:通信工程专业名称:班级:学号:学生姓名:指导教师:时间:一、课程设计目的(1)熟练掌握C语言和数据结构的相关操作。

(2)综合应用C语言的知识和数据结构的知识,编写程序,并且对以前所学的知识进行复习。

( 3 ) 培养学生独立完成课程设计的能力。

二、课程设计内容1.用带头结点的动态单链表来存储多项式;在此基础上完成多项式乘法运算要求以动态链表为存储结构、使用到查找和排序等操作;在创建多项式的过程中,可以按指数的任意顺序输入,并且可在同一多项式中输入指数相同的多项;在进行乘法操作之前,输出参与操作的两个多项式。

要求输出的多项式按指数降序排列,同指数的多项合并,项数的正负号显示合理。

2.魔王语言有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。

但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 ……θδ1 θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。

试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。

读取文件,并统计1. 读取文本文件(rule.txt), 将具体规则的对应关系读入数组或链中2. 读取文本文件(mean.txt), 将小写字母及其对应的含义读入数组或链表中处理规则形式(2)按照规则形式(2)处理魔王所说的话。

处理完毕后,对应的解释语句不再含有()。

处理规则形式(1)按照读入的具体规则,对上一步处理的结果进行规则形式(1)的处理,得到魔王所说的话的人类语言结果。

写结果文件按照所读入的小写字母对应的文字含义,将翻译成的人类语言转换成文字语句,写入文件result.txt中。

读取文件,并统计1. 读取文本文件(rule.txt),将具体规则的对应关系读入数组或链表中2. 读取文本文件(mean.txt), 将小写字母及其对应的含义读入数组或链表中处理规则形式(2)按照规则形式(2)处理魔王所说的话。

题目3 魔王语言解释

题目3   魔王语言解释

题目3 魔王语言解释问题:魔王的语言精练而抽向,将他的语言按如下规则可转换成人的语言:(1) BtAdA(2) Asae(3) (n) 2…… 1 1 2 n……实现提示1:构造栈S,用于放置魔王语言(右 左)栈为顺序栈,元素类型为字符型,栈的空间长度为30,增量为5。

栈的结构为Stack型,{top;base}。

并完成以下几个基本函数:(1) 构造函数InitS(),它返回Stack型(2) 销毁函数DestS(Stack S)(3) 入栈函数Push(char c, Stack S ),它返回Stack型(4) 出栈函数Pop(Stack S),它返回Stack型(5) 读栈顶GetTop(Stack S),它返回char型(6) 判空函数Sempty(Stack S),它返回0、1实现提示2:构造队列Q,用于放置“(……)”内的信息队列可设置成循环队列,空间长度为30,元素类型为char,队列的结构为Queue型,{base,rear,front},并完成以下基本函数:(1) 构造InitQ(),返回Queue型(2) 销毁函数DestQ(Queue Q)(3) 入队函数EnQ(char c, Queue Q ),它返回Queue型(4) 出队函数DeQ(Queue Q ),它返回Queue型(5) 读队头GetQ(Queue Q ),它返回char型(6) 判空函数Qempty(Queue Q ),它返回0、1实现提示3:1)读入第一、二两条规则;2)将魔王的语言按从右向左的顺序依次进栈;3)循环,直到栈空停止4)读栈顶元素,分情况处理情况1 若是小写字母,直接出栈情况2 若是大写字母B,按规则一依次进栈情况3 若是大写字母A,按规则二依次进栈情况4 若是“(”,则c1= ;循环依次出栈,进队列,并进队c1,直到“)”结束循环;依次出队列,入栈,直到队列空题目1 约瑟夫环问题:编号为1,2,……,n的n个人按顺时针方向围坐一圈,每个人持有一个密码(正整数)。

魔王语言

魔王语言

软件设计部分1.题目分析该题目要实现的是将魔王的语言逐步解释成人能听懂的语言,依据任务书要求可总结魔王语言符合以下几条规则:(1)α→β1β2...βm(2)(θδ1δ2...δn)→θδnδn-1...θδ1θ(3)B→tAdA(4)A→sae上述规则中大写字母表示魔王词汇;小写字母表示人的语言;希腊字母表示可以用大写或小写字母代换的变量。

魔王语言可含人的词汇。

经分析知本程序主要通过栈和队列实现的,将魔王的语言自右至左近栈,总是处理栈顶字符,由第二条规则知遇开括号时,字母逐一出栈顺序入队列,闭括号出现时,按规则要求逐一出队列处理后再入栈。

2.设计过程软件程序主要通过一个主函数实现,执行主函数过程中再分别调用各部分子函数,各个子函数分别实现判断栈(队列)是否为空,进栈(队列),出栈(队列)。

①图1表示的是主函数的流程图图1主函数流程图②图2表示的是进栈之前判断栈是否为空,当栈顶指针和栈底指针指同一位置时,栈为空,图2判断栈是否空③图3表示的是进栈的流程图,输入魔王语言时将其从右至左进栈,并始终处理栈顶元素,其中难点在于对开括号和闭括号的不同处理,当遇开括号时,字母逐一出栈顺序入队列,闭括号出现时,按规则要求逐一出队列处理后再入栈。

图3进栈流程图④图4 表示的是出栈流程图,出栈时也需判断栈是否为空,若非空即从栈顶元素开始出。

图4出栈流程图⑤图5 表示的是判断队列是否为空的流程图,判断条件也是看其头指针与尾指针是否重合。

图5判断队列是否空⑥图6 表示的是入队列的流程图,入队列时从队尾入。

图6入队列流程图⑦图7表示的是出队列流程图,在队列不为空的前提下,从对头开始出。

图7出队列流程图3.调试过程及实验结果调试过程error C2440: '=' : cannot convert from 'char' to 'char *' Conversion from integral type to pointer type requires reinterpret_cast, C-style cast or function-style cast执行 cl.exe 时出错.改正:在char后加*实验结果输入魔王语言即出现翻译过来的人类语言,如下图所示:图7实验结果4.结论通过一周的软件实习,使我对c语言及软件部分的知识都有了更深一步的了解,在实习过程中我的动手能力得到了锻炼和提高,也增强了解决问题的能力,同时也激发了我对软件知识学习的兴趣。

魔王语言解释

魔王语言解释
基本操作:
initstack (&s)
操作结果:构造一个空栈s.
push (&s,e)
初始条件:栈s已存在.
操作结果:在栈s的栈顶插入新的栈顶元素e.
pop(&s,&e)
初始条件:栈s已存在.
操作结果:删除s的栈顶元素,并以e返回其值.
}ADT stack
2:设定队列的抽象数据类型:
ADT queue{
(2)A -> sae
[测试数据]
B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae
若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
t d s a e z g x n h
天 地 上 一只 鹅 追 赶 下 蛋 恨
do
{
i++;
c=demon[i ];
push(temps,c)/*第一次循环将次字母入栈*/;
push(temps,t);/*再将首字母进栈*/
}
while(c!=')');/*直到括号中元素全部进栈*/
pop(temps,&t);/*将多余进栈的首字母t出栈*/
pop(temps,&t); /*将多余进栈的’)’出栈*/
default:strcpy(a,"???"); /*不能翻译的魔王语言以”???”输出*/
}
while(a[j]!='\0') /*如果数组还有字母*/
{
enqueue(q,a[j]);/*进队*/
j++;
}
}/*特殊入队*/
6.排序入队处理函数

DS_上机实验的目的、要求和评分标准

DS_上机实验的目的、要求和评分标准

上机实验的目的、要求和评分标准一、实验目的上机实践是各位对本门课程所学知识的一种全面、综合的能力训练,是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节,也是对课堂教学与实践教学效果的一种检验。

通常,实验题中的问题比平时的习题复杂得多,也更接近实际。

实验着眼于原理与应用的结合,使你们学会如何把书上学到的知识运用于解决实际问题的过程中去,培养从事软件开发设计工作所必需的基本技能;另一方面,能使书上的知识变“活”,起到深化理解和灵活掌握教学内容的目的。

平时的练习较偏重于如何编写功能单一的“小”算法,而实验题是软件设计的综合训练,包括问题分析(需求分析)、总体结构设计和用户界面设计(概要设计)、程序设计基本技能和技巧等,即一整套软件工程规范的训练和科学作风的培养。

此外,还有很重要的一点是:机器是比任何教师都严厉的主考者。

为了达到上述目的,本课程共安排了10个实验单元,各单元的训练重点在于基本的数据结构,而不强调面面俱到。

各实验单元与教科书的各章具有紧密的对应关系。

二、要求:⒈做好每一次上机前的准备以提高上机效率:①预先认真阅读相关实验内容,做到心中有明确的目的要求和任务,要有备而来,应该自己独立的思考和设计你的算法和程序,并争取在规定的时间内如期完成上机工作任务。

对于个别目前基础较差的同学,实在是没法完成任务的建议你先参考其他同学的算法,勤学好问,最终自己独立完成,以增强你的感性认识,强化你的实践基础,提高你的实践能力。

②按照实验内容规定的习题题目,事先在实验预习报告上编写好源程序及运行程序所需的典型数据,并经人工静态检查认为无误;手编程序应书写整齐,应在每个题目之间留出一定的空间,以备记录上机调试情况和运行结果等;对程序中自己有疑问的地方,应作出记号,以便上机时给以注意。

③将想要上机验证的问题草拟提纲;制定一个简捷的程序调试计划。

⒉上机时输入和调式自己所编写的程序。

对“出错信息”,应善于自己分析判断,并充分利用开发工具提供的错误信息和调试手段解决出现的问题,及时修改与完善算法、源程序,随时记录有价值的内容。

魔王的语言

魔王的语言

魔王语言实习报告题目:编制一个解释魔王语言的程序完成日期2012.11.13一、需求分析(1)魔王语言有两条规则规则1可以由用户自己确定存储于expression[26[[6]中(每个魔王词汇最多只能转换成5个人类语言,规则2则为(@a(1)a(2)a(3)a(4)…..a(n))->(@a(n)@a(n-1)…@a(1)@)(2) 演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后由用户在键盘上输入演示程序中规定的运算命令;相应的输入数据(滤去输入中非法的字符)和运算结果显示在其后(3) 程序执行的命令为:a.创建魔王语言规则;b.输入魔王语言;c.解释魔王语言。

(4) 测试数据为:默认规则 1 魔王语言:B(ehnxgz)B 解释后:tsaedsaeezegexenchetsaedsae自定义规则1 A=aaa B=bbb C=ccc 其他为0 魔王语言:B(AC)B解释后为:bbbaaacccaaabbb二、概要设计1.栈的抽象类型数据定义ADT Stack{数据对象:D={ai|ai∈ElemSet, i=1,2, …,n, n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D, i=1,2, …,n }约定an端为栈顶,a1端为栈底。

InitStack( &S )操作结果:构造一个空栈S。

初始条件:栈S已存在。

GetTop( S, &e )初始条件:栈S已存在且非空。

操作结果:用e返回S的栈顶元素。

Push( &S, e )初始条件:栈S已存在。

操作结果:插入元素e为新的栈顶元素。

Pop( &S, &e )初始条件:栈S已存在且非空。

操作结果:删除S的栈顶元素,并用e返回其值。

}ADT Stack(2).本程序包含2个模块1)主程序模块:void main() {初始化;do{接受命令;处理命令;}while(“命令”=“退出”);}2)栈的构造模块三.详细程序#include<stdio.h>#include<stdlib.h>#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OK 1#define OVERFLOW -1;#define ERROR 0#define MAXSIZE 100typedef struct{int* st,*end;int size;}SqStack;int InitStack(SqStack &S) //建立一个栈{S.st=(int *)malloc(STACK_INIT_SIZE * sizeof(int));if(!S.st){//exit(OVERFLOW);}S.end=S.st;S.size=STACK_INIT_SIZE;return OK;int SGetTop(SqStack S,int &e) //用e返回S的栈顶元素if(S.st==S.end)return ERROR;e=*(S.st-1);return OK;}int SPush(SqStack &S,int e) //插入元素e为新的栈顶元素{if(S.st-S.end>=S.size){S.end=(int *)realloc(S.end,(S.size+STACKINCREMENT)*sizeof(int));if(!S.end){//exit(OVERFLOW);}S.st=S.end+S.size;S.size+=STACKINCREMENT;}*S.st++=e;return OK;}int SPop(SqStack &S,int &e) //删除S的栈顶元素,用e返回其值{if(S.st==S.end)return ERROR;e=*--S.st;return OK;}void print(char x) //将小写英文转化成汉字{if(x=='A')printf("上一只鹅");else if(x=='B')printf("天上一只鹅地上一只鹅");else if(x=='t') printf("天");else if(x=='d') printf("地");else if(x=='s') printf("上");else if(x=='a') printf("一只");else if(x=='e') printf("鹅");else if(x=='z') printf("追");else if(x=='g') printf("赶");else if(x=='x') printf("下");else if(x=='n') printf("蛋");else if(x=='h') printf("恨");}int main(){int temp,i,j;char ch[1000];printf("请输入魔王的语言:");scanf("%s",ch);{for(i=0;ch[i];i++){if(ch[i]=='('){if(ch[i+1]==')') //如果只出现(),则跳过{i=i+1;continue;}char LL=ch[i+1]; // 把LL指向括号后的位置SqStack s;InitStack(s);for(j=i+2;ch[j]!=')';j++){SPush(s,ch[j]); //将元素逐一入栈}i=j;while(SGetTop(s,temp)){print(LL); //输出LLprint(temp); //将元素逐一出栈并输出SPop(s,temp);}print(LL); //再次输出LL}else{print(ch[i]); //输出括号外的}}printf("\n");}return 0;}四、调试分析1.在编程过程中对设计做了如下修改:(1)在输出时,对括号中的内容先记录第一个字符,每次出栈的时候,先输出记录的字符,再输出出栈的字符。

混世魔王_混世魔王的意思_成语词典

混世魔王_混世魔王的意思_成语词典
例子
多谢戮力同心,拽倒十余年混世魔王。(《晚清文学丛钞·新罗马·会议》)
英文翻译
devil incarnate <fiend in human shape; the god of this world>
谜语
樊瑞
产生年代
古代
常用程度
常用
请确保付费时的浏览器及电脑和复制文章时所用的浏览器是一样的
混世魔王
拼音
hùn shì mó wáng
简拼
hsmw
近义词
纨绔子弟
反义词
感情色彩
贬义词
成语结构
偏正式
成语解释
比喻扰乱人世的凶人或骄纵恣肆的人
成出处
清·曹雪芹《红楼梦》第三回:“我有一个孽根祸胎,是家里的混世魔王。”
成语用法
偏正式;作主语、宾语;含贬义

魔王语言程序

魔王语言程序

/*maintest.cpp魔王语言解释程序主测试文件,文件FiendTranslater 中自定义了一个魔王语言解释类及其实现,LastModified:---*/#include <iostream>/*文件名:base基本数据结构类的定义和实现: MyStack ,MyPoint,MyArc,Graph,MyQueues MyStack为构造的一个通用的C++模版堆栈类;MyPoint为一个坐标结构MyArc为带权的边类Graph为临街矩阵表示的图MyQueues为按权值顺序存储的边的队列LastModified:---*/#define BASE_H#include<list>using namespace std;/*MyStack 堆栈类的结构[ 0 1 ... curlen ... size][栈底(bottom) ... prt ... ]*/#define BASESIZE 64 //默认堆栈数组空间大小(8*8),可以自扩充template <class Type>class MyStack{private:Type *bottom; // 元素存放的动态数组int size,ptr; // 堆栈大小和当前栈顶元素索引public://构造函数MyStack(){bottom=new Type[BASESIZE];ptr=-1;size=BASESIZE;};//析构函数~MyStack(){delete []bottom;};//清栈还原inline void clear(){if(bottom!=NULL)delete []bottom;bottom=new Type[size];ptr=-1;};//判栈空inline bool IsEmpty(){if(ptr==-1) return true;else return false;}//入栈int push(Type e);//出栈int pop(Type &e);//获得栈顶元素int top(Type &e);int settop(Type e);// 用callback函数对栈从低向上遍历void traverse(void callback(Type *),Type *);private:inline int extent(){int s=size;Type *temp=new Type[size];for(int i=0;i<s;i++)temp[i]=bottom[i];size*=2;clear();ptr=s+1;for(int j=0;j<s;j++)bottom[j]=temp[j ];delete [] temp;return size;}};/*MyStack的实现*//*压栈*/template <class Type>int MyStack<Type>::push(Type e) //{if(++ptr==size) extent();bottom[ptr]=e;return ptr;}/*出栈*/template <class Type>int MyStack<Type>::pop(Type &e) //{if(ptr==-1)return -2;//栈空,返回-2 !elsee=bottom[ptr--];return ptr;}/*获取栈顶元素*/template <class Type>int MyStack<Type>::top(Type &e) //{if(ptr==-1)return -1;//栈空,返回-1 !elsee=bottom[ptr];return ptr;}/*设置栈定元素*/template <class Type>int MyStack<Type>::settop(Type e) //{if(ptr==-1)return -1;//栈空,返回-1 !elsebottom[ptr]=e;return ptr;}/*用callback函数对栈从低向上遍历*/template <class Type>void MyStack<Type>::traverse(void callback(Type *),Type *e) {if(callback!=NULL){for(int i=0;i<=ptr;i++){e=&bottom[i];callback(e);}}}; ///*MyPoint 坐标结构*/typedef struct MyPoint{int x, y;} *pMyPoint;///*表示边的类*/class MyArc{public:int m_beginV ex;int m_endV ex;int m_weight;MyArc(int beginV ex,int endV ex,int weight);MyArc(){}bool operator < (const MyArc& arc){return m_weight<arc.m_weight;}bool operator == (const MyArc& arc){return m_weight==arc.m_weight;}bool operator > (const MyArc& arc){return m_weight>arc.m_weight;}};MyArc::MyArc(int beginV ex,int endV ex,int weight):m_beginV ex(beginV ex),m_endV ex(endV ex),m_weight(weight){}/*用邻接矩阵表示的图类,可以带权,权不可以为0*/class Graph{public:int m_vexnum;int m_arcnum;int *m_pmatrix;public:~Graph();Graph(int vexnum);Graph(int vexnum,int *pmatrix);void insert(MyArc arc);//按权值大小排序插入bool bound(int x); //判断顶点x是否已与其它顶点连通};//构造函数Graph::Graph(int vexnum){m_pmatrix=new int[vexnum*vexnum];m_vexnum=vexnum;m_arcnum=0;for(int i=0;i<vexnum*vexnum;++i) m_pmatrix[i]=0;}//构造函数Graph::Graph(int vexnum,int *pmatrix)m_vexnum=vexnum;// m_arcnum=arcnum;m_pmatrix=new int[m_vexnum*m_vexnum];for(int i=0;i<m_vexnum*m_vexnum;++i)m_pmatrix[i]=pmatrix[i];}//测试顶点x是否已与其他点连通bool Graph::bound(int x){for(int i=0;i<m_vexnum;++i) if(m_pmatrix[x+i*m_vexnum]!=0) return true;return false;}//在邻接表中连通arc表示的边,并且设置权void Graph::insert(MyArc arc){m_pmatrix[arc.m_beginV ex*m_vexnum+arc.m_endV ex]=arc.m_weight;m_pmatrix[arc.m_endV ex*m_vexnum+arc.m_beginV ex]=arc.m_weight;++m_arcnum;}Graph::~Graph(){delete[] m_pmatrix;}/*自定义队列,用于存放连通图,或按权排列后的边*/class MyQueues{public:list<MyArc> m_list;MyQueues(){}void insert(const MyArc& arc);//边按权值插入队列中合适位置,void InsertGraph(const Graph &graph);//将图的连通分量插入队列MyArc pop();};//边出队MyArc MyQueues::pop()MyArc arc=m_list.front();m_list.pop_front();return arc;}//边按权值插入队列中合适位置,void MyQueues::insert(const MyArc& arc){list<MyArc>::iterator pos=m_list.begin();while(pos!=m_list.end()){if(*pos>arc) break;else ++pos;}m_list.insert(pos,arc);}//将图的连通分量插入队列void MyQueues::InsertGraph(const Graph &graph){for(int i=0;i<graph.m_vexnum;++i){for(int j=i+1;j<graph.m_vexnum;++j)if(graph.m_pmatrix[i*graph.m_vexnum+j]) insert(MyArc(i,j,graph.m_pmatrix[i*graph.m_vexnum+j]));}}/*-------------------------------------------------文件名:FiendTranslater魔王语言解释类的定义和实现文件base 是自定义数据结构的定义和实现文件LastModified:-----------------------------------------------------类名:FiendTranslater属性:私有接口:公有接口:*/#define FIENDTRANSLA TER_H#include <string>/*声明全局宏,常量,变量,函数*/#define MAXV ARNUM 20 //定义变量个数的最大值class FiendTranslater{private:char cV AR[MAXV ARNUM]; //终结符和非终结符变量char *cV AREXPR[MAXV ARNUM]; //指针数组,cV AR[]中各字符表达式char *cV AREXPEND[MAXV ARNUM]; //指针数组,cV AR[]中各字符的完全展开char *cWords; //翻译后的话int iFlag[MAXV ARNUM]; //cV AR[]中各字符是否完全展开的标志;int ptr ; //已用变量个数-1bool bIsExpended; //所有变量是否已翻译完成bool Expend(); //将各变量字符展开,获得cV ARTEXPEND[]int Solve(char[]); //翻译的核心算法public:FiendTranslater();~FiendTranslater();int GetPtr(); //返回当前游标void Reset(); //重置int AddExpr(char,char[],int len); //添加表达式bool GetExpr(char &ch,char [],int i); //获取下标为i的表达式int Translate(char[],char []); //获取翻译后的话};/*FiendTranslater类的方法*///构造函数FiendTranslater::FiendTranslater(){for(int i=0;i<MAXV ARNUM;i++)//初始化iFlag[];未使用位为-1;未展开位为表达式长度len;已展开位为-2;//同时初始化2个指针数组{iFlag[i]=-1;cV AREXPR[i]=NULL;cV AREXPEND[i]=NULL;}ptr=-1;bIsExpended=false;cWords=NULL;}//析构函数FiendTranslater::~FiendTranslater(){for(int i=0;i<=ptr;i++)//删除申请的内存空间{delete []cV AREXPR[i];if(cV AREXPEND!=NULL)delete []cV AREXPEND[i];}}//int FiendTranslater::GetPtr(){return ptr;}//重置函数void FiendTranslater::Reset(){for(int i=0;i<=ptr;i++)//删除申请的内存空间{delete []cV AREXPR[i];if(cV AREXPEND!=NULL)delete []cV AREXPEND[i];}for(int j=0;j<MAXV ARNUM;j++)//初始化iFlag[];未使用位为-1;未展开位为表达式长度len;已展开位为-2;//同时初始化2个指针数组{iFlag[j]=-1;cV AREXPR[j]=NULL;cV AREXPEND[j]=NULL;}ptr=-1;if(cWords!=NULL)delete []cWords;cWords=NULL;bIsExpended=false;}//添加表达式int FiendTranslater::AddExpr(char ch,char exp[],int len){ptr++;if(ptr>=MAXV ARNUM)//变量个数已达最大值,不能再添加{ptr--;return -1;}cV AR[ptr]=ch;cV AREXPR[ptr]=new char[len+1];cV AREXPR[ptr][len]=NULL;strcpy(cV AREXPR[ptr],exp);iFlag[ptr]=len;return ptr;}//获取已存在的表达式bool FiendTranslater::GetExpr(char &ch,char chexpr[],int index){if(index>ptr||index<0)return false;ch=cV AR[index];strcpy(chexpr,cV AREXPR[index]);return true;}//bool FiendTranslater::Expend(){if(ptr==-1)//无表达式return false;int lastunexpend=0,currunexpend=0;for(int index=0;index<=ptr;index++)//先找出终结符,{if(iFlag[index]==-2)//已处理,到下一个continue;for(int i=0;i<iFlag[index];i++)//判断第index个表达式是不是终结符的表达式{if(cV AREXPR[index][i]>='A'&&cV AREXPR[index][i]<='Z')//含有变量则跳出break;}if(i>=iFlag[index])//是终结符{currunexpend++;cV AREXPEND[index]=new char[iFlag[index]+1];cV AREXPEND[index][iFlag[index]]=NULL;strcpy(cV AREXPEND[index],cV AREXPR[index]);iFlag[index]=-2;}}//找终结符完毕lastunexpend=ptr+1-currunexpend;currunexpend=lastunexpend;//while(1)//展开非终结符{if(currunexpend==0)//都已经展开break;lastunexpend=currunexpend;for(int index=0;index<=ptr;index++)//for 1.一趟扫描{if(iFlag[index]==-2)//已处理,到下一个continue;else//*cV AREXPR[index]指向的表达式未处理,其长度为iFlag[index]{for(int i=0;i<iFlag[index];i++)//for 2. 先扫描表达式内的变量是否都已展开{if(cV AREXPR[index][i]>='A'&&cV AREXPR[index][i]<='Z')//表达式内有变量,查表{char ch=cV AREXPR[index][i];for(int j=0;j<=ptr;j++)//for 3.查表循坏{if(ch==cV AR[j])//查到,则跳出3break;}if(j>ptr||iFlag[j]!=-2)//字符cV AREXPR[index][i]未查到或还未展开,则跳出2,不用再扫描下一个字符break;}}if(i>=iFlag[index])//cV AREXPR[index][]内部所有变量都可以展开,进行展开{char cTemp;MyStack<char> sExp;//表达式字符栈for(int i=iFlag[index]-1;i>=0;i--)//对表达式字符串从右向左入栈sExp.push(cV AREXPR[index][i]);char ch[256]={0};//临时存放展开式用while(sExp.pop(cTemp)!=-2)//展开{if(cTemp>='A'&&cTemp<='Z')//处理变量{for(int i=0;i<=ptr;i++)//查表{if(cTemp==cV AR[i]){strcat(ch,cV AREXPEND[i]);break;}}}else//非变量{char a[2]={0};a[0]=cTemp;strcat(ch,a);int mm=0;}}//end whileint len=strlen(ch);cV AREXPEND[index]=new char[len+1];cV AREXPEND[index][len]=NULL;strcpy(cV AREXPEND[index],ch);currunexpend--;}//end if(i>=iFlag[index])}//end else}//end for 1.if(currunexpend==lastunexpend)//一趟下来没有展开一个变量break;//说明剩下的都不可以展开了,跳出while(1);}//end while(1)if(currunexpend!=0)//仍有不可展开的,则返回falsereturn false;else//全部变量展开成功{bIsExpended=true;return true;}}//翻译int FiendTranslater::Solve(char words[]){if(bIsExpended==false)//还有变量未展开return -1;char cTemp;MyStack<char> sWords,sBracket;//存放魔王原话和括号内话的栈int len=strlen(words);for(int i=len-1;i>=0;i--)//从右i至左入栈sWords.push(words[i]);char ch[512]={0};//临时存放翻译后的话while(sWords.pop(cTemp)!=-2){if(cTemp>='A'&&cTemp<='Z')//遇到变量{for(int i=0;i<=ptr;i++)//查表{if(cTemp==cV AR[i]){strcat(ch,cV AREXPEND[i]);break;}}//结束查表if(i>ptr)//该变量未查到return -2;}//end ifelse if(cTemp=='(')//遇到左括号,使用规则(2){char cFirst;sWords.pop(cFirst);//记录第一个字符while(sWords.pop(cTemp)!=-2&&cTemp!=')'){sBracket.push(cFirst);sBracket.push(cTemp);}sBracket.push(cFirst);while(sBracket.pop(cTemp)!=-2)//while 2.处理括号栈中字符和变量{if(cTemp>='A'&&cTemp<='Z')//括号中遇到变量{for(int i=0;i<=ptr;i++)//查表{if(cTemp==cV AR[i]){strcat(ch,cV AREXPEND[i]);break;}}//查表结束if(i>ptr)//该变量未查到return -2;}else//非变量{char a[2]={0};a[0]=cTemp;strcat(ch,a);}}//end while 2.括号处理完毕}//end if else,继续else//非变量,非括号{char a[2]={0};a[0]=cTemp;strcat(ch,a);}}//end whilelen=strlen(ch);cWords=new char[len+1];cWords[len]=NULL;strcpy(cWords,ch);return 1;}//返回翻译后的话int FiendTranslater::Translate(char in[],char ret[]){if(Expend()==false){ret=NULL;return -1;//变量未全展开}int i=Solve(in);if(i==-1){return -1;//不能翻译出来,有未展开变量}if(i==-2){return -2;//原话中有无知变量}strcpy(ret,cWords);return 1;//正确}using namespace std;char cV AR,cEXP[256]={0},cWords[256]={0};void UI_Header(){cout<<"***********魔王语言解释系统*************"<<endl;cout<<"*该系统由基于堆栈的自定义的魔王语言解释类实现的*"<<endl;cout<<"************************************************"<<endl<<endl;cout<<"语言规则:\n"<<"1.α->β1β2...βn ;\n2.(θδ1δ2...δn)->θδnθn-1 (2)δ1θ;\n\n";}void UI_Body(){cout<<"\n\n-------功能选项--------\n";cout<<"1.添加变量规则\n"<<"2.查看已有的变量及其表达式\n"<<"3.输入魔王的话并翻译\n"<<"4.清除所有已输入的规则\n"<<"5.退出\n"<<"请输入序号:";}void UI_End(){cout<<"BYE!"<<endl;}void main(){FiendTranslater fi;char p[256]={0};UI_Header();char i;while(1){UI_Body();cin>>i;if(i<'1'||i>'5')continue;if(i=='1'){cout<<"\n----开始添加变量规则----\n";cout<<"请输入变量名(一个大写字母):";cin>>cV AR;cout<<"\n请输入该变量表达式:";cin>>cEXP;fi.AddExpr(cV AR,cEXP,strlen(cEXP));continue;}if(i=='2'){cout<<"-----已存在的变量表达式------\n";char ch,cexp[256]={0};int iNumOfExpr=fi.GetPtr();for(int j=0;j<=iNumOfExpr;j++){fi.GetExpr(ch,cexp,j);cout<<j<<":"<<ch<<"->"<<cexp<<endl;}continue;}if(i=='3'){cout<<"\n----输入魔王的话并翻译----";cout<<"\n请输入魔王的话:";cin>>cWords;int m=fi.Translate(cWords,p);if(m==-1){cout<<"提示:变量规则中含有不可解析的变量或者含有递归表达式或者没有规则存在,请输入完整\n";continue;}else if(m==-2){cout<<"提示:魔王的话中含有不可解析的变量,请保证所有规则都已正确输入;\n";continue;}else{cout<<"魔王的话:"<<cWords<<endl;cout<<"翻译后:"<<p<<endl;cout<<"提示:已成功翻译!"<<endl;continue;}}if(i=='4'){fi.Reset();continue;}else{UI_End();break;}}}。

魔王语言解释

魔王语言解释

实习报告题目:编制一种魔王语言解释旳程序班级:06052711 姓名:曹旭学号:06057104 完毕日期:.11.27一、需求分析[问题描述]有一种魔王总是使用自己旳一种非常精练而抽象旳语言发言,没人能听旳懂。

但他旳语言是可以逐渐解释成人能懂得语言旳,由于他旳语言是由如下两种形式旳规则由人旳语言逐步抽象上去旳:(1)α->β1β2...βn(2)(θδ1δ2...δn)->θδnθδn-1...θδ1θﻫ在这两种形式中,从左到右均表达解释;从右到左表达抽象。

试写一种魔王解释系统,把他旳话解释成人能听懂得话。

[基本规定] ﻫ用下述两条具体规则和上述规则形式(2)实现。

设大写字母表达魔王语言旳词汇;小写字母表达人旳语言词汇;希腊字母(a,b1,s,y1等)表达可以用大写或小写字母代换旳变量。

ﻫ魔王语言可含人旳词汇。

(1)B->tAdA(2) A->sae[测试数据]B(einxgz)B解释成tsaedsaeezegexeneietsaedsae若将小写字母与中文建立下表所示旳相应关系,则魔王说旳话是“天上一种鹅地上一种鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一种鹅地上一种鹅。

” ﻫt d s a ez G x n iﻫ天地上一种鹅追赶下蛋恨[实现提示]将魔王旳语言自右至左进栈,总是解决栈顶。

若是开括号,则逐个出栈,将字母顺序入队ﻫ列,直至闭括号出栈,并按规则规定逐个出队列再解决后入栈。

其他情形较简朴,请读者思考如何解决,应一方面实现栈和队列旳基本运算二、概要设计为实现上述程序功能,应以栈和队列来表达。

1.设定栈旳抽象数据类型定义为:ADTStack{ ﻫ数据对象:D={ai| ai∈CharSet,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |ai-1,ai∈D,I=1,2,......,n}基本操作: ﻫListInitiate (&S) ﻫ操作成果:构造一种空栈S。

魔王语言解释

魔王语言解释

1、绪论1.1 背景随着网络技术的发展,网络安全变得越来越重要,文件加密是其中一个重要部分。

而“魔王语言”就是一个简单的文件加密。

“魔王语言”就是有一个魔王总是使用自己的一种非常精练而又抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是有规则的,可以通过相应的规则来解释。

1.2研究目的通过这次设计,要求在数据结构逻辑特性和物理分析、数据结构的选择和应用、算法的设计及其实现等方面,加深对基础知识的理解。

同时,在程序设计方法以及上机造作等基本技能方面受到严格的训练。

2、需求分析2.1 题目魔王语言解释。

2.2 基本要求魔王的话没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,有着下面的基本要求:用下述两条具体规则和下述规则形式2)实现。

设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

以下是他的语言的两种形式的规则有语言逐步抽象上去的:1)α 转换为β1β2…βm2)(θδ1δ2…δn)转换为θδnθδn-1… θδ1θ在这两种形式重,从左到右均表示解释。

试写一个魔王语言的解释兄,把他的话解释成人能听得懂的话。

因此,我们编写了一个有趣的魔王语言解释程序来巩固和加强对栈和队列的理解。

以下是他的语言的两种形式的具体规则:⑴B 转换为他tAdA,A 转化为sae.⑵t转化为”天”, d转化为"地",s转化为"上",a转化为"一只",e转化为"鹅",z转化为"追",g转化为"赶",x转化为"下",n转化为"蛋",h转化为”恨”. 2.3数据测试B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:”天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”2.4实现分析⑴以一维数组demon[ i ]表示魔王语言.⑵魔王语言由用户输入,初始保存在demon[ i ]中.⑶魔王语言与人类语言对应关系固化在程序中.2.5实现过程⑴初始,魔王语言接收后存放在demon[ i ]中.⑵遍历数组,将数组中括号内的元素入栈,同时插入相应首字母;⑶再次遍历数组,将数组元素依次入队。

魔王语言翻译

魔王语言翻译

魔王语言翻译
要求:
传说有一个魔王使用自己的语言说话,没人能够听得懂他的语言。

后来从外国来了一位智者,他发现魔王的语言能够逐步翻译成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的。

(1)123αββββ→…
(2)
123n n n -1θδδδδθδθδθδθ→(…)… 上面的规则中,从左到右表示将魔王语言翻译成人类的语言。

魔王语言和人类的语言按照该语法的规则进行转换。

设大写字母表示魔王语言词汇,小写字母表示人类语言词汇。

上述的希腊文法式中,希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可以包含人类的词汇。

(1)B tA d A →
(2)A sa e →
编写一个魔王语言的翻译系统,把魔王的话翻译成人类的语言。

eg:
B 的解释为:tsaedsae
AB 的解释为:saetsaedsae。

demon和devil用法

demon和devil用法

demon和devil用法
demon和devil是两个单词,常常被人们混淆使用。

尽管它们的字面意义相似,都与邪恶和邪恶势力有关,但它们在实际用法中还是存在一些差异。

首先,demon(恶魔)是一种超自然生物的称呼,在许多文化和宗教中都有不
同的解释。

在一些宗教信仰中,恶魔被描述为天使堕落后的形象,代表着邪恶、罪恶和破坏。

然而,在比喻意义上,demon也可以用来形容人类行为中的邪恶、自私或有害部分。

例如,我们可能会说某人的内心充满了恶魔,意思是他们在某方面有不可原谅或不道德的行为。

与此相反,devil(魔鬼)通常指地狱之王或在基督教中代表邪恶的形象。

魔鬼
被认为是撒旦的代称,他作为上帝隐喻中的对立力量而存在。

魔鬼一般被描述为反上帝的存在,引诱人类堕落和犯罪。

在日常用语中,devil通常用来形容一个非常
邪恶的人或行为。

我们可能会说某人是一个“魔鬼”,以强调他们的危害性和邪恶程度。

综上所述,尽管demon和devil都与恶魔或邪恶有关,但它们在使用时仍具有
一些细微的差异。

demon更多的是指恶魔及其邪恶属性的一般化表达,而devil则
更加具体地指代基督教中的邪恶形象。

无论是在文学作品、宗教信仰还是日常用语中,我们都可以根据具体的背景和语境来明确使用这两个词语。

恶魔??[èmó]什么意思?近义词和反义词是什么?英文翻译是什么?

恶魔??[èmó]什么意思?近义词和反义词是什么?英文翻译是什么?

恶魔[èmó]什么意思?近义词和反义词是什么?英文翻译是什
么?
恶魔[è mó]
[恶魔]基本解释
1.佛教语。

障碍佛法的恶神的总称
2.比喻非常凶恶的人
[恶魔]详细解释
1.佛教语。

障碍佛道的恶神的总称。

《圆觉经》:“无令恶魔及诸外道恼其身心。


2.比喻极会害人的事物。

极为凶恶的人。

闻一多《你看》:“朋友,乡愁最是个无情的恶魔。

” 闻捷《大宝眼睛合不拢》:“ 大宝大宝怎么办?你可敢挺身战恶魔?”
[恶魔]百科解释
Devil又被译作魔鬼,是各种宗教、文学作品、影视作品、ACG作品中虚构的拥有超自然力量的邪恶存在,通常是特别强大的魔鬼。

人心所浮现的恶意即是恶魔。

当人类遭遇到自然力量的威胁、自己或者他人的恶意,自然而然会去寻找其源头。

而这些造成恶意的原因,被具体化形成了邪灵、恶神,甚至到最后形成了所谓的恶魔。

人类文化早期的泛灵论(Animi *** )时代,并没有恶魔的存在,但是,强调唯一真神的基督宗教(包含天主教在内)均将异教神祇视为恶魔,以否定其神格的存在,就连旧约圣经里的撒旦(Satan)也是神忠实的仆役。

到了新约圣经以后的时代,唯一真神的信仰已然确立,无需再去贬抑异教神祇,因而创造出作为神的敌对者的堕落天... 更多→ 恶魔
[恶魔]英文翻译
Devil
[恶魔]近义词
邪魔魔鬼
[恶魔]反义词
天使
[恶魔]相关搜寻
恶魔的魔的四字成语。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构课程设计报告题目:魔王语言解释院系:信息学院班级:信管11-2姓名:王裕辰学号:1101051024指导教师:张晓庆实习报告:魔王语言解释题目:魔王语言的解释班级:信管11-2 姓名:王裕辰学号:1101051024 完成日期:2012-5-30一、需求分析1、问题重述有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听得懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2…βm(2)(θδ1δ2…δn)→θδnθδn-1…θδ1θ在这两种形式中,从左到右均表示解释。

试写一个魔王语言的解释系统,用下述两条具体规则和上述规则形式(2)实现,把他的话解释成人能听得懂的话。

(1)B→tAdA(2)A→sae设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。

魔王语言可含人的词汇。

2、问题分析从左至右依次读入待翻译的字符串,根据读入字符的不同做出不同的操作。

如果读到的是大写字母,则以上述规则转换输出;如果读到的是小写字母则直接输出;如果读到的是开括号,则依次入栈,直到读到比括号后,依次将栈中元素入队列。

然后根据规则(2)将队列中的字符转换。

最后将翻译后的字符串输出。

3、测试数据B(ehnxgz)B解释成:tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。

二、概要设计为了实现上述过程应分别构造栈和队列为存储结构。

1、设定栈的抽象数据类型定义:ADT Stack{数据对象:D={ai|ai∈ElemSet,i=1,2,…,n,n>=0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,…,n}基本操作:Initstack (&S)操作结果:构造一个空栈S。

StackEmpty(S)初始条件:栈S已存在。

操作结果:若S为空栈,则返回true,否则false。

ClearStack(&S)初始条件:栈S已存在操作结果:将S清为空栈Push (&S,e)初始条件:栈S已存在。

操作结果:在栈S的栈顶插入新的栈顶元素e。

Pop(&S,&e)初始条件:栈s已存在。

操作结果:删除S的栈顶元素,并以e返回其值。

}ADT Stack2、设定队列的抽象数据类型定义:ADT Queue{数据对象:D={ai|ai∈Elemset,i=1,2,…,n,n>=0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,…,n}基本操作:Initqueue(&Q)操作结果: 构造一个空队列Q。

Enqueue(&Q, e)初始条件: 队列Q已存在。

操作结果: 插入元素e为Q的新的队尾元素。

Dequeue(&Q,&e)初始条件: Q为非空队列。

操作结果: 删除Q的队头元素,并用e返回其值。

}ADT Queue3、本程序包含以下模块(1)主程序模块void main(){初始化栈;初始化队列;接收魔王语言输入到数组demon[];遍历数组将括号中元素进栈;检查魔王语言是否符合翻译语法;while(栈不为空){大写字母存放在临时栈temp中;遇到括号时临时栈temp添加标示“#”,小写字母全部入队列;}(2)魔王语言进栈模块构建栈的存储结构,调用CharInStack(demon[ ],&S)将魔王的语言自右至左进栈,总是处理栈顶元素。

(3)入队列模块构建队列存储结构,用于处理括号内的字符的翻译。

(4)翻译处理模块按照翻译后的字母与汉字的一一对应的原则将翻译后的字符串转换成汉语并输出。

各模块之间的调用关系如下:主程序模块魔王语言进栈模块入队列模块翻译输出模块主函数模块{魔王语言进栈模块;检验模块{入队列模块;}翻译大小写翻译中文处理模块}三、详细设计1、栈类型的定义typedefstruct Stack//栈结构的定义{char* base; //栈底指针char* top; //栈顶指针int size; //栈中元素个数}Stack;//栈类型栈的基本操作如下:void InitStack(Stack &S)//初始化,构造一个空栈Svoid Push(Stack &S,char e)//若分配空间成功,则在S的栈顶插入新的栈顶元素e void Pop(Stack &S,char&e)//若栈不空,则删除S的栈顶元素并以e返回其值boolStackEmpty(Stack s)//若栈为空,则返回true,否则,返回falsevoid ClearStack(Stack &s)//将栈清为空栈void InitStack(Stack &S) //初始化,构造一个空栈S{S.base=(char*)malloc(STACK_INITSIZE*sizeof(char));S.top=S.base;S.size=STACK_INITSIZE;}void Push(Stack &S,char e)//若分配空间成功,则在S的栈顶插入新的栈顶元素e{if(S.top-S.base>=STACK_INITSIZE){S.base=(char*)realloc(S.base,(S.size+STACK_INCREASE)*sizeof(char)); S.top=S.base+S.size;S.size+=STACK_INCREASE;}*(S.top)=e;S.top++;}void Pop(Stack &S,char&e)// 若栈不空,则删除S的栈顶元素并以e返回其值{--S.top;e=*S.top;}boolStackEmpty(Stack s)// 若栈为空,则返回true,否则,返回false{if(s.top==s.base){return true;}else{return false;}}void ClearStack(Stack &s)// 将栈清为空栈{s.top=s.base;}2、队列类型的定义typedefstructQNode//链式队列的定义{char data;QNode* next;}QNode;typedefstructLinkQueue//队列结点的定义{QNode* front; //对头元素QNode* rear; //队尾元素}LinkQueue;//LinkQueue队列的基本操作如下:void InitQueue(LinkQueue&Q)//初始化,构造一个空队列Qvoid EnQueue(LinkQueue&Q,char e)//插入元素e为Q的新的队尾元素voidDeQueue(LinkQueue&Q,char&e)//若队列不为空,则删除Q的对头元素,用e返回其值boolQueueEmpty(LinkQueue Q)//若队列为空队列,则返回true,否则返回false void InitQueue(LinkQueue&Q)//初始化,构造一个空队列Q{Q.front=Q.rear=(QNode*)malloc(sizeof(QNode));Q.front->next=NULL;}void EnQueue(LinkQueue&Q,char e)//插入元素e为Q的新的队尾元素{QNode* temp;temp=(QNode*)malloc(sizeof(QNode));temp->data=e;temp->next=NULL;Q.rear->next=temp;Q.rear=temp;}voidDeQueue(LinkQueue&Q,char&e)//若队列不为空,则删除Q的对头元素,用e返回其值{QNode* temp;temp=Q.front->next;e=temp->data;Q.front->next=temp->next;if(Q.rear==temp)//若出队列后为空{Q.rear=Q.front;}free(temp);}boolQueueEmpty(LinkQueue Q)//若队列为空队列,则返回true,否则返回false {if(Q.front==Q.rear){return true;}else{return false;}}3、主函数和其他函数的伪码算法void main(){//主程序gets(demon);//读入一句魔王语言,放入字符串demon中CharInStack(demon,S);// 将字符串demon中的字符压栈void RStack(Stack &S,Stack&temp); //栈S中的元素出栈,对每个元素进行判断,若出现左括号则将括号内的字符全部放入队列Q中,其它放入栈temp中void CL(Stack &temp,char flag,char key); //处理栈temp中存放的括号中的字符void Translateenglish(Stack S,Queue&Q); // 将栈S中处理后的字符串输出,并将其放入队列Q中void Interpret(Queue Q);// 将队列中所存放的字符串逐个字符的出队列,并将其转换成相应汉字输出}//mainvoid CharInStack(char* ch,Stack&S)//把魔王的语言从右至左压入栈中{inti,k=0;while('\0'!=ch[k]){k++;}for(i=k-1;i>=0;i--){Push(S,ch[i]);}}voidRStack(Stack&S,Stack&temp){ //栈S中的元素出栈,对每个元素进行判断,若出现左括号则将括号内的字符全部放入队列Q中,其它放入栈temp中while(!StackEmpty(S)){Pop(S,e1); //栈S中元素出栈if(e1=='(')//出现左括号,则用队列存储括号中的元素{Push(temp,flag);//用flag标记括号在栈S中出现的位置Pop(S,e1);while(e1!=')')//括号内全部入队列Q{EnQueue(Q,e1);Pop(S,e1);}if(!QueueEmpty(Q))DeQueue(Q,key);//将队列中的第一个元素赋值给key }else if (e1==’A’) //若出现字符A则将其转换成字符串“sae”放入栈temp中{Push(temp,’s’);Push(temp,’a’);Push(temp,’e’);}else if (e1==’B’) //若出现字符B将其转换成字符串“tsaedsae”放入栈temp中{Push(temp,’t’);Push(temp,’s’);Push(temp,’a’);Push(temp,’e’);Push(temp,’d’);Push(temp,’s’);Push(temp,’a’);Push(temp,’e’);}else//非括号中的元素放入栈temp中{Push(temp,e1); }}//此时S栈为空}void CL(Stack &temp,char flag,char key){//处理栈temp中存放的括号中的字符while(!StackEmpty(temp)){Pop(temp,e1);if(e1!=flag)//括号外的元素入栈S{Push(S,e1);}else //括号内的元素即将队列Q中存放的字符放入栈S中{while(!QueueEmpty(Q)){DeQueue(Q,e2);Push(S,key);Push(S,e2);}}}}voidTranslateenglish(Stack S,Queue&Q){// 将栈S中处理后的字符串输出,并将其放入队列Q中while(!StackEmpty(S))//依次出栈输出处理后的元素{Pop(S,e);EnQueue(Q,e);//元素进队是为了输出对应汉字printf("%c",e);}}void Interpret(Queue Q){// 将队列中所存放的字符串逐个字符的出队列,并将其转换成相应汉字输出DeQueue(Q,e);switch(e){case 't': printf("天");break;case 'd' : printf("地"); break;case 's' : printf("上"); break;case 'a' : printf("一只"); break;case 'e' : printf("鹅"); break;case 'z' : printf("追"); break;case 'g' : printf("赶"); break;case 'x' : printf("下"); break;case 'n' : printf("蛋"); break;case 'h' : printf("恨"); break;}}四、测试及分析进入程序后显示提示信息:“请输入你想要解释的魔王语嫣:”即输入相应的字符串测试结果当输入B(ehnxgz)B时,屏幕上显示“解释后的语言为:tsaedsaeezegexenehetsaedsae”“翻译成中文为:天上一只鹅地上一只鹅鹅追鹅鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”程序运行如下图所示:。

相关文档
最新文档