二十四点游戏

#include<iostream>
#include<string.h>
#include<string>
#include<stack>
using namespace std;

bool lessthan(char a, char b)
{
    if(b==‘*‘ || b==‘/‘ )
    {
        return true;
    }

    if(a==‘+‘ || a==‘-‘ )
    {
        return true;
    }
    return false;
}

void compute(stack<int> & s_num, char op)
{
    int b = s_num.top();
    s_num.pop();
    int a = s_num.top();
    s_num.pop();

    if(op==‘*‘)
    {
        s_num.push(a*b);
    }
    else if(op==‘/‘)
    {
        s_num.push(a/b);
    }
    else if(op==‘+‘)
    {
        s_num.push(a+b);
    }
    else if(op==‘-‘)
    {
        s_num.push(a-b);
    }
    else
    {
    }
}

int expression(char *str, int num)
{
    int res = 0;
    stack<int> s_num;
    stack<char> s_op;
    for(int i=0; i<num; i++)
    {
        if(str[i]>=‘0‘ && str[i]<=‘9‘)
        {
            int tmp = 0;
            int base = 1;
            tmp = base*(str[i]-‘0‘);
            while(str[i+1]>=‘0‘ && str[i+1]<=‘9‘)
            {
                tmp = tmp*10 + (str[i+1]-‘0‘);
                i++;
            }
            s_num.push(tmp);
        }

        else if(str[i] == ‘(‘)
        {
            s_op.push(str[i]);
        }
        else if(str[i] == ‘[‘)
        {
            s_op.push(str[i]);
        }
        else if(str[i] == ‘{‘)
        {
            s_op.push(str[i]);
        }

        else if(str[i] == ‘)‘)
        {
            char tmp = s_op.top();
            while(tmp!=‘(‘)
            {
                s_op.pop();
                //
                compute(s_num, tmp);

                tmp = s_op.top();
            }
            s_op.pop();
        }
        else if(str[i] == ‘]‘)
        {
            char tmp = s_op.top();
            while(tmp!=‘[‘)
            {
                s_op.pop();
                //
                compute(s_num, tmp);

                tmp = s_op.top();
            }
            s_op.pop();
        }
        else if(str[i] == ‘}‘)
        {
            char tmp = s_op.top();
            while(tmp!=‘{‘)
            {
                s_op.pop();
                //
                compute(s_num, tmp);

                tmp = s_op.top();
            }
            s_op.pop();
        }

        //*/+-
        else if( str[i]==‘-‘ )
        {
            if( i==0 || str[i-1]==‘(‘ ||str[i-1]==‘{‘ ||str[i-1]==‘[‘ ||str[i-1]==‘+‘ ||str[i-1]==‘-‘ ||str[i-1]==‘*‘ ||str[i-1]==‘/‘ )
            {
                i++;
                if(str[i]>=‘0‘ && str[i]<=‘9‘)
                {
                    int tmp = 0;
                    int base = 1;
                    tmp = base*(str[i]-‘0‘);
                    while(str[i+1]>=‘0‘ && str[i+1]<=‘9‘)
                    {
                        tmp = tmp*10 + (str[i+1]-‘0‘);
                        i++;
                    }
                    s_num.push(0-tmp);
                }
                else
                {
                    cout<<"error"<<endl;
                }
            }
            else
            {
                while(!s_op.empty())
                {
                    char tmp = s_op.top();
                    if( tmp!=‘(‘ && tmp!=‘[‘ && tmp!=‘{‘ && lessthan(str[i], tmp))
                    {
                        s_op.pop();
                        //
                        compute(s_num, tmp);
                    }
                    else
                    {
                        break;
                    }
                }

                s_op.push(str[i]);
            }
        }
        else if(str[i]==‘*‘ || str[i]==‘/‘ || str[i]==‘+‘)
        {
            while(!s_op.empty())
            {
                char tmp = s_op.top();
                if( tmp!=‘(‘ && tmp!=‘[‘ && tmp!=‘{‘ && lessthan(str[i], tmp))
                {
                    s_op.pop();
                    //
                    compute(s_num, tmp);

                }
                else
                {
                    break;
                }
            }

            s_op.push(str[i]);
        }
        else
        {
        }

    }

    //final
    while(!s_op.empty())
    {
        char tmp = s_op.top();
        compute(s_num, tmp);
        s_op.pop();
    }

    return s_num.top();
}

void solve(int count, string *four, string *plusx, bool &flag)
{
    string fuhao[4] = {"+","-", "*", "/"};
    if(flag)
    {
        return;
    }
    else
    {
        if(count == 3)
        {
            string total;
            if(plusx[0]=="/" && plusx[1]=="*" && plusx[2]=="*")// /**
            {
                total = four[0]  + plusx[1] + four[2] + plusx[2] + four[3]+ plusx[0] + four[1];
            }
            else if(plusx[0]=="/" && plusx[1]=="*")
            {
                total = four[0]  + plusx[1] + four[2] + plusx[0] + four[1]+ plusx[2] + four[3];
            }
            else if(plusx[1]=="/" && plusx[2]=="*")
            {
                total = four[0]  + plusx[0] + four[1]+ plusx[2] + four[3]+ plusx[1] + four[2] ;
            }
            else
            {
                total = four[0]  + plusx[1] + four[1]+ plusx[2]+ four[2] + plusx[0]  + four[3];
            }

            char expr[100];

            int len = total.length();

            for(int i=0; i<len; i++)
            {
                expr[i] = total[i];
            }
            expr[len] = ‘\0‘;

            //cout<<expr<<"=";

            float tmp = expression(expr, len);
            //cout<<tmp<<endl;

            if(tmp - 24 < 0.001 && tmp - 24>-0.001)
            {
                flag = true;
            }
            else
            {
            }

        }
        else
        {
            for(int i=0; i<4; i++)
            {
                if(flag==false)
                {
                    plusx[count] = fuhao[i];
                    solve(count+1, four, plusx, flag);
                }
            }
        }
    }
    if(count==0 && flag==false)
    {
        cout<<"NONE";
    }
}

string trans(string str)
{
    if(str=="J")
    {
        str="11";
        return str;
    }
    else if(str=="Q")
    {
        str="12";
        return str;
    }
    else if(str=="K")
    {
        str="13";
        return str;
    }
    else if(str=="A")
    {
        str="1";
        return str;
    }
    else
    {
        return str;
    }
}

int main()
{
/*
    char str[100];
    cin.get(str, 100);
    int N = strlen(str);

    cout<<expression(str, N)<<endl;
    cout<<"true"<<endl;
*/
    string four[4];
    string tran[4];
    for(int i=0; i<4; i++)
    {
        cin>>four[i];
    }

    for(int i=0; i<4; i++)
    {
        if(four[i]=="joker" || four[i]=="JOKER")
        {
            cout<<"ERROR";
            return 0;
        }
        else
        {
            tran[i] = trans(four[i]);
        }
    }

    string plusx[3];
    bool flag = false;
    solve(0, tran, plusx, flag);

    if(flag)
        cout<<four[0]  + plusx[1] + four[1]+ plusx[2]+ four[2] + plusx[0]  + four[3];

    return 0;
}

  

时间: 2024-10-25 17:39:19

二十四点游戏的相关文章

Scala二十四点游戏

Scala二十四点游戏(1):表达式计算(一) Scala二十四点游戏(2):表达式计算(二) Scala二十四点游戏(3):表达式计算(三) Scala二十四点游戏(4):算法之一 Scala二十四点游戏(5):List简介 Scala二十四点游戏(6):实现全排列 Scala二十四点游戏(7):穷举可能的表达式 Scala二十四点游戏(8): 计算24的算法 Scala二十四点游戏(9): 完整的代码和计算结果 Scala二十四点游戏(10): 更简单的表达式算法 Scala二十四点游戏(1

[LeetCode] 24 Game 二十四点游戏

You have 4 cards each containing a number from 1 to 9. You need to judge whether they could operated through *, /, +, -, (, )to get the value of 24. Example 1: Input: [4, 1, 8, 7] Output: True Explanation: (8-4) * (7-1) = 24 Example 2: Input: [1, 2,

HNU 12886 Cracking the Safe 二十四点的判断

经典的一个题,今天竟然写跪了…… 题意: 给你4个数字,让你判断是否能通过四则运算和括号,凑成24点. 思路: 暴力枚举运算顺序和运算符. 代码: 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <cstdlib> 5 #include <cmath> 6 #include <algorithm> 7 #include <stri

二十四点问题

判断四个数是否可能通过加减乘得到二十四, 可以使用括号,思路极其像Expression Add Operators, 区别是在处理乘号的时候,一种是没有括号的,和Expression Add Operators一样,一种是带有括号的,其实就是把乘号当作加号来计算 public class Solution { public boolean solution(List<Integer> list) { return helper(list, 0); } public boolean helper

Java从零开始学二十四点(集合工具类Collections)

一.Collections简介 在集合的应用开发中,集合的若干接口和若干个子类是最最常使用的,但是在JDK中提供了一种集合操作的工具类 —— Collections,可以直接通过此类方便的操作集合 二.Collections类的常用方法及常量 No. 方法 类型 描述 1 public static final List EMPTY_LIST 常量 返回一个空的List集合 2 public static final Set EMPTY_SET 常量 返回空的Set集合 3 public sta

二十四点

本来想用后缀表达式,但是感觉代码太长了,算式也不复杂就懒得写,就模拟了下 过程,思路很简单,算两趟,第一次算乘除,第二次算加减 import java.util.LinkedList; import java.util.Scanner; /** * @Auther: Pengwen * @Date: 2019/12/8 21:29 * @Description: */ public class Main { public static void main(String[] args) { Sca

CSP201903-2二十四点

如图所示先处理乘号和除号,再处理加减. #include<bits/stdc++.h> using namespace std; bool res[101];int main(){ int n; cin>>n; int i,j,op1,op2; string inp; char op[3]; int nn[4]; int sum,nnum=0; int opnum=0; int nns[4]; char ops[3]; for(i=0;i<n;i++){ cin>>

201903-2 二十四点

n = int(input())result = []for i in range(n): temp = str(input()) if("x" in temp): temp = temp.replace("x","*") if("/" in temp): temp = temp.replace("/","//") if(eval(temp) == 24): result.append(

ActionScript3游戏中的图像编程(连载二十)

1.4.2 灰度的计算方法 回过头来看RGB,站在科学的角度来解释,它们确实也有更明亮的理由,因为下面一排色彩反射出来的色光总量是上一排色的两倍.      为此,作者曾自作聪明地发明了一条“原创”的灰度公式: Gray=(r+g+b)/3 哈哈,用色光总量来表达颜色的灰度想必就比较准确了吧!沾沾自喜一番以后,我还试着用这条自创的定律来转换这张测试图片,上下色块的灰度果然拉开了,可是很不幸地,左右相邻,边界分明的色块依然粘连在一块(图 1.30). 图 1.30 笔者“自创”的灰度转换 显然此法