魔王语言解释
《魔王》名词解释
《魔王》名词解释嘿,咱今儿个就来说说“魔王”这个词儿。
你说啥是魔王呀?魔王可不是那种随随便便的角色。
你想想看,魔王就像是游戏里的大 BOSS,超级厉害,超级难对付!他们有着强大的力量和邪恶的心思,总是想尽办法给主角找麻烦,阻碍主角前进的道路。
这不就跟咱生活里那些特别难搞的事儿或者人似的嘛。
魔王通常有着独特的外貌和气质,可能长着狰狞的面容,穿着酷炫又邪恶的服装。
这就好比有些人,光看外表就能感觉出他们不好惹。
他们往那一站,气场就不一样,让人不自觉地紧张起来。
而且魔王都有自己的地盘,在那里他们就是老大,谁都得听他们的。
这跟现实里那些有权有势的人是不是有点像?在他们的地盘上,他们说了算,别人都得小心翼翼的。
魔王还有很多手下,这些手下都对魔王忠心耿耿,为魔王办事儿。
这像不像一些小团体呀,有个带头的,后面跟着一群拥护的。
但是呢,魔王也不是不可战胜的。
就像再难的事儿,只要咱鼓起勇气,想办法,总能找到解决的途径。
那些故事里的英雄不就是这样嘛,面对魔王不退缩,勇往直前,最后总能战胜魔王。
咱生活里也会遇到各种各样的“魔王”,可能是一份很难的工作任务,可能是一段糟糕的人际关系,也可能是自己内心的恐惧和犹豫。
但咱不能怕呀,得像故事里的英雄一样,挺起胸膛去面对。
魔王虽然可怕,但他们也是故事里不可或缺的一部分呀。
没有魔王,那英雄的存在还有啥意义呢?没有挑战,那生活岂不是太无趣了。
所以呀,别害怕魔王,把他们当成是让自己成长的机会。
当你战胜了一个又一个的魔王,你就会变得越来越强大。
到时候再回头看看,那些曾经让你头疼的魔王,也不过如此嘛。
你说是不是这个理儿?反正我是这么觉得的。
魔王就是生活中的那些困难和挑战,咱得勇敢面对,才能成为真正的英雄!。
数据结构 课程设计报告 魔王语言解释
题目:魔王语言解释[问题描述]有一个魔王总是使用自己的一种非常精练而抽象的语言讲话,没有人能听懂,但他的语言是可以逐步解释成人能听懂的语言,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(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
若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是:“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
实现提示:
将魔王的语言自右至左进栈,总是处理栈顶字符。
若是开括号,则逐一出栈,将字母顺序入队列,直至闭括号出栈,并按规则要求逐一出队列在处理后入栈。
其他情形较简单,请读者思考应如何处理。
应首先实现栈和队列的基本操作。
题目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_上机实验的目的、要求和评分标准
上机实验的目的、要求和评分标准一、实验目的上机实践是各位对本门课程所学知识的一种全面、综合的能力训练,是与课堂听讲、自学和练习相辅相成的必不可少的一个教学环节,也是对课堂教学与实践教学效果的一种检验。
通常,实验题中的问题比平时的习题复杂得多,也更接近实际。
实验着眼于原理与应用的结合,使你们学会如何把书上学到的知识运用于解决实际问题的过程中去,培养从事软件开发设计工作所必需的基本技能;另一方面,能使书上的知识变“活”,起到深化理解和灵活掌握教学内容的目的。
平时的练习较偏重于如何编写功能单一的“小”算法,而实验题是软件设计的综合训练,包括问题分析(需求分析)、总体结构设计和用户界面设计(概要设计)、程序设计基本技能和技巧等,即一整套软件工程规范的训练和科学作风的培养。
此外,还有很重要的一点是:机器是比任何教师都严厉的主考者。
为了达到上述目的,本课程共安排了10个实验单元,各单元的训练重点在于基本的数据结构,而不强调面面俱到。
各实验单元与教科书的各章具有紧密的对应关系。
二、要求:⒈做好每一次上机前的准备以提高上机效率:①预先认真阅读相关实验内容,做到心中有明确的目的要求和任务,要有备而来,应该自己独立的思考和设计你的算法和程序,并争取在规定的时间内如期完成上机工作任务。
对于个别目前基础较差的同学,实在是没法完成任务的建议你先参考其他同学的算法,勤学好问,最终自己独立完成,以增强你的感性认识,强化你的实践基础,提高你的实践能力。
②按照实验内容规定的习题题目,事先在实验预习报告上编写好源程序及运行程序所需的典型数据,并经人工静态检查认为无误;手编程序应书写整齐,应在每个题目之间留出一定的空间,以备记录上机调试情况和运行结果等;对程序中自己有疑问的地方,应作出记号,以便上机时给以注意。
③将想要上机验证的问题草拟提纲;制定一个简捷的程序调试计划。
⒉上机时输入和调式自己所编写的程序。
对“出错信息”,应善于自己分析判断,并充分利用开发工具提供的错误信息和调试手段解决出现的问题,及时修改与完善算法、源程序,随时记录有价值的内容。
魔王语言实验报告范文
魔王语言实验报告范文数据结构课程设计报告题目:系部名称:专业名称:班级:学号:学生姓名:指导教师:时间:魔王语言通信工程一、课程设计目的(1)熟练掌握C语言和数据结构的相关操作。
(2)综合应用C语言的知识和数据结构的知识,编写程序,并且对以前所学的知识进行复习。
(3)培养学生独立完成课程设计的能力。
二、课程设计内容1.用带头结点的动态单链表来存储多项式;在此基础上完成多项式乘法运算要求以动态链表为存储结构、使用到查找和排序等操作;在创建多项式的过程中,可以按指数的任意顺序输入,并且可在同一多项式中输入指数相同的多项;在进行乘法操作之前,输出参与操作的两个多项式。
要求输出的多项式按指数降序排列,同指数的多项合并,项数的正负号显示合理。
2.魔王语言有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。
但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2……βm(2)(θδ1δ2……δn)→θδnθδn-1……θδ1θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。
试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。
",读取文件,并统计1.读取文本文件(rule.t某t),将具体规则的对应关系读入数组或链中2.读取文本文件(mean.t某t),将小写字母及其对应的含义读入数组或链表中",处理规则形式(2)按照规则形式(2)处理魔王所说的话。
处理完毕后,对应的解释语句不再含有()。
处理规则形式(1)按照读入的具体规则,对上一步处理的结果进行规则形式(1)的处理,得到魔王所说的话的人类语言结果。
",写结果文件按照所读入的小写字母对应的文字含义,将翻译成的人类语言转换成文字语句,写入文件reult.t某t中。
",读取文件,并统计1.读取文本文件(rule.t某t),将具体规则的对应关系读入数组或链表中2.读取文本文件(mean.t某t),将小写字母及其对应的含义读入数组或链表中",处理规则形式(2)按照规则形式(2)处理魔王所说的话。
魔王语言 实验报告
魔王语言实验报告1. 实验目的本实验旨在探索一种被称为魔王语言的语言现象,并对其进行分析和研究。
2. 实验背景在语言学领域,存在着一种被称为魔王语言的现象。
这种语言以其难以理解和识别的特点而闻名,有时甚至被称为“恶魔之语”。
许多人尝试了解和研究这种语言,希望能揭示其背后的奥秘。
3. 实验过程为了深入了解魔王语言,我们采用了以下步骤进行实验:步骤1:魔王语言文本收集我们首先搜集了大量的魔王语言文本样本。
这些文本来自不同的来源,包括魔王信函、魔法咒语书籍和神秘的古代文献。
我们收集的文本涵盖了不同的主题和语境,以便全面分析魔王语言。
步骤2:文本分析在这一步骤中,我们对收集到的文本进行了详细的分析。
我们注意到魔王语言的特点主要体现在以下几个方面:•字符替换:魔王语言中的字符常常被替换为其他字符,这使得文本变得难以辨认。
例如,字母“A”可能被替换为“@”,字母“E”可能被替换为“3”等等。
•语法变异:魔王语言的语法规则与传统语言不同,存在着一定的变异。
例如,动词可能在句子中出现的位置不同,或者名词和形容词的顺序可能被颠倒。
•隐藏信息:魔王语言中可能隐藏着某种特殊的信息。
这些信息可能需要特定的解密方法才能被识别出来。
步骤3:解码尝试为了解码魔王语言,我们进行了多次尝试。
我们试图根据魔王语言中的规律和特点,找到可能的解码方法。
我们使用了计算机程序进行自动化解码,同时也进行了手动解码实验。
然而,我们未能完全成功地解码魔王语言。
步骤4:结论尽管我们未能完全解码魔王语言,但我们对其进行了深入的分析和研究。
我们发现魔王语言是一种极具挑战性的语言现象,其独特的特点使其难以被理解和解码。
我们相信,进一步的研究和实验将有助于我们更好地理解魔王语言,并揭示其隐藏的奥秘。
4. 实验展望魔王语言作为一种神秘而难以理解的语言现象,仍然有许多待解决的问题。
未来的研究可以从以下几个方面展开:•更多文本样本的收集:收集更多的魔王语言文本样本,以便进行更全面和深入的分析。
魔王语言
西安郵電學院数据结构课程设计报告题目:魔王语言系部名称:通信与信息工程学院专业名称:通信工程班级:通工0905学号:03091183学生姓名:李辉指导教师:王小银时间:2010年11月15日至2010年11月24日一.实验目的(1)通过实验加深对线性表、栈、队列的掌握和应用。
(2)通过实验提高自己整合所学C语言及数据结构知识分析和解决实际问题的能力。
(3)进一步提高自己的编程水平。
二.实验内容及思想(1)问题描述:有一个魔王总是使用自己的一种非常精炼而抽象的语言讲话,没有人能听懂。
但他的语言是可以逐步解释成人能懂的语言的,因为他的语言是由以下两种形式的规则由人的语言逐步抽象上去的:(1)α→β1β2 ……βm(2)(θδ1δ2 ……δn)→θδnθδn-1 ……θδ1 θ在这两种形式中,从左到右均表示解释;从右到左均表示抽象。
试写一个魔王语言的解释系统,把他的话解释成人能听得懂的话。
(2)算法思想:算法主思想:①判断魔王语言大写转换成小写、小写转换成人类语言的规则是否存在,若存在则直接读出并保存在相应的单链表中,若不存在则予以创建并保存在对应的文件中。
②将输入的魔王语言存入字符数组,并逆序入栈利用递归的方法进行去括号操作。
③采用递归法对去完括号后的字符序列进行大写化小写操作。
④将经过③处理后得的小写字母序列利用字符串比较、插入等方法转换成人类语言,并把小写字母序列和翻译后的人类语言保存在result.txt文件中。
去括号思想:定义字符变量temp, 定义flag=0,当flag=1时进行递归。
采用while循环把输入的魔王语言从右自左依次逆序入栈s,当栈s不为空且没遇到右括号时依次出栈s,进栈s1,当遇到右括号时flag=1。
采用while循环元素出栈s1入队q直到遇到左括号,入队结束(左括号不入队),此时temp为左括号后的元素。
然后,当队q不为空时依次出队,令temp和出队元素依次入队s1,将多入队的元素删除一个。
魔王语言程序
/*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;}}}。
成语系列课件模板-混世魔王
成语课件:混世魔王
近义词: 纨绔子弟。
谢谢!
混世魔王 hห้องสมุดไป่ตู้n shì mó wáng
成语课件模板
成语课件:混世魔王
用法: 偏正式;作主语、宾语;含贬义。
成语课件:混世魔王
解释: 比喻扰乱人世的凶人或骄纵恣肆的人。
成语课件:混世魔王
出处: 清·曹雪芹《红楼梦》第三回:“我有一 个孽根祸胎,是家里的混世魔王”。
成语课件:混世魔王
举例: 多谢戮力同心,拽倒十余年~。(《晚清 文学丛钞·新罗马·会议》)。
成语课件:混世魔王
典故:
这些时,被那厮抢了我们许多家伙,捉了 我们许多子孙,教我们昼夜无眠。大王若 再不来,这山洞尽属他人了!”悟空大怒 道:“是什么妖魔,这般无理!你们且细 细道来,待我寻他报仇”。众猴叩头道: “告大王,那厮自称混世魔王,住在直北 下”。
成语课件:混世魔王
典故:
悟空道:“有多少路程?”众猴道:“他 来时云,去时雾,不知道有多少路程”。 悟空道:“你们不要怕,只管在此玩耍, 等我寻他去!” 好悟空,一个筋头跳到半空,去寻那妖魔。 “混世魔王”形容无法无天、穷凶极恶之 徒。 (出自《西游记•第二回》)。
成语课件:混世魔王
典故:
混世魔王 孙悟空武艺学成,告别祖师,驾起筋斗云, 不到一个时辰,就回到了花果山。 悟空按下云头,叫道:“孩儿们, 我回 来了!”那石坎边、花草中、树木里,大 大小小,跳出千万只猴子,把悟空围在当 中,叩头叫道:“大王,你好宽心!怎么 一去这么久?把我们都闪在这里,盼你盼 得饥渴!近来一妖魔在此逞凶,要强占我 们的水帘洞,我们舍死忘生,与他争斗。
魔王语言解释
实习报告题目:编制一种魔王语言解释旳程序班级: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。
课程设计--魔王语言解释
魔王语言解释一目的通过课程设计,巩固和加深对线性表、栈、队列、字符串、树、图、查找、排序等理论知识的理解;掌握现实复杂问题的分析建模和解决方法(包括问题描述、系统分析、设计建模、代码实现、结果分析等);提高利用计算机分析解决综合性实际问题的基本能力。
二需求分析1、输入输出形式输入一个用于表示魔王语言的字符串,用数组存储,输入应该是含有大小写字母及括号的字符串;输出包括解释成表示认得语言词汇的小写字母和相对应的汉字。
2、程序功能写一个魔王语言的解释系统,把他的话解释成人能听懂的话容。
设大写字母表示魔王语言的词汇;小写字母表示人的语言词汇;希腊字母表示可以用大写字母或小写字母代换的变量。
魔王语言可含人的词汇。
规则如下:θα1α2….αn)→θαnθαn-规则 1 (θ1…..θα1规则2 B→tAdA规则3 A→sae例如,将 B(ehnxgz)B 解释成tsaedsaeezegexenehetsaedsae若将小写字母与汉字建立下表所示的对应关系,则魔王说的话是“B(鹅恨蛋下赶追)B”。
翻译输出为“天上一只鹅地上一只鹅鹅追鹅赶鹅下鹅蛋鹅恨鹅天上一只鹅地上一只鹅”。
三概要设计1、数据类型定义及含义本程序中使用了栈和队列两种数据类型,其中使用s栈用于将魔王语言的所有元素压入,temp栈用于压入魔王语言中括号外面的元素,队列q用于放括号里面的元素。
2、主程序流程主程序先调用InitStack构造两个空栈S和Temp,接着调用InitQueue构造队列q,然后通过调用函数lhh完成魔王语言的翻译。
再通过询问方式询问用户是否继续进行操作。
3、各模块功能各模块功能如下:⑴main主函数;⑵InitStack构造空栈;⑶Push入栈;⑷Pop出栈;⑸StackEmpty判断栈是否为空;⑹ClearStack清空栈;⑺InitQueue构造一个队列;⑻EnQueue入队;⑼DeQueue出队;⑽QueueEmpty判断队列是否为空;⑾InStack将字符数组所有元素入栈;⑿check_MoWang检验魔王语言是否正确;⒀Translate翻译魔王语言;⒁lhh核心代码部分,处理括号里的元素以及调用其它函数翻译魔王语言。
魔鬼是堕落的天使
魔鬼是堕落的天使魔鬼是堕落的天使每一种文化中都有一些让人害怕的无形妖魔,这些坏妖怪的唯一目的就是危害人类。
如果形容一个人是“魔鬼”,那么他很可能行事邪恶并且乐此不疲。
但是,魔鬼并非一开始就臭名昭著的。
“魔鬼”(demon) 一词的起源是希腊文字“daimon”,意思是“超自然生物”(supernatural being) 或者“精灵”(spirit)。
在古希腊,人们相信魔鬼对人有好坏两方面的影响。
2,000 年前,基督教谴责对此类幽灵的信仰,把它们称作魔鬼。
自那以后,魔鬼就成了邪恶的幽灵。
大魔鬼有许多不同的名称:撒旦(Satan)、恶魔(Lucifer)、魔王(Beelzebub)、魔头 (Devil) 等等。
在圣经里,魔王 (Beelzebub) 被称为魔王(Baalzebub) 或太阳神(Baal)。
在古文化中,太阳神是象征生产和太阳的神,人们崇拜他,希望获得丰收。
后来,犹太教士说,太阳神是一个邪恶的神,会带来干旱和饥荒,于是他成了魔鬼。
撒旦则是与上帝作对的堕落天使。
基督教相信,撒旦领导了一群魔鬼,千方百计诱惑人类抛弃上帝和赎罪,去过邪恶的生活。
魔鬼是没有实体的幽灵,在地狱中忍受煎熬。
基督教(尤其是天主教)相信,魔鬼会进入并控制人的身体,用这样的方法获得肉体来到世上。
魔鬼附体有许多方式;有人说会听到自己心中有个声音叫他们去做坏事。
另外一些人则会精神恍惚或者情绪亢奋,变得异常暴力。
甚至有报道说,一些人被魔鬼附体后会浮在空中并从身上排出异物。
只有某些神父才能获准驱魔。
他们会举行仪式,用圣水和耶稣的名义将撒旦赶出被附体者的身体。
在中世纪,魔鬼附体会被看作是很严重的问题,成百上千的人会涌到教堂观看驱魔仪式。
现在的天主教会仍然认为魔鬼附体是非常严重的问题。
1999年,教皇修改了驱魔仪式,增加了驱魔神父的数量。
500年来,天主教会每年要举行数千次的驱魔仪式,这个传统一直保持到现在。
批评家说,魔鬼附体可以用身体疾病来解释,比如癫痫症或者精神病。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实习报告题目:编制一个魔王语言解释的程序班级: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。
StackEmpty(S)初始条件:栈S已经存在。
操作结果:若栈S为空栈,则返回TRUE,否则返回FALSE。
Push(&S,e)初始条件:栈S已经存在。
操作结果:在栈S的栈顶插入新的栈顶元素e。
Pop(&S,&e)初始条件:栈S已经存在。
操作结果:删除S的栈顶元素,并以e返回其值。
} ADT Stack2. 设定队列的抽象数据类型定义为:ADTQueue{数据对象:D={ai | ai∈ElemSet,I=1,2,......,n,n≥0}数据关系:R1={< ai-1,ai > |ai-1,ai∈D,I=1,2,......,n}基本操作:ListInitiate (&Q)操作结果:构造一个空队列Q。
StackEmpty(Q)初始条件:队列Q已经存在。
操作结果:若队列Q为空栈,则返回TRUE,否则返回FALSE。
EnQueue(&Q,e)初始条件:队列Q已经存在。
操作结果:插入元素e为Q的新的队尾元素。
DeQueue(&Q,&e)初始条件:队列Q已经存在。
操作结果:删除Q的对头元素,并以e返回其值。
} ADT Queue2.程序包含四个模块:1)主程序模块:Void main(){初始化;For(){接受处理命令;}接受处理;}2)栈模块——实现栈的抽象数据类型;3)队列模块——实现队列的抽象数据类型。
4)魔王语言解释模块——定义线性表的结点结构。
各模块的之间的调用关系如下:队列模块三、详细设计1. 站类型typedef struct{char *base;char *top;int stacksize;}stack;2. 队列类型typedef struct QNode{char data;struct QNode *next;}QNode,*LinkQueueNode;typedef struct{LinkQueueNode front;LinkQueueNode rear;}LinkQueue;3.栈的基本操作int Initstack(stack &s){s.base=(char*)malloc(100*sizeof(char)); if(!s.base)exit(0);s.top=s.base;s.stacksize=100;return 1;}int IsEmpty(stack s){if(s.top==s.base)return 1;return 0;}void push(stack &s,char e){if(s.top-s.base>=s.stacksize){s.base=(char*)realloc(s.base,(s.stacksize+10)*sizeof(char));if(!s.base)exit(0);s.top=s.base+s.stacksize;s.stacksize+=10;}*s.top++=e;}int pop(stack &s,char &e){if(s.top==s.base)exit(0);e=*--s.top;return 1;}4队列的基本操作int initQueue(LinkQueue &Q){Q.front=Q.rear=(LinkQueueNode)malloc(sizeof(LinkQueueNode));if(!Q.front)exit(-1);Q.front->next=NULL;return 1;}int Isempty(LinkQueue Q){if(Q.front==Q.rear)return 1;return 0;}int EnQueue(LinkQueue &Q,char e){LinkQueueNode p;p=(LinkQueueNode)malloc(sizeof(QNode));if(!p)exit(-1);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return 1;}char DeQueue(LinkQueue &Q,char &e){LinkQueueNode p;if(Q.front==Q.rear)return 0;p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return e;}5.求魔王语言解释的伪码算法:void transmite(stack S){LinkQueue Q;initQueue(Q);char c,e,ch;char A[3]={'s','a','e'};char B[8]={'t','s','a','e','d','s','a','e'}; printf("魔王要说的话是:");while(!IsEmpty(S)){pop(S,e);if(e=='B')printf("tsaedsae");else if(e=='A')printf("sae");else if(e=='('){while(pop(S,e)&&e!=')'){EnQueue(Q,e);}push(S,e);DeQueue(Q,c);while(!Isempty(Q)){DeQueue(Q,e);push(S,c);push(S,e);}push(S,c);while(!IsEmpty(S)){pop(S,e);if(e==')')break;else if(e=='B')printf("tsaedsae");else if(e=='A')printf("sae");elseprintf("%c",e);}}elseprintf("%c",e);}printf("\n");}6.主函数和其他函数的算法:void main(){bool flag=1;char str,c;while(flag==1){stack S;Initstack(S);char a[100];printf("魔王说话了:");int i=0;cin>>a;while(a[i])i++;for(int k=i;k>=0;k--)push(S,a[k]);transmite(S);printf("\n是否需要继续?是的话请按y: ");scanf("%c",&str);if(str=='y')flag=1;else flag=0;c=getchar();}}7调用函数关系图反映了演示程序的层次结构:四.调试分析1.对‘&’的用法明白了许多。
原来有点看不懂标识符‘&’,使调试程序时费了我不少的时间。
通过本次实验调试,让我明白了’&’用法。
2.函数调用。
函数调用是语言中一块十分重要部分,它可以把一个程序分成若干部分,然后进行配置,所以这块内容一定要学好。
3,栈和队列问题比较简单。
4,由于考虑不周,如果同样的字母出现时,规则会要求重复输入,最终以最后一个为准,这是一个失误,后来改正程序,过滤掉重复字母,从而实现了简洁正确输入规则。
五.用户手册1、本程序运行在DOS命令下2、进入程序后即显示用户界面:3、注意输入后即可得到相应的结果。
六、测试结果魔王说话了:B((aAb))A魔王要说的话是:tsaedsae(b(sae(a()sae七、附录源程序文件名清单:base .H //公用的常量和类型stkpas.H //栈类型testmaze.C //主程序。