24种设计模式
一、创建型模式
1、抽象工厂模式(Abstract factory pattern): 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要指定具体类.
2、生成器模式(Builder pattern): 使用生成器模式封装一个产品的构造过程, 并允许按步骤构造. 将一个复杂对象的构建与它的表示分离, 使得同样的构建过程可以创建不同的表示.
3、工厂模式(factory method pattern): 定义了一个创建对象的接口, 但由子类决定要实例化的类是哪一个. 工厂方法让类把实例化推迟到子类.
4、原型模式(prototype pattern): 当创建给定类的实例过程很昂贵或很复杂时, 就使用原形模式.
5、单例了模式(Singleton pattern): 确保一个类只有一个实例, 并提供全局访问点.
6、多例模式(Multition pattern): 在一个解决方案中结合两个或多个模式, 以解决一般或重复发生的问题.
二、结构型模式
1、适配器模式(Adapter pattern): 将一个类的接口, 转换成客户期望的另一个接口. 适配器让原本接口不兼容的类可以合作无间. 对象适配器使用组合, 类适配器使用多重继承.
2、桥接模式(Bridge pattern): 使用桥接模式通过将实现和抽象放在两个不同的类层次中而使它们可以独立改变.
3、组合模式(composite pattern): 允许你将对象组合成树形结构来表现”整体/部分”层次结构. 组合能让客户以一致的方式处理个别对象以及对象组合.
4、装饰者模式(decorator pattern): 动态地将责任附加到对象上, 若要扩展功能, 装饰者提供了比继承更有弹性的替代方案.
5、外观模式(facade pattern): 提供了一个统一的接口, 用来访问子系统中的一群接口. 外观定义了一个高层接口, 让子系统更容易使用.
6、亨元模式(Flyweight Pattern): 如想让某个类的一个实例能用来提供许多”虚拟实例”, 就使用蝇量模式.
7、代理模式(Proxy pattern): 为另一个对象提供一个替身或占位符以控制对这个对象的访问.
三、行为型模式
1、责任链模式(Chain of responsibility pattern): 通过责任链模式, 你可以为某个请求创建一个对象链. 每个对象依序检查此请求并对其进行处理或者将它传给链中的下一个对象.
2、命令模式(Command pattern): 将”请求”封闭成对象, 以便使用不同的请求,队列或者日志来参数化其他对象. 命令模式也支持可撤销的操作.
3、解释器模式(Interpreter pattern): 使用解释器模式为语言创建解释器.
4、迭代器模式(iterator pattern): 提供一种方法顺序访问一个聚合对象中的各个元素, 而又不暴露其内部的表示.
5、中介者模式(Mediator pattern) : 使用中介者模式来集中相关对象之间复杂的沟通和控制方式.
6、备忘录模式(Memento pattern): 当你需要让对象返回之前的状态时(例如, 你的用户请求”撤销”), 你使用备忘录模式.
7、观察者模式(observer pattern): 在对象之间定义一对多的依赖, 这样一来, 当一个对象改变状态, 依赖它的对象都会收到通知, 并自动更新.
8、状态模式(State pattern): 允许对象在内部状态改变时改变它的行为, 对象看起来好象改了它的类.
9、策略模式(strategy pattern): 定义了算法族, 分别封闭起来, 让它们之间可以互相替换, 此模式让算法的变化独立于使用算法的客户.
10、模板方法模式(Template pattern): 在一个方法中定义一个算法的骨架, 而将一些步骤延迟到子类中. 模板方法使得子类可以在不改变算法结构的情况下, 重新定义算法中的某些步骤.
11、访问者模式(visitor pattern): 当你想要为一个对象的组合增加新的能力, 且封装并不重要时, 就使用访问者模式.
俗话说，只要肯动脑，办法总比困难多，面对生活中各种各样的烦恼，那些喜欢动脑的人们便想出了他们自己的解决方案，而且其中的很多创意设计都是出自儿童之手。
一起来看看，哪些让你眼前一亮呢？
一位父亲给自己的孩子改造的自行车，这样的设计不容易摔倒，对于刚学车的儿童来说还是挺有用的。
儿童自己动手用积木制作的平板支架，不得不说，有时候儿童们的创意甚至会让大人们吃惊。
用胶带把竹夹绑到勺子上，这样就不用担心勺子会掉进锅里了。
这是一个抽屉柜，四个抽屉分别采用了不同的形状，将衣服按上面的分类放进去，再也不怕自己的衣服找不到了。
女孩把自家破损的木门进行了改造，样子还挺形象，也算是别出心裁了。
儿童自制的雨水收集器，雨伞上面放置了一些海绵，水可以通过伞柄流进下面的瓶子里，因为养鱼或者其他的水生小动物都不能使用自来水。
8岁大的孩子给自己的小车自制了顶棚，虽然看起来不怎么样，但起码能遮阳……
用挂钩把书挂起来，躺在浴缸里看书肯定很舒服。
把牙膏放到注射器里，用的时候一推就行，不用每次挤牙膏了。
牛人自制了一个带风扇的餐具，再也不怕热食烫嘴了。
百叶窗改成的台灯罩，通过拉链就能控制亮度，太有创意了。
对花粉过敏是一件很痛苦的事情，在没有口罩的情况下这倒也是个办法。
自制轮滑鞋，而且还带减震，看上去不错，就是不知道效果怎么样。
这是一个树叶收集器，因为很多树木的叶子用途很广，所以这个发明倒也不算奇怪。
给老年人制作的拐杖，亮点是加了一个收音机，开关就在把手上。
两用型立镜，既可以当小桌，也可以当镜子。
餐馆里定制的扎啤杯，有了这样的设计就可以同时端好几杯了。
这是一家儿童推车专卖店，这里的地板被设计成了不同的类型，以便家长们亲自体验。
一名牙医将天花板做成了错觉图片，用来分散患者的注意力，感觉非常贴心。
输一次就换一次位置的密码器，不用担心后面的人会通过手势动作记住自己的秘密了。
一家餐厅用积木展示自家店里的座位情况，不仅位置很直观，而且红色代表有人，绿色代表空位。
非常简单的设计，作用却很直观。
旋转式的冰箱，不论取东西还是放东西都更方便了。
男孩自制的“家庭影院”，单凭想象的话，效果也会不错吧。
1.Abstract Factory.. 2提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。
2.Builder 2 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
3.Factory Method.. 3定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延迟到其子类。
4.Prototype.. 3用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
5.Singleton. 3 保证一个类仅有一个实例，并提供一个访问它的全局访问点
结构型模式...
1.Adapter. 4将一个类的接口转换成客户希望的另外一个接口。
2.Bridge.. 4将抽象部分与它的实现部分分离，使它们都可以独立的变化。
3.Composite.. 5将对象组合成树形结构以表示“部分-整体”的层次结构。
4.Decorator. 5动态地给一个对象添加一些额外的职责。
5.Fa?ade.. 6为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
6.Flyweight. 6运用共享技术有效地支持大量细粒度的对象。
7.Proxy.. 7为其它对象提供一种代理以控制对这个对象的访问。
行为模式...
1.Chain of Responsibility. 7 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
2.Command. 7 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。
3.Interpreter. 8给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语句中的句子。
4.Iterator 8 提供一种方法顺序访问一个聚合对象中的各个元素，而不需要暴露该对象的内部表示。
5.Mediator 8 用一个中介对象来封装一系列的对象交互。
6.Memento.. 9在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。
7.Observer 9 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。
8.State.. 9允许一个对象在其内部状态改变时改变它的行为。
9.Strategy. 10 定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。
10. Template Method.. 10定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。
11. Visitor. 10表示一个作用于某对象结构中的各元素的操作。
餐厅卡座介绍：卡座，在演艺式的酒吧或者休闲会所，餐厅的座位形式：通常是两个面对面的沙发，中间加一个小桌子，被称为“卡座”, 这个说法来源于香港。
香港称之为“卡位”，是来源于英文"Car Seat"。Car是指以前的马车中的车；马车车厢中的座位是这样，比较形象。
►简约风餐厅卡座设计
客餐厅面积不是很大，餐厅没有自然光源，利用小吧台隔断，在餐厅设计一个L型卡座真是一个非常不错的选择。
节约了空间，又增加了收纳空间。餐厅也变成了一个无比温馨的角落。卡座延伸的小柜子刚好可做餐边柜，墙面的搁架可做展示架。米色的墙面、白色的卡座和餐桌、绿色原木的吊顶和卡座坐垫，颜色搭配的都恰到好处。
简约风格的一字型卡座，
整个餐厅已黑白两色为主调，搭配绿色的餐桌装饰品，清新简洁。
简约咖啡色调的餐厅，卡座背景墙的花朵壁纸为简约的设计带来了优雅的气息。当然灯具装饰也能给小餐厅起到画龙点睛的作用。
吊顶和墙面都做了非常简洁的设计，照片墙，白色卡座上方的书柜，原木餐桌椅和宜家吊灯，简约中带着时尚和舒适。
壁纸和墙面软包，简约中带了点小奢华的气息。
►地中海风格餐厅卡座设计
地中海风情的装修，餐厅的墙面的区域分成了三个功能区：收纳柜、卡座、冰箱和微波炉搁架。听起来有些杂乱的三个区域，在设计师的调整下看起来很美观。
客餐厅融为一体的设计，省下了沙发和餐椅的费用。看起来也美观，就是舒适度不知道如何。
小巧的蓝白餐厅，小户型可以借鉴。卡座下面的收纳，上面的搁架都非常实用。
蓝白地中海风情餐厅设计，吊顶和白砖让地中海的气息更加浓郁。空间虽小，小圆桌可是非常实用的哦。
►田园风格餐厅卡座设计
墙面的色彩已经定义了整个空间的味道，zakka小清新。客餐厅间用一个收纳柜做了隔断，也可做餐边柜用。白色和原木的卡座和整个装修的风格融合在一起。
白色卡座加上绿白格子的坐垫，搭配米色的墙面，非常小清新。
原木卡座的设计，就餐的时候是不是有种在大自然的感觉。鲜艳的抱枕和鲜花增加了活泼感。
小户型的餐厅采用了直角卡座的设计，非常实用。
餐厅比较狭长的话，一字型的卡座是非常合适的设计。卡座两端可以做收纳柜，墙面可做照片墙或者壁纸装饰，再加上抱枕、灯具的装饰，浪漫的餐厅就出来啦。
L型卡座，和餐桌一样用了原木和白色的搭配，简洁清新。这样的餐桌设计简单省空间。
绿色的背景墙延伸到吊顶，原木卡座和延伸的树枝造型、餐桌，白云造型的吊灯，小餐厅仿佛在大自然中。
卡座中间部分做了软包设计，连着卡座做了白色的书架，让这个光线充足又安静的餐厅也充当了小书房。
文艺范十足的小清新餐厅，沿用整个装修主色调绿色，浅绿色的卡座，绿色的手绘装饰画，很美妙的色彩搭配。
►海外餐厅卡座设计
淡淡的蓝色和米色调搭配，软包、坐垫、抱枕、单人椅、窗帘和吊灯，和谐的色彩运用是空间装饰不可或缺的。
明亮的色彩搭配，让小空间充满活力。花朵壁纸、条纹抱枕，年轻的朋友不妨尝试一下大胆的色彩哦。
利用小角落做的餐厅，L型沿着墙角做的卡座，加上小圆桌，很实用的设计。
很美的垭口设计，让小餐厅变得很梦幻。利用小窗的自然采光，在两边墙面都做了一字型的卡座，搭配红色的坐垫，可爱甜美。
沿着窗户做了又弧度的卡座，最大化利用自然光源和空间。
个性时尚的卡座设计
小巧的蓝白餐厅，小户型可以借鉴。卡座下面的收纳，上面的搁架都非常实用。
蓝白地中海风情餐厅设计，吊顶和白砖让地中海的气息更加浓郁。空间虽小，小圆桌可是非常实用的哦。
►田园风格餐厅卡座设计
墙面的色彩已经定义了整个空间的味道，zakka小清新。客餐厅间用一个收纳柜做了隔断，也可做餐边柜用。白色和原木的卡座和整个装修的风格融合在一起。
白色卡座加上绿白格子的坐垫，搭配米色的墙面，非常小清新。
原木卡座的设计，就餐的时候是不是有种在大自然的感觉。鲜艳的抱枕和鲜花增加了活泼感。
小户型的餐厅采用了直角卡座的设计，非常实用。
餐厅比较狭长的话，一字型的卡座是非常合适的设计。卡座两端可以做收纳柜，墙面可做照片墙或者壁纸装饰，再加上抱枕、灯具的装饰，浪漫的餐厅就出来啦。
L型卡座，和餐桌一样用了原木和白色的搭配，简洁清新。这样的餐桌设计简单省空间。
绿色的背景墙延伸到吊顶，原木卡座和延伸的树枝造型、餐桌，白云造型的吊灯，小餐厅仿佛在大自然中。
卡座中间部分做了软包设计，连着卡座做了白色的书架，让这个光线充足又安静的餐厅也充当了小书房。
文艺范十足的小清新餐厅，沿用整个装修主色调绿色，浅绿色的卡座，绿色的手绘装饰画，很美妙的色彩搭配。
►海外餐厅卡座设计
淡淡的蓝色和米色调搭配，软包、坐垫、抱枕、单人椅、窗帘和吊灯，和谐的色彩运用是空间装饰不可或缺的。
明亮的色彩搭配，让小空间充满活力。花朵壁纸、条纹抱枕，年轻的朋友不妨尝试一下大胆的色彩哦。
利用小角落做的餐厅，L型沿着墙角做的卡座，加上小圆桌，很实用的设计。
很美的垭口设计，让小餐厅变得很梦幻。利用小窗的自然采光，在两边墙面都做了一字型的卡座，搭配红色的坐垫，可爱甜美。
沿着窗户做了又弧度的卡座，最大化利用自然光源和空间。
个性时尚的卡座设计
正度4开：370x520
正度8开：260x380
正度16开：186X260
正度32开：130x186
以上为成品尺寸，设计尺寸就在此基础上四边各加3mm出血就ok。
#include<string.h>
#include<stdlib.h>
#include<time.h>
#define MAX 13
#define OK 1
#define TRUE 1
#define FALSE 0
#define ERROR 0
#define OVERFLOW -2
#define OPSETSIZE 7
#define STACK_INIF_SIZE 50
#define STACKINCREMENT 10
typedef int status
int number[2][4]
enum
{
eNumber = 0, //操作数
eOperator = 1 //算子
}
int oper[7]={43,45,42,47,40,41,35}
typedef struct sqlist{
int bol//bol is 0 when num_ch is a numberbol is 1 when the num_ch is a oprater
int num_ch
struct sqlist *next
}sqlist
typedef struct sqstack{
int *base
int *top
int stacksize
}sqstack
unsigned char Prior[7][7] = { // 表3.1 算符间的优先关系
'>','>','<','<','<','>','>',
'>','>','<','<','<','>','>',
'>','>','>','>','<','>','>',
'>','>','>','>','<','>','>',
'<','<','<','<','<','=',' ',
'>','>','>','>',' ','>','>',
'<','<','<','<','<',' ','='
}
char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'}
status init_sq(sqlist *l){//初始化链表
l=(sqlist*)malloc(sizeof(sqlist))
if(l==NULL){
exit(OVERFLOW)
}
l->next=NULL
return OK
}
status insert_sq(sqlist **p,int e,int bl){//链表插入操作
sqlist *q
q=(sqlist*)malloc(sizeof(sqlist))
q->num_ch=e
q->bol=bl
q->next=NULL
(*p)->next=q
(*p)=(*p)->next
// printf("insert %d ,%dis succssed!\n",e,bl)
return OK
}
int check(sqlist l)//保证输入的数字是给出的四个数字
{
int right=1,find=0,i
sqlist *q=&l
q=q->next
for (q->next!=NULLq=q->next){
if(q->bol==1){
if(q->num_ch <=39||q->num_ch>57||q->num_ch==44||q->num_ch==46){
right=0
printf("%c不是有效的运算符!\n")
}
}
else {
find=0
for(i=0i<4i++){
if(number[1][i]==0&&number[0][i]==q->num_ch ){
number[1][i]=1
find=1
break
}
}
if(find==0){
printf("%d 不在给出的四个数字中!\n",q->num_ch )
right=0
}
}
}//end for
for (i=0i<4i++){
if(number[1][i]==0){
printf("%d没有用上!\n",number[0][i])
right=0
}
}
return right
}
int chang(char *s,sqlist *l){//将用户的输入转化为单链表
int t=0
unsigned int i=0
int bl,ch
int a1,a2,a
sqlist *p=l
for (i<strlen(s)i++){
if(s[i]>47&&s[i]<58&&t==0){
a1=(int)s[i]-48
t++
}
else if(s[i]>47&&s[i]<58&&t==1){
a2=(int)s[i]-48
a=a1*10+a2
t++
}
else if(s[i]<48&&s[i]>39&&s[i]!=44&&s[i]!=46){
if(t==1){
bl=0
insert_sq(&p,a1,bl)
t=0
}
else if(t==2){
bl=0
insert_sq(&p,a,bl)
t=0
}
bl=1
ch=(int)s[i]
insert_sq(&p,ch,bl)
t=0
}
else {
printf("%c不是有效的运算符!\n",s[i])
}
} //end for
i=strlen(s)-1
if(s[i]>47&&s[i]<58){
if(s[i-1]>47&&s[i-1]<58){
bl=0
insert_sq(&p,a,bl)
}
else {
bl=0
insert_sq(&p,a1,bl)
}
}
bl=1
a=35
insert_sq(&p,a,bl)
//printf("chang is OK\n")
return (check(*l))
}
int Operate(int a,int theta, int b) {//计算
// printf("a=%d,theta=%c,b=%d\n",a,theta,b)
switch(theta) {
case 43: return a+b
case 45: return a-b
case 42: return a*b
case 47:
{
if(b==0){
return -2000
}
if (a%b==0){
return a/b
}
else {//printf("不能为小数\n")
return -10000
}
}
default : return 0
}
}
int ReturnOpOrd(char op,char* TestOp) {//被char precede(char Aop, char Bop)所调用来求优先级
int i
for(i=0i<OPSETSIZEi++) {
if (op == TestOp[i]) return i
}
return 0
}
char precede(char Aop, char Bop) {
return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)]
}
status initstack(sqstack *s){
(s)->base = (int*)malloc(STACK_INIF_SIZE*sizeof(int))
if((s)->base==NULL) exit(OVERFLOW)
(s)->top=(s)->base
(s)->stacksize = STACK_INIF_SIZE
// printf("栈初始化完成!\n")
return OK
}
int gettop(sqstack *s){
int e
if(s->top==s->base){
printf("栈空,无法取得栈顶元素!\n")
return 0
}
e=*(s->top-1)
// printf("取得栈顶元素: %d \n",e)
return e
}
status push(sqstack *s,int e){
if(s->top-s->base>=s->stacksize){
s->base=(int*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(int))
if(!s->base) exit(OVERFLOW)
s->stacksize+= STACKINCREMENT
}
*(s->top++)=e
//printf("把 %d 压栈 is OK\n",e)
return OK
}
status pop(sqstack *s,int *e){
if(s->top==s->base){
printf("栈空,出栈错误!\n")
return ERROR
}
*e=*(--s->top)
//printf(" %d出栈成功 !\n",*e)
return OK
}
int EvaluateExpression(char* MyExpression) { // 算法3.4
// 算术表达式求值的算符优先算法。
// 设OPTR和&&OPND分别为运算符栈和运算数栈，OP为运算符集合。
int result
sqstack OPTR // 运算符栈，字符元素
sqstack OPND // 运算数栈，实数元素
int c,bl,a,b,theta,top
sqlist *q,l
char *s=MyExpression
init_sq(&l)
if(chang(s,&l)!=0){
q=&l
initstack(&OPTR)
push(&OPTR, 35)
initstack (&OPND)
q=q->next
c=q->num_ch
bl=q->bol
while ((c!= 35 || gettop(&OPTR)!=35)){
if (bl!=1) {
push(&OPND, c)
q=q->next
c=q->num_ch
bl=q->bol
} // 不是运算符则进栈
else {
top=gettop(&OPTR)
// printf("top %c",top)
switch (precede(top, c)) {
case '<': // 栈顶元素优先权低
push(&OPTR, c)
q=q->next
c=q->num_ch
bl=q->bol
break
case '=': // 脱括号并接收下一字符
pop(&OPTR, &c)
q=q->next
c=q->num_ch
bl=q->bol
break
case '>': // 退栈并将运算结果入栈
pop(&OPTR, &theta)
pop(&OPND, &b)
pop(&OPND, &a)
//printf("q->num_ch is %d\n",q->num_ch)
push(&OPND, Operate(a, theta, b))
break
default :
printf("没有这个运算符!\n")
return 0
} // switch
}//else
} // while
result=gettop(&OPND)
return result
}
else {
printf("你的输入有错误!\n")
return 0
}
} // EvaluateExpression
int randomm()//产生四个随机数
{
int i=0
srand((unsigned)time(NULL))
for (i<4i++){
number[0][i]=0
number[0][i]=rand()
number[0][i]%=13
number[0][i]++
number[1][i]=0
}
return number[2][4]
}
int CalcOneExpress(int expression[][2])
{
// 算术表达式求值的算符优先算法。
// 设OPTR和&&OPND分别为运算符栈和运算数栈，OP为运算符集合。
int index=0,result,c,theta,a,b
sqstack OPTR // 运算符栈，字符元素
sqstack OPND // 运算数栈，实数元素
initstack(&OPTR)
push(&OPTR, 35)
initstack (&OPND)
c=expression[index][0]
while (c!= 35 || gettop(&OPTR)!=35){
if (expression[index][1]!=1) {
push(&OPND, c)
index++
c=expression[index][0]
} // 不是运算符则进栈
else {
switch (precede(gettop(&OPTR), c)) {
case '<':
// 栈顶元素优先权低
push(&OPTR, c)
index++
c=expression[index][0]
break
case '=': // 脱括号并接收下一字符
pop(&OPTR, &c)
index++
c=expression[index][0]
break
case '>': // 退栈并将运算结果入栈
pop(&OPTR, &theta)
pop(&OPND, &b)
pop(&OPND, &a)
push(&OPND, Operate(a, theta, b))
break
default :
printf("没有这个运算符\n")
return 0
} // switch
}//else
} // while
result=gettop(&OPND)
return result
} // EvaluateExpression
int Equal24(int n)
{
if(n==24){
// printf("the result is %d\n",n)
return TRUE
}
elsereturn FALSE
}
//括号的几种情况
//1 无括号
//2 (a b) c d 同a b (c d), 下省略
//3 (a b c) d
//4 a (b c) d
//5 (a b) (c d)
//6 ((a b) c) d
//7 (a (b c)) d
int CalcArray1(int iNumInput[2][4])
{
// a * b * c * d //7 number
int expression[8][2],ii,jj,kk
int i,j,k,l,dRes
for(i=0i<4i++)
{
for(j=0j<4j++)
{
if(j==i)
{
continue
}
for(k=0k<4k++)
{
if(k==i||k==j)
{
continue
}
for(l=0l<4l++)
{
if(l==i||l==j||l==k)
{
continue
}
expression[0][0]=iNumInput[0][i]
expression[2][0]=iNumInput[0][j]
expression[4][0]=iNumInput[0][k]
expression[6][0]=iNumInput[0][l]
expression[0][1]=eNumber
expression[2][1]=eNumber
expression[4][1]=eNumber
expression[6][1]=eNumber
for (ii=0ii<4ii++)
{
for (jj=0jj<4jj++)
{
for (kk=0kk<4kk++)
{
expression[1][0] = oper[ii]
expression[1][1] = eOperator
expression[3][0] = oper[jj]
expression[3][1] = eOperator
expression[5][0] = oper[kk]
expression[5][1] = eOperator
expression[7][0] = oper[6]
expression[7][1] = eOperator
dRes = CalcOneExpress(expression)
if(Equal24(dRes))
{
printf("可以这样运算:%d%c%d%c%d%c%d\n",expression[0][0],oper[ii],expression[2][0],oper[jj],expression[4][0],oper[kk],expression[6][0])
return TRUE
}
}
}
}//end of for oper
}
}
}
}
return FALSE
}
int CalcArray2(int iNumInput[2][4])
{
// (a * b) * c * d //9 number
int expression[10][2]
int ii,jj,i,j,k,l,kk
int dRes
// printf("CalcArray2\n")
for(i=0i<4i++)
{
for(j=0j<4j++)
{
if(j==i)
{
continue
}
for(k=0k<4k++)
{
if(k==i||k==j)
{
continue
}
for(l=0l<4l++)
{
if(l==i||l==j||l==k)
{
continue
}
expression[1][0]=iNumInput[0][i]
expression[3][0]=iNumInput[0][j]
expression[6][0]=iNumInput[0][k]
expression[8][0]=iNumInput[0][l]
expression[1][1]=eNumber
expression[3][1]=eNumber
expression[6][1]=eNumber
expression[8][1]=eNumber
for (ii=0ii<4ii++)
{
for (jj=0jj<4jj++)
{
for (kk=0kk<4kk++)
{
expression[2][0] = oper[ii]
expression[2][1] = eOperator
expression[5][0] = oper[jj]
expression[5][1] = eOperator
expression[7][0] = oper[kk]
expression[7][1] = eOperator
expression[9][0] = oper[6]
expression[9][1] = eOperator
expression[0][0] = oper[4]
expression[0][1] = eOperator
expression[4][0] = oper[5]
expression[4][1] = eOperator
dRes = CalcOneExpress(expression)
if(Equal24(dRes))
{
printf("可以这样运算:%c%d%c%d%c%c%d%c%d\n",oper[4],expression[1][0],oper[ii],expression[3][0],oper[5],oper[jj],expression[6][0],oper[kk],expression[8][0])
return TRUE
}
}
}
}//end of for oper
}
}
}
}
return FALSE
}
int CalcArray3(int iNumInput[2][4])
{
// (a * b * c) * d //9 number
int expression[10][2]
int ii,jj,i,j,k,l,kk
int dRes
// printf("CalcArray3\n")
for(i=0i<4i++)
{
for(j=0j<4j++)
{
if(j==i)
{
continue
}
for(k=0k<4k++)
{
if(k==i||k==j)
{
continue
}
for(l=0l<4l++)
{
if(l==i||l==j||l==k)
{
continue
}
expression[1][0]=iNumInput[0][i]
expression[3][0]=iNumInput[0][j]
expression[5][0]=iNumInput[0][k]
expression[8][0]=iNumInput[0][l]
expression[1][1]=eNumber
expression[3][1]=eNumber
expression[5][1]=eNumber
expression[8][1]=eNumber
for (ii=0ii<4ii++)
{
for (jj=0jj<4jj++)
{
for (kk=0kk<4kk++)
{
expression[2][0] = oper[ii]
expression[2][1] = eOperator
expression[4][0] = oper[jj]
expression[4][1] = eOperator
expression[7][0] = oper[kk]
expression[7][1] = eOperator
expression[9][0] = oper[6]
expression[9][1] = eOperator
expression[0][0] = oper[4]
expression[0][1] = eOperator
expression[6][0] = oper[5]
expression[6][1] = eOperator
dRes = CalcOneExpress(expression)
if(Equal24(dRes))
{
printf("可以这样运算:%c%d%c%d%c%d%c%c%d\n",oper[4],expression[1][0],oper[ii],expression[3][0],oper[jj],expression[5][0],oper[5],oper[kk],expression[8][0])
return TRUE
}
}
}
}//end of for oper
}
}
}
}
return FALSE
}
int CalcArray4(int iNumInput[2][4])
{
// (a * b * c) * d //9 number
int expression[10][2]
int ii,jj,i,j,k,l,kk
int dRes
// printf("CalcArray4\n")
for(i=0i<4i++)
{
for(j=0j<4j++)
{
if(j==i)
{
continue
}
for(k=0k<4k++)
{
if(k==i||k==j)
{
continue
}
for(l=0l<4l++)
{
if(l==i||l==j||l==k)
{
continue
}
expression[0][0]=iNumInput[0][i]
expression[3][0]=iNumInput[0][j]
expression[5][0]=iNumInput[0][k]
expression[8][0]=iNumInput[0][l]
expression[0][1]=eNumber
expression[3][1]=eNumber
expression[5][1]=eNumber
expression[8][1]=eNumber
for (ii=0ii<4ii++)
{
for (jj=0jj<4jj++)
{
for (kk=0kk<4kk++)
{
expression[1][0] = oper[ii]
expression[1][1] = eOperator
expression[4][0] = oper[jj]
expression[4][1] = eOperator
expression[7][0] = oper[kk]
expression[7][1] = eOperator
expression[9][0] = oper[6]
expression[9][1] = eOperator
expression[2][0] = oper[4]
expression[2][1] = eOperator
expression[6][0] = oper[5]
expression[6][1] = eOperator
dRes = CalcOneExpress(expression)
if(Equal24(dRes))
{
printf("可以这样运算:%d%c%c%d%c%d%c%c%d\n",expression[0][0],oper[ii],oper[4],expression[3][0],oper[jj],expression[5][0],oper[5],oper[kk],expression[8][0])
return TRUE
}
}
}
}//end of for oper
}
}
}
}
return FALSE
}
int CalcArray5(int iNumInput[2][4])
{
// (a * b) * (c * d) //11 number
int expression[12][2]
int ii,jj,i,j,k,l,kk
int dRes
// printf("CalcArray5\n")
for(i=0i<4i++)
{
for(j=0j<4j++)
{
if(j==i)
{
continue
}
for(k=0k<4k++)
{
if(k==i||k==j)
{
continue
}
for(l=0l<4l++)
{
if(l==i||l==j||l==k)
{
continue
}
expression[1][0]=iNumInput[0][i]
expression[3][0]=iNumInput[0][j]
expression[7][0]=iNumInput[0][k]
expression[9][0]=iNumInput[0][l]
expression[1][1]=eNumber
expression[3][1]=eNumber
expression[7][1]=eNumber
expression[9][1]=eNumber
for (ii=0ii<4ii++)
{
for (jj=0jj<4jj++)
{
for (kk=0kk<4kk++)
{
expression[2][0] = oper[ii]
expression[2][1] = eOperator
expression[5][0] = oper[jj]
expression[5][1] = eOperator
expression[8][0] = oper[kk]
expression[8][1] = eOperator
expression[11][0] = oper[6]
expression[11][1] = eOperator
expression[0][0] = oper[4]
expression[0][1] = eOperator
expression[6][0] = oper[4]
expression[6][1] = eOperator
expression[4][0] = oper[5]
expression[4][1] = eOperator
expression[10][0] = oper[5]
expression[10][1] = eOperator
dRes = CalcOneExpress(expression)
if(Equal24(dRes))
{
printf("可以这样运算:%c%d%c%d%c%c%c%d%c%d%c\n",oper[4],expression[1][0],oper[ii],expression[3][0],oper[5],oper[jj],oper[4],expression[7][0],oper[kk],expression[9][0],oper[5])
return TRUE
}
}
}
}//end of for oper
}
}
}
}
return FALSE
}
int CalcArray6(int iNumInput[2][4])
{
// ((a * b) * c) * d //11 number
int expression[12][2]
int ii,jj,i,j,k,l,kk
int dRes
// printf("CalcArray6\n")
for(i=0i<4i++)
{
for(j=0j<4j++)
{
if(j==i)
{
continue
}
for(k=0k<4k++)
{
if(k==i||k==j)
{
continue
}
for(l=0l<4l++)
{
if(l==i||l==j||l==k)
{
continue
}
expression[2][0]=iNumInput[0][i]
expression[4][0]=iNumInput[0][j]
expression[7][0]=iNumInput[0][k]
expression[10][0]=iNumInput[0][l]
expression[2][1]=eNumber
expression[4][1]=eNumber
expression[7][1]=eNumber
expression[10][1]=eNumber
for (ii=0ii<4ii++)
{
for (jj=0jj<4jj++)
{
for (kk=0kk<4kk++)
{
expression[3][0] = oper[ii]
expression[3][1] = eOperator
expression[6][0] = oper[jj]
expression[6][1] = eOperator
expression[9][0] = oper[kk]
expression[9][1] = eOperator
expression[11][0] = oper[6]
expression[11][1] = eOperator
expression[0][0] = oper[4]
expression[0][1] = eOperator
expression[1][0] = oper[4]
expression[1][1] = eOperator
expression[5][0] = oper[5]
expression[5][1] = eOperator
expression[8][0] = oper[5]
expression[8][1] = eOperator
dRes = CalcOneExpress(expression)
if(Equal24(dRes))
{
printf("可以这样运算:%c%c%d%c%d%
