24点运算__牛客网

Java

cxw_luca

我去，牛客也有bug啊

编辑于 2024-03-05 23:02:49 回复(1)

Java

觉醒了的刚子很想奋斗

使用dfs + 不同牌随机顺序求解。

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { 
            String inputData = in.nextLine();
            if(inputData.contains("joker") || inputData.contains("JOKER")) {
                System.out.println("ERROR");
                return;
            }
            String[] paiArray = inputData.split(" ");
            int tryCalNum = 0;
            boolean opResult = false;
            while(!opResult && tryCalNum < 50) {//暂时猜测计算50次一定得出结果，超出50次说明不能计算出24
                String[] paiRandomArray = new String[paiArray.length];//保存牌的随机顺序值
                int[] randomArray = getRandom();
                for(int i = 0; i < paiRandomArray.length; i ++) {
                    paiRandomArray[i] = paiArray[randomArray[i]];
                }
                int lastCalResult = getPaiRealVal(paiRandomArray[0]);
                StringBuilder opeSb = new StringBuilder();
                opResult = dfs(paiRandomArray, 0, lastCalResult, opeSb);
                opeSb.insert(0, paiRandomArray[0]);
                if(opResult) {
                    //计算成功24
                    System.out.println(opeSb.toString());
                    break;
                } 
                tryCalNum ++;
            }
            if(!opResult) {
                System.out.println("NONE");
            }
        }    
    }

    //深度优先搜索算法
    private static boolean dfs(String[] paiArray, int index, int lastCalResult, StringBuilder opeSb) {
        if(index == paiArray.length - 1 && lastCalResult == 24) {
            return true;
        }
        if(index + 1 <= paiArray.length - 1) {
            //加
            boolean result = dfs(paiArray, index + 1, lastCalResult + getPaiRealVal(paiArray[index + 1]), opeSb);
            if(result) {
                opeSb.insert(0, "+" + paiArray[index + 1]);
                //opeSb.append(getPaiRealVal(paiArray[index + 1]));
                return result;
            }
            //减 
            result = dfs(paiArray, index + 1, lastCalResult - getPaiRealVal(paiArray[index + 1]), opeSb);
            if(result) {
                opeSb.insert(0, "-" + paiArray[index + 1]);
                //opeSb.append(getPaiRealVal(paiArray[index + 1]));
                return result;
            }
            //乘
            result = dfs(paiArray, index + 1, lastCalResult * getPaiRealVal(paiArray[index + 1]), opeSb);
            if(result) {
                opeSb.insert(0, "*" + paiArray[index + 1]);
                //opeSb.append(getPaiRealVal(paiArray[index + 1]));
                return result;
            }
            //除
            int divResult = lastCalResult / getPaiRealVal(paiArray[index + 1]);
            int ysResult = lastCalResult % getPaiRealVal(paiArray[index + 1]);
            if(ysResult == 0) {
                //能被整除
                result = dfs(paiArray, index + 1, divResult, opeSb);
            } else {
                result = false;
            }
            if(result) {
                opeSb.insert(0, "/" + paiArray[index + 1]);
                //opeSb.append(getPaiRealVal(paiArray[index + 1]));
                return result;
            }
        }
        return false;
    }

    //获取牌的实际值
    public static int getPaiRealVal(String pai) {
        int result = 0;
        switch(pai) {
            case "2":
            case "3":
            case "4":
            case "5":
            case "6":
            case "7":
            case "8":
            case "9":
            case "10": result = Integer.valueOf(pai); break;
            case "J":  result = 11; break;
            case "Q":  result = 12; break;
            case "K":  result = 13; break;
            case "A":  result = 1; break;
        }
        return result;
    }

    //随机生成4个0到3不同的数
    public static int[] getRandom() {
        int[] resultData = new int[4];
        boolean[] findFlag = new boolean[4];
        int calData = (int)(Math.random() * (3 - 0 + 1) + 0);
        for(int i = 0; i < resultData.length; i ++) {
            while(findFlag[calData]) {
                calData = (int)(Math.random() * (3 - 0 + 1) + 0);
            }
            findFlag[calData] = true;
            resultData[i] = calData;
        }
        return resultData;
    }
}

发表于 2024-01-25 17:49:12 回复(0)

Java

牛客182275170号

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String[] sorts={
           "0123","1203","1230","2301","3012",
           "0132","1320","3201","2013",
           "0213","2130","1320","2301",
           "0231","2310","3102","1023",
           "0312","3120","2031",
           "0321","3210","2103","1032"
        };
        String[] inputs=new String[4];
        for(int i=0;i<4;i++){
            inputs[i]=in.next();
        }
        if(checkJOKER(inputs)){
            System.out.print("ERROR");
        }else{
            int[] nums=new int[4];
            for(int i=0;i<4;i++){
                String str=inputs[i];
                int num=0;
                if(str.equals("A")){
                    num=1;
                }else if(str.equals("J")){
                    num=11;
                }else if(str.equals("Q")){
                    num=12;
                }else if(str.equals("K")){
                    num=13;
                }else{
                    num=Integer.parseInt(str);
                }
                nums[i]=num;
            }
            System.out.print(get24allsort(nums,sorts));
        }
    }
    public static boolean checkJOKER(String[] strs){
        for(String str:strs){
            if(str.equals("JOKER")||str.equals("joker")){
                return true;
            }
        }
        return false;
    }
    public static String get24allsort(int[] nums,String[] sorts){
        String output="NONE";
        for(int i=0;i<sorts.length;i++){
            int[] tmp=new int[4];
            String sort=sorts[i];
            for(int j=0;j<4;j++){
                char a=sort.charAt(j);
                tmp[j]=nums[a-'0'];
            }
            if(!get24(tmp,24).equals("NONE")){
                output=get24(tmp,24);
                break;
            }
        }
        return output;
    }
    public static String getStr(int num){
        if(num==1){
            return "A";
        }else if(num==11){
            return "J";
        }else if(num==12){
            return "Q";
        }else if(num==13){
            return "K";
        }else {
            return ""+num;
        }
    }
    public static String get24(int[] nums,int n){
        if(nums.length==0 && n!=24){
            return "NONE";
        }else if(nums.length==1){
            if(n+nums[0]==24){
                return "+"+getStr(nums[0]);
            }else if(n-nums[0]==24){
                return "-"+getStr(nums[0]);
            }else if(n*nums[0]==24){
                return "*"+getStr(nums[0]);
            }else if(n/nums[0]==24){
                return "/"+getStr(nums[0]);
            }else{
                return "NONE";
            }
        }else {
            int todo=nums[0];
            int[] tmp=new int[nums.length-1];
            for(int i=0;i<tmp.length;i++){
                tmp[i]=nums[i+1];
            }
            if(nums.length<4){
                String todown=get24(tmp,n-todo);
                String toup=get24(tmp,n+todo);
                String toleft=get24(tmp,n/todo);
                String toright=get24(tmp,n*todo);
                if(todown.equals("NONE")&&toleft.equals("NONE")&&toup.equals("NONE")&&toright.equals("NONE")){
                    return "NONE";
                }else if(!todown.equals("NONE")){
                    return "-"+getStr(todo)+todown;
                }else if(!toup.equals("NONE")){
                    return "+"+getStr(todo)+toup;
                }else if(!toright.equals("NONE")){
                    return "*"+getStr(todo)+toright;
                }else {
                    return "/"+getStr(todo)+toleft;
                }
            }else{
                if(get24(tmp,todo).equals("NONE")){
                    return "NONE";
                }else{
                    return getStr(todo)+get24(tmp,todo);
                }
            }
        }
    }
}

运行时间39ms

占用内存10988KB

暴力求解全排序，有一个能过24就输出，调整了一下遍历全排序顺序可以过全部case，不知道答案该是怎样

发表于 2023-10-05 23:54:01 回复(0)

Java

练习时长两年半的太平湖水怪很理智

import java.io.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    private static String[] op = new String[] {"+", "-", "*", "/"};
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        while ((str = br.readLine()) != null) {
            String[] strArr = str.split(" ");
            int a = getInputNum(strArr[0]);
            int b = getInputNum(strArr[1]);
            int c = getInputNum(strArr[2]);
            int d = getInputNum(strArr[3]);
            if (a == -1 || b == -1 || c == -1 || d == -1) System.out.println("ERROR");
            else System.out.println(compute(a, b, c, d));
        }

    }
    private static String compute(int a, int b, int c, int d) {
        int[] intArr = {a, b, c, d};
        String[][] strArr = symbol();
        // 前4个用于找出4个运算数在不同位置的情况，即abcd、acbd、acdb等。再结合第5
        // 个for得到的运算符在不同位置情况，完成所有可能运算
        for (int i = 0; i < 4; i++) {// 第一个数字
            for (int j = 0; j < 4; j++) {// 第二个数字
                for (int k = 0; k < 4; k++) {// 第三个数字
                    for (int p = 0; p < 4; p++) {// 第四个数字
                        // 每次运算，只有4个参与运算的数不是intArr中同一个元素时才进行运算
                        if (i != j && i != k && i != p && j != k && j != p && k != p) {
                            // 这个for每一次遍历得到一组运算符
                            for (String[] symArr : strArr) {
                                int res = computeStep(intArr[i], intArr[j], symArr[0]);
                                res = computeStep(res, intArr[k], symArr[1]);
                                res = computeStep(res, intArr[p], symArr[2]);
                                if (res == 24) return getOutputStr(intArr[i]) + symArr[0] + 
                                                      getOutputStr(intArr[j]) + symArr[1] + 
                                                      getOutputStr(intArr[k]) + symArr[2] + 
                                                      getOutputStr(intArr[p]);
                            }
                        }
                    }
                }
            }
        }
        return "NONE";

    }
    // 将输入的字符转换为数字，用于计算
    private static int getInputNum(String str) {
        switch (str.toUpperCase()) {
            case "A":
                return 1;
            case "J":
                return 11;
            case "Q":
                return 12;
            case "K":
                return 13;
            case "JOKER":
                return -1;
            default:
                return Integer.parseInt(str);
        }
    }
    //将计算式的数字转换为字符串，用于拼接后输出
    private static String getOutputStr(int num) {
        switch (num) {
            case 1:
                return "A";
            case 11:
                return "J";
            case 12:
                return "Q";
            case 13:
                return "K";
            default:
                return String.valueOf(num);
        }
    }
    // 运算符可能的组合
    private static String[][] symbol() {
        // 4个数组成的运算式含3个运算符号，每个运算符位要有4种类型，可组合成64种形式
        String[][] symbol = new String[64][3];
        // 二维数组中的第row行
        int row = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                for (int k = 0; k < 4; k++) {
                    // 二维数组可以看成是多行的一维数组
                    symbol[row++] = new String[] {op[i], op[j], op[k]};
                }
            }
        }
        return symbol;
    }
    //单步计算
    private static int computeStep(int num1, int num2, String sym) {
        switch (sym) {
            case "+":
                return num1 + num2;
            case "-":
                return num1 - num2;
            case "*":
                return num1 * num2;
            case "/":
                return num1 / num2;
            default:
                return 0;
        }
    }
}

发表于 2023-07-11 13:07:11 回复(0)

Java

joyvvvv

public class Main {
    static String[] poker = {"0","A","2","3","4","5","6","7","8","9","10","J","Q","K","joker","JOKER"};
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
           String[] str = in.nextLine().split(" ");
           int[] num =new int[str.length];
           //初始化poker
           for(int i =0;i<str.length;i++){
               if(str[i].equals("joker")||str[i].equals("JOKER")){
                   System.out.println("ERROR");
                   return;
               }else if(str[i].equals("A")){
                   num[i]=1;
               }else if(str[i].equals("J")){
                   num[i]= 11;
               }else if(str[i].equals("Q")){
                   num[i]= 12;
               }else if(str[i].equals("K")){
                   num[i]= 13;
               }else if(Character.isDigit(str[i].charAt(0))){
                   num[i] = Integer.parseInt(str[i]);
               }else{
                   System.out.println("ERROR");
                   return;
               }
           }
           //创建boolean数组标记使用过的牌;
           boolean[] flg = new boolean[str.length];

           //如果没找到24点，打印NONE;
           if(!backTacking(num,flg,0,"",0)){
               System.out.println("NONE");
           }
        }
    }

    /**
     * 判断结果是否为24，如果有打印结果并返回true，没有返回false；
     * @param num 牌数组
     * @param flg 标记用过的牌
     * @param val 记录计算结果
     * @param result 记录算数表达式
     * @param count 记录使用牌数
     * @return
     */
    public static boolean backTacking(int[] num,boolean[] flg,int val,String result,int count){
        //所有牌都使用了，并且判断计算结果。
        if(count==num.length){
            if(val==24){
                System.out.println(result);
                return true;
            }else{
                return false;
            }
        }
        //排列每种组合，并进行计算。
        for(int i = 0 ;i<num.length;i++){
            if(flg[i]){
                continue;
            }else{
                //标记已使用；
                flg[i]=true;
                //三目判断是否为第一张牌，true，不计算，作为第一位。
                if(backTacking(num,flg,(count==0?num[i]:val+num[i]),(count==0?poker[num[i]]:result+"+"+poker[num[i]]),
                        count+1) ||
                        backTacking(num,flg,(count==0?num[i]:val-num[i]),(count==0?poker[num[i]]:result+"-"+poker[num[i]]),
                                count+1) ||
                        backTacking(num,flg,(count==0?num[i]:val*num[i]),(count==0?poker[num[i]]:result+"*"+poker[num[i]]),
                                count+1) ||
                        backTacking(num,flg,(count==0?num[i]:val/num[i]),(count==0?poker[num[i]]:result+"/"+poker[num[i]]),
                                count+1)
                ){
                    return true;
                }
                //回溯；
                flg[i]=false;
            }
        }
        return false;
    }
}

发表于 2023-05-05 21:02:29 回复(0)

Java

牛客604637229号

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息

public class Main {

public static int strToNum(String ss) {

int ret = -1;

if (ss.equalsIgnoreCase("joker")) { //注意1：如果是大小王，则返回-1

ret = -1;

} else if (ss.equals("A")) { //注意2：都要写成if else if else形式

ret = 1;

} else if (ss.equals("J")) {

ret = 11;

} else if (ss.equals("Q")) {

ret = 12;

} else if (ss.equals("K")) {

ret = 13;

} else {

ret = Integer.parseInt(ss);

}

return ret;

}

public static String numToStr(int num) {//注意3：输出要把数字转换成字符

String ret = "";

if (num == 1) {

ret = "A";

} else if (num == 11) {

ret = "J";

} else if (num == 12) {

ret = "Q";

} else if (num == 13) {

ret = "K";

} else {

ret = num + "";

}

return ret;

}

public static String getSuanshi(int[] nums) {

//先设定一个结果集合

List<TreeMap<Integer, String>> list = new

ArrayList<TreeMap<Integer, String>>(); //注意4：保存的是每次计算的值和算式的键值对；

TreeMap<Integer, String> tempMap = new

TreeMap<Integer, String>(); //注意5;存放每次的值-算式的临时值；

String suanshi = "";//返回算式结果

tempMap.put(nums[0], numToStr(nums[0]));//注意6：存放初始值-算式的键值对；

list.add(tempMap);//默认结果是第一个值

for (int i = 1; i < nums.length; i++) {

int after = nums[i];//后面的数

List<TreeMap<Integer, String>> templist = new

ArrayList<TreeMap<Integer, String>>();//注意7：设置临时集合，子循环结束后，要把旧结果清空，全加这个集合；

for (int j = 0; j < list.size(); j++) {

TreeMap<Integer, String> tree = list.get(j); //前面的数

int front = tree.firstEntry().getKey();

String suanshitemp = tree.firstEntry().getValue();//代表每次计算的算式

tempMap = new TreeMap<Integer, String>();//注意8，每次都要新new一个实例，否则会出错；

tempMap.put(front + after, suanshitemp + "+" + numToStr(after));

templist.add(tempMap);

tempMap = new TreeMap<Integer, String>();

tempMap.put(front - after, suanshitemp + "-" + numToStr(after));

templist.add(tempMap);

tempMap = new TreeMap<Integer, String>();

tempMap.put(front * after, suanshitemp + "*" + numToStr(after));

templist.add(tempMap);

tempMap = new TreeMap<Integer, String>();

tempMap.put(front / after, suanshitemp + "/" + numToStr(after));

templist.add(tempMap);

}

list.clear();//清空旧数据

list.addAll(templist);//注意9：清空旧数据，添加新数据；

}

for (int i = 0; i < list.size(); i++) {

int key = list.get(i).firstEntry().getKey();

String value = list.get(i).firstEntry().getValue();

if (key == 24) { //注意10：找到结果等于24的值，键值就是算式

suanshi = value;

break;

}

return suanshi;

}

//获取4位数组的12中排列顺序

public static int[][] getArrs(int[] nums) {

int[][] arrs = new int[4 * 3 * 2 * 1][4];//注意11:4个数排序组合有4 * 3 * 2 * 1种

int index = 0;

for(int i=0;i<nums.length;i++){

for(int j=0;j<nums.length;j++){

for(int k=0;k<nums.length;k++){

for(int m=0;m<nums.length;m++){

if(i!=j && i!=k && i!=m && j!=k && j!=m && k!=m) {//注意12：ijkm互相都不相等

arrs[index] = new int[]{nums[i],nums[j],nums[k],nums[m]};

index++;

}

return arrs;

}

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

// 注意 hasNext 和 hasNextLine 的区别

while (in.hasNext()) { // 注意 while 处理多个 case

String str = in.nextLine();

String[] strs = str.split(" ");

int[] nums = new int[strs.length];

boolean flag = true;

for (int i = 0; i < strs.length; i++) {

int num = strToNum(strs[i]);

if (num == -1) {

flag = false;

break;

}

nums[i] = num;

}

if (flag) {

int[][] arrs = getArrs(nums);

String suanshi = "";

int indexFlag = 0;

while (suanshi.isEmpty()) {//注意13：将每一种排列组合都放进去计算，直到找到算式是24的，或者排列组合算完

suanshi = getSuanshi(arrs[indexFlag]);

indexFlag++;

if (indexFlag == arrs.length) {

break;

}

if (!suanshi.isEmpty()) {

System.out.println(suanshi);

} else {

System.out.println("NONE");

}

} else {

System.out.println("ERROR");

}

发表于 2023-04-30 20:16:24 回复(0)

Java

不给offer不改名😡

import java.util.*;

public class Main {
    private static char[] ops = new char[]{'+', '-', '*', '/'};
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        HashMap<String, Integer> map = new HashMap<>();
        String[] strs = new String[4];
        map.put("3", 3);
        map.put("4", 4);
        map.put("5", 5);
        map.put("6", 6);
        map.put("7", 7);
        map.put("8", 8);
        map.put("9", 9);
        map.put("10", 10);
        map.put("J", 11);
        map.put("Q", 12);
        map.put("K", 13);
        map.put("A", 1);
        map.put("2", 2);
        double[] arr = new double[4];
        for(int i = 0; i < 4; i++){
            String str = in.next();
            if("joker".equals(str) || "JOKER".equals(str)){
                System.out.println("ERROR");
                return;
            }
            strs[i] = str;
            arr[i] = map.get(str);
        }
        ArrayList<ArrayList<Double>> list = new ArrayList<>();
        recursion(list, arr, 0);
        for(int p = 0; p < list.size(); p++){
            ArrayList<Double> innerList = list.get(p);
            for(int i = 0; i < 4; i++){
                for(int j = 0; j < 4; j++){
                    for(int k = 0; k < 4; k++){
                        double first = operation(innerList.get(0), innerList.get(1), ops[i]);
                        double second = operation(first, innerList.get(2), ops[j]);
                        if(operation(second, innerList.get(3), ops[k]) == 24){
                            System.out.println("" + zhuanhaun(innerList.get(0)) + ops[i] + zhuanhaun(innerList.get(1)) + ops[j] + zhuanhaun(innerList.get(2)) + ops[k] + zhuanhaun(innerList.get(3)));
                            return;
                        }
                    }
                }
            }
        }
        System.out.println("NONE");
    }

    public static String zhuanhaun(double x){
         int cur = (int) x;
         if(cur == 11)
            return "J";
         if(cur == 12)
            return "Q";
         if(cur == 13)
            return "K";
         if(cur == 1)
            return "A";
         return  String.valueOf(cur);
    }

    public static double operation(double x, double y, char op){
        switch(op){
            case('+'):
                return x + y;
            case('-'):
                return x - y;
            case('*'):
                return x * y;
            case('/'):
                return x / y;
        }
        return 0;
    }

    public static void recursion(ArrayList<ArrayList<Double>> list, double[] arr, int index){
        if(index == arr.length){
            ArrayList<Double> innerList = new ArrayList<>();
            for(double i : arr){
                innerList.add(i);
            }
            list.add(innerList);
            return;
        }else{
            for(int i = index; i < arr.length; i++){
                swap(arr, i , index);
                recursion(list, arr, index + 1);
                swap(arr, i , index);
            }
        }
    }


    public static void swap(double[] arr, int x, int y){
        double temp = arr[x];
        arr[x] = arr[y];
        arr[y] = temp;
    }
}

发表于 2023-04-09 16:04:18 回复(1)

Java

牛客653213510号

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    static boolean[] isVisited;
    static HashMap<String, Integer> table = new HashMap<>();
    static ArrayList<String> res;
    static boolean finish;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        for (int i = 2; i < 10; i++) {
            table.put(i + "", i);
        }
        table.put("J", 11);
        table.put("A", 1);
        table.put("Q", 12);
        table.put("K", 13);
        while (in.hasNextLine()) {
            // 注意 while 处理多个 case
            finish = false;
            isVisited = new boolean[4];
            res = new ArrayList<>();
            String[] str = in.nextLine().split(" ");
            int flag = 0;
            for (int i = 0; i < 4; i++) {
                if ("joker".equals(str[i].toLowerCase())) {
                    System.out.println("ERROR");
                    flag = 1;
                    break;
                }
            }
            if (flag == 0) {
                for (int i = 0; i < 4; i++) {
                    isVisited[i] = true;
                    process(1, table.get(str[i]), str[i], str);
                    isVisited[i] = false;
                }
                if (res.size() > 0) {
                    System.out.println(res.get(0));
                } else {
                    System.out.println("NONE");
                }

            }

        }
    }

    public static void process(int start, int sum, String s, String[] str) {
        if (start == 4) {
            if (sum == 24) {
                res.add(s);
                finish = true;
            }
            return;
        }
        if (!finish) {
            start++;
            for (int i = 0; i < 4; i++) {
                if (!isVisited[i]) {
                    isVisited[i] = true;
                    process(start, sum + table.get(str[i]), s + "+" + str[i], str);
                    process(start, sum - table.get(str[i]), s + "-" + str[i], str);
                    process(start, sum * table.get(str[i]), s + "*" + str[i], str);
                    process(start, sum / table.get(str[i]), s + "/" + str[i], str);
                    isVisited[i] = false;
                }
            }
        }

    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    static boolean[] isVisited;
    static HashMap<String, Integer> table = new HashMap<>();
    static ArrayList<String> res;
    static boolean finish;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        for (int i = 2; i < 10; i++) {
            table.put(i + "", i);
        }
        table.put("J", 11);
        table.put("A", 1);
        table.put("Q", 12);
        table.put("K", 13);
        while (in.hasNextLine()) {
            // 注意 while 处理多个 case
            finish = false;
            isVisited = new boolean[4];
            res = new ArrayList<>();
            String[] str = in.nextLine().split(" ");
            int flag = 0;
            for (int i = 0; i < 4; i++) {
                if ("joker".equals(str[i].toLowerCase())) {
                    System.out.println("ERROR");
                    flag = 1;
                    break;
                }
            }
            if (flag == 0) {
                for (int i = 0; i < 4; i++) {
                    isVisited[i] = true;
                    process(1, table.get(str[i]), str[i], str);
                    isVisited[i] = false;
                }
                if (res.size() > 0) {
                    System.out.println(res.get(0));
                } else {
                    System.out.println("NONE");
                }

            }

        }
    }

    public static void process(int start, int sum, String s, String[] str) {
        if (start == 4) {
            if (sum == 24) {
                res.add(s);
                finish = true;
            }
            return;
        }
        if (!finish) {
            start++;
            for (int i = 0; i < 4; i++) {
                if (!isVisited[i]) {
                    isVisited[i] = true;
                    process(start, sum + table.get(str[i]), s + "+" + str[i], str);
                    process(start, sum - table.get(str[i]), s + "-" + str[i], str);
                    process(start, sum * table.get(str[i]), s + "*" + str[i], str);
                    process(start, sum / table.get(str[i]), s + "/" + str[i], str);
                    isVisited[i] = false;
                }
            }
        }

    }
}

发表于 2023-03-21 23:20:09 回复(1)

Java

牛客164541665号

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String input = in.nextLine().toLowerCase();
            String[] fourDigital = input.split(" ");
            Main test = new Main();
            test.solve(fourDigital);
        }
    }

    private void solve(String[] fourDigital) {
        int len = fourDigital.length;
        int[] digital = new int[len];
        for (int i = 0; i < len; i++) {
            if ("joker".equals(fourDigital[i]) || "JOKER".equals(fourDigital[i])) {
                System.out.println("ERROR");
                break;
            }
            if ("a".equals(fourDigital[i])) {
                digital[i] = 1;
            } else if ("j".equals(fourDigital[i])) {
                digital[i] = 11;
            } else if ("q".equals(fourDigital[i])) {
                digital[i] = 12;
            } else if ("k".equals(fourDigital[i])) {
                digital[i] = 13;
            } else if (fourDigital[i].charAt(0) >= '0' && fourDigital[i].charAt(0) <= '9') {
                digital[i] = Integer.parseInt(fourDigital[i]);
            } else {
                System.out.println("ERROR");
                return;
            }
        }
        List<Compute> computes = new ArrayList<>();
        int add, sub, mul, div;
        Set<Integer> set = new HashSet();
        int max, min;
        for (int i = 0; i < len; i++)
            for (int j = 0; j < i; j++) {
                List<String> tmpExpression = new ArrayList<>();
                List<Integer> tmpResult = new ArrayList<>();
                max = Math.max(digital[i], digital[j]);
                min = Math.min(digital[i], digital[j]);
                add = max + min;
                sub = max - min;
                mul = max * min;

                tmpResult.add(add);
                tmpResult.add(sub);
                tmpExpression.add(max + "+" + min);
                tmpExpression.add(max + "-" + min);
                set.add(add);
                set.add(sub);
                if (!set.contains(mul)) {
                    tmpResult.add(mul);
                    tmpExpression.add(max + "*" + min);
                    set.add(mul);
                }
                if (min != 0 && set.contains((div = max / min))) {
                    tmpResult.add(div);
                    tmpExpression.add(max + "/" + min);
                }
                Compute compute = new Compute();
                compute.expression = tmpExpression;
                compute.result = tmpResult;
                computes.add(compute);
                set.clear();
            }
        String s = null;
        if ((s = trySolve(computes.get(0), digital[2], digital[3])) != null) {
            System.out.println(s);
            return;
        } else if ((s = trySolve(computes.get(1), digital[1], digital[3])) != null) {
            System.out.println(s);
            return;
        } else if ((s = trySolve(computes.get(2), digital[0], digital[3])) != null) {
            System.out.println(s);
            return;
        } else if ((s = trySolve(computes.get(3), digital[1], digital[2])) != null) {
            System.out.println(s);
            return;
        } else if ((s = trySolve(computes.get(4), digital[0], digital[2])) != null) {
            System.out.println(s);
            return;
        } else if ((s = trySolve(computes.get(5), digital[0], digital[1])) != null) {
            System.out.println(s);
            return;
        } else {
            System.out.println("NONE");
        }
    }

    private String trySolve(Compute compute1, int data3, int data4) {
        final List<String> expression1 = compute1.expression;
        final List<Integer> result1 = compute1.result;
        int len1 = result1.size();
        String result = null;
        for (int i = 0; i < len1; i++) {
            if (result1.get(i) + data3 + data4 == 24) {
                result = expression1.get(i) + "+" + data3 + "+" + data4;
            } else if (result1.get(i) + data3 - data4 == 24) {
                result = expression1.get(i) + "+" + data3 + "-" + data4;
            } else if ((result1.get(i) + data3) * data4 == 24) {
                result = expression1.get(i) + "+" + data3 + "*" + data4;
            } else if (data4 != 0 && (result1.get(i) + data3) / data4 == 24) {
                result = expression1.get(i) + "+" + data3 + "/" + data4;
            } else if (result1.get(i) - data3 + data4 == 24) {
                result = expression1.get(i) + "-" + data3 + "+" + data4;
            } else if (result1.get(i) - data3 - data4 == 24) {
                result = expression1.get(i) + "-" + data3 + "-" + data4;
            } else if ((result1.get(i) - data3) * data4 == 24) {
                result = expression1.get(i) + "-" + data3 + "*" + data4;
            } else if (data4 != 0 && (result1.get(i) - data3) / data4 == 24) {
                result = expression1.get(i) + "-" + data3 + "/" + data4;
            } else if ((result1.get(i) * data3) + data4 == 24) {
                result = expression1.get(i) + "*" + data3 + "+" + data4;
            } else if ((result1.get(i) * data3) - data4 == 24) {
                result = expression1.get(i) + "*" + data3 + "-" + data4;
            } else if ((result1.get(i) * data3) * data4 == 24) {
                result = expression1.get(i) + "*" + data3 + "*" + data4;
            } else if (data4 != 0 && (result1.get(i) * data3) / data4 == 24) {
                result = expression1.get(i) + "*" + data3 + "/" + data4;
            } else if (data3 != 0 && ((result1.get(i) / data3) + data4 == 24)) {
                result = expression1.get(i) + "/" + data3 + "+" + data4;
            } else if (data3 != 0 && ((result1.get(i) / data3) - data4 == 24)) {
                result = expression1.get(i) + "/" + data3 + "-" + data4;
            } else if (data3 != 0 && ((result1.get(i) / data3) * data4 == 24)) {
                result = expression1.get(i) + "/" + data3 + "*" + data4;
            } else if (data3 != 0 &&data4!=0&& ((result1.get(i) / data3) / data4 == 24)) {
                result = expression1.get(i) + "/" + data3 + "/" + data4;
            } else {
                continue;
            }
        }
        if (result != null) {
            result = result.replaceAll("11", "J").
                     replaceAll("12", "Q").
                     replaceAll("13", "K");
            if (result.contains("10")) {
                result = result.replaceAll("10", "?");
                result = result.replaceAll("1", "A");
                result = result.replaceAll("\\?", "10");
            } else {
                result = result.replaceAll("1", "A");
            }
        }
        return result;
    }

    private class Compute {
        private List<String> expression;
        private List<Integer> result;
    }
}

发表于 2023-03-11 17:43:35 回复(0)

Java

IceToSnow

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息

public class Main {

private static String[] opt = new String[]{"","",""};

private static HashMap<String,String> sMaps = new HashMap<>();

private static List<String> sResults = new ArrayList<>();

public static void main(String[] args) {

Scanner s = new Scanner(System.in);

String[] lines = s.nextLine().trim().split(" ");

for (int i =0;i<lines.length;i++){

if (lines[i].equalsIgnoreCase("J")){

lines[i] = "11";

sMaps.put(lines[i],"J");

}else if (lines[i].equalsIgnoreCase("Q")){

lines[i]="12";

sMaps.put(lines[i],"Q");

}else if (lines[i].equalsIgnoreCase("K")){

lines[i]="13";

sMaps.put(lines[i],"K");

}else if (lines[i].equalsIgnoreCase("A")){

lines[i]="1";

sMaps.put(lines[i],"A");

}else{

sMaps.put(lines[i],lines[i]);

}

if (lines[i].equalsIgnoreCase("joker")){

System.out.println("ERROR");

return;

}

int a = Integer.parseInt(lines[0]);

int b = Integer.parseInt(lines[1]);

int c = Integer.parseInt(lines[2]);

int d = Integer.parseInt(lines[3]);

int[] ints = new int[]{a, b, c, d};

List<int[]> data = new ArrayList<>();

//输出所有 a b c d可能的排列组合

//先从0位置取数，可以取4种,依次类推

for (int i =0;i<4;i++){

int[] tmp = new int[4];

tmp[0]=ints[i];

for (int j =0;j<3;j++){

int[] tmp1 = removeElements(ints,tmp[0]);

tmp[1]=tmp1[j];

for (int k=0;k<2;k++){

int[] tmp2 = removeElements(tmp1,tmp[1]);

tmp[2]=tmp2[k];

for (int l=0;l<1;l++){

int[] tmp3 =removeElements(tmp2,tmp[2]);

tmp[3]=tmp3[l];

int[] temp = new int[4];

temp[0]=tmp[0];

temp[1]=tmp[1];

temp[2]=tmp[2];

temp[3]=tmp[3];

data.add(temp);

}

for (int[] tmp : data){

cal(tmp[0],tmp,1);

}

if (sResults.isEmpty()){

System.out.println("NONE");

}else{

System.out.println(sResults.get(0));

}

private static int[] removeElements(int[] arr,int value){

int[] ints = new int[arr.length-1];

int i=0;

boolean first=true;//第一个遇到的删除，其他的应添加到队列里

for (int tmp : arr){

if (value!=tmp){

ints[i]=tmp;

i++;

}else{

if (first){

first=false;

}else{

ints[i]=tmp;

i++;

}

return ints;

}

public static int count=0;

private static int cal(int result,int[] ints,int index){

if (index>=4){

count++;

if (result==24){

String res ="" +getMappingString(ints[0]) +opt[0]

+getMappingString(ints[1])+opt[1]

+getMappingString(ints[2])+opt[2]

+getMappingString(ints[3]);

sResults.add(res);

}

return result;

}

// System.out.println("执行加法:"+result+",index="+index);

int add = result + ints[index];

opt[index-1]="+";

cal(add,ints,index+1);

int subtract =result - ints[index];

opt[index-1]="-";

cal(subtract,ints,index+1);

// System.out.println("执行减法:"+result+",index="+index);

int times = result * ints[index];

opt[index-1]="*";

cal(times,ints,index+1);

// System.out.println("执行乘法:"+result+",index="+index);

int division =result / ints[index];

opt[index-1]="/";

return cal(division,ints,index+1);

}

private static String getMappingString(int value){

return sMaps.get(value+"");

}

发表于 2022-11-11 14:45:18 回复(0)

Java

Ethan-

import java.util.*;

public class Main {
     public static HashMap<Integer,String> map = new HashMap<Integer,String>(){{
         put(1,"A");
         put(2,"2");
         put(3,"3");
         put(4,"4");
         put(5,"5");
         put(6,"6");
         put(7,"7");
         put(8,"8");
         put(9,"9");
         put(10,"10");
         put(11,"J");
         put(12,"Q");
         put(13,"K");
     }};
    public static String expression = "";
    public static boolean dfs(int arr[],int[] combs,boolean[] visited,int index){
        if(index==4) return backtrack(combs,combs[0],1,map.get(combs[0]));
        boolean bool=false;
        for(int i=0;i<4;i++){
            if(!visited[i]){
                visited[i]=true;
                combs[index]=arr[i];
                bool = bool||dfs(arr,combs,visited,index+1);
                visited[i]=false;
            }
        }
        return bool;
    }
    public static boolean backtrack(int arr[],int sum,int index,String str){
        if(index==4&&sum==24){
            expression = str;
            return true;
        }
        if(index==4) return false;
        return backtrack(arr,sum+arr[index],index+1,str+"+"+map.get(arr[index]))||backtrack(arr,sum-arr[index],index+1,str+"-"+map.get(arr[index]))
                   ||backtrack(arr,sum*arr[index],index+1,str+"*"+map.get(arr[index]))|| backtrack(arr,sum/arr[index],index+1,str+"/"+map.get(arr[index]));     
        
    }
    public static void main(String[] args) {
        Scanner sc =  new Scanner(System.in);
        int[] arr = new int[4];
        int i=0;
        boolean valid = true;

        while(sc.hasNext()){
            String s = sc.next();
            if(s.length()>1){
                valid = false;
                break;
            }
            char c = s.charAt(0);
            if(Character.isDigit(c)) arr[i]=c-'0';
            else{
                if(c=='J') arr[i]=11;
                else if(c=='Q') arr[i]=12;
                else if(c=='K') arr[i]=13;
                else arr[i]=1;
            }
            i++;
        }
        if(!valid)    System.out.println("ERROR");
        else if(dfs(arr,new int[4],new boolean[4],0)) System.out.println(expression);
        else System.out.println("NONE");
    }
}

发表于 2022-09-01 15:50:18 回复(1)

Java

牛客200498065号

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        System.out.println(isEqual24(line));
    }

    public static String isEqual24(String line) {
        String[] fuHao = new String[]{"+", "-", "*", "/"};
        String[] letters = line.split(" ");
        int[] nums = new int[letters.length];
        for (int i = 0; i < 4; i++) {
            if ("joker".equals(letters[i]) || "JOKER".equals(letters[i])) {
                return "ERROR";
            }
            nums[i] = transfer(letters[i]);
        }
        // 问题转化成：怎么将nums数组中的4个数组合成结果为24的表达式
        // 4个数，所以需要3个运算符号连接，每个运算符号有4种： + - * /
        for (int i = 0; i < 4; i++) {
            int a = nums[i];
            for (int j = 0; j < 4; j++) {
                int b = nums[j];
                if (j == i) continue;  // 排除同一个位置的元素
                for (int k = 0; k < 4; k++) {
                    int c = nums[k];
                    if (k == j || k == i) continue;
                    for (int l = 0; l < 4; l++) {
                        int d = nums[l];
                        if (l == i || l == j || l == k) continue;
                        for (int one = 0; one < 4; one++) {
                            int temp1 = 0;
                            switch (one) {
                                case 0:
                                    temp1 = a + b;
                                    break;
                                case 1:
                                    temp1 = a - b;
                                    break;
                                case 2:
                                    temp1 = a * b;
                                    break;
                                case 3:
                                    temp1 = a / b;
                                    break;
                            }
                            for (int two = 0; two < 4; two++) {
                                int temp2 = 0;
                                switch (two) {
                                    case 0:
                                        temp2 = temp1 + c;
                                        break;
                                    case 1:
                                        temp2 = temp1 - c;
                                        break;
                                    case 2:
                                        temp2 = temp1 * c;
                                        break;
                                    case 3:
                                        temp2 = temp1 / c;
                                        break;
                                }
                                for (int thr = 0; thr < 4; thr++) {
                                    int temp3 = 0;
                                    switch (thr) {
                                        case 0:
                                            temp3 = temp2 + d;
                                            break;
                                        case 1:
                                            temp3 = temp2 - d;
                                            break;
                                        case 2:
                                            temp3 = temp2 * d;
                                            break;
                                        case 3:
                                            temp3 = temp2 / d;
                                            break;
                                    }
                                    if (temp3 == 24) {
                                        String ss = a + fuHao[one] + b + fuHao[two] + c + fuHao[thr] + d;
                                        String res;
                                        res = ss.replace("13", "K");
                                        res = res.replace("12", "Q");
                                        res = res.replace("11", "J");
                                        res = res.replace("1", "A");
                                        res = res.replace("A0", "10");
                                        return res;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return "NONE";
    }

    public static int transfer(String str) {
        switch (str) {
            case "A":
                return 1;
            case "J":
                return 11;
            case "Q":
                return 12;
            case "K":
                return 13;
            default:
                return Integer.valueOf(str);
        }
    }
}

发表于 2022-08-17 10:48:28 回复(0)

Java

想退休的刚子又熬夜了

分享一种回溯的方法，每次传入一个数，对剩余三个数分别进行加减乘除计算，并通过string记录表达式

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        boolean flag = true;
        if(s.contains("joker")||s.contains("JOKER")){
            flag = false;
            System.out.println("ERROR");
        }
        if(flag){
            String[] strArr = s.split(" ");
            int[] arr = new int[strArr.length];
            for(int i=0;i<strArr.length;i++){
                switch (strArr[i]){
                    case "J":
                        arr[i]=11;
                        break;
                    case "Q":
                        arr[i]=12;
                        break;
                    case "K":
                        arr[i]=13;
                        break;
                    case "A":
                        arr[i]=1;
                        break;
                    default:
                        arr[i]=Integer.parseInt(strArr[i]);
                        break;
                }
            }
            boolean[] vis = new boolean[arr.length];
            StringBuffer buffer = new StringBuffer();
            for(int i=0;i<arr.length;i++){
                int tmp = arr[i];
                vis[i]  = true;
                if(dfs(arr, strArr,vis, 1, tmp, strArr[i], buffer)){
                    break;
                }
                vis[i]=false;
            }
            if(buffer.length()==0){
                System.out.println("NONE");
            }else{
                System.out.println(buffer.toString());
            }
        }

    }
    public static boolean dfs(int[] arr,String[] strArr,boolean[] vis,int count,int sum,String s,StringBuffer buffer){
        if(count==4){
            if(sum==24){
                buffer.append(s);
                return true;
            }else{
                return false;
            }
        }
        for(int i=0;i<arr.length;i++){
            if(vis[i])continue;
            vis[i]=true;
            if(dfs(arr, strArr,vis, count + 1, sum + arr[i], s + "+"+strArr[i], buffer)){
                return true;
            }

            if(dfs(arr, strArr,vis, count + 1, sum - arr[i], s + "-"+strArr[i], buffer)){
                return true;
            }

            if(dfs(arr, strArr,vis, count + 1, sum * arr[i], s + "*"+strArr[i], buffer)){
                return true;
            }

            if(arr[i]!=0&&dfs(arr, strArr,vis, count + 1, sum / arr[i], s + "/"+strArr[i], buffer)){
                return true;
            }
            vis[i]=false;
        }
        return false;
    }

发表于 2022-06-22 10:38:18 回复(0)

Java

牛客496636535号

K Q 6 K 这个用例为啥输出NONE，明明有解法K-Q/6+K呀，求解答

发表于 2022-06-18 18:19:52 回复(2)

Java

牛客340125754号

import java.util.Scanner;
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        String s = in.nextLine();
        String[] arr =   s.split(" ");
        int[] arrInt = new int[arr.length];
        boolean isErr = false;
        for (int i = 0; i < arr.length; i++) {
            String ss = arr[i];

            if (ss.equals("J")) {
                arrInt[i] = 11;
            } else  if (ss.equals("Q")) {
                arrInt[i] = 12;
            } else  if (ss.equals("K")) {
                arrInt[i] = 13;
            } else  if (ss.equals("A")) {
                arrInt[i] = 1;
            } else  if (ss.equals("joker")) {
                isErr = true;
                break;
            } else  if (ss.equals("JOKER")) {
                isErr = true;
                break;
            } else {
                arrInt[i] = Integer.parseInt(ss);
            }
        }
        if (isErr) {
            System.out.println("ERROR");
            return;
        }
        String[] somp = new String[4];
        somp[0] = "+";
        somp[1] = "-";
        somp[2] = "*";
        somp[3] = "/";
        boolean isOk=false;
        String ret="";
        List<String> mList=new ArrayList();
        for (int i = 0; i < 4; i++ ) {
            for (int j = 0; j< 4; j++ ) {
                for (int k = 0; k < 4; k++ ) {
                 for (int i1 = 0; i1 < 4; i1++) {
                        for (int j1 = 0; j1 < 4; j1++) {
                            int t = arrInt[i1];
                            arrInt[i1] = arrInt[j1];
                            arrInt[j1] = t;
//                            System.out.println(Arrays.toString(arrInt));
//                            ret = int2S(arrInt[0]) + somp[i] + int2S(arrInt[1]) + somp[j] + int2S(arrInt[2]) + somp[k] + int2S(arrInt[3]);

                            float sum = cacl(arrInt[0], arrInt[1], somp[i]);
                            sum = cacl(sum, arrInt[2], somp[j]);
                            sum = cacl(sum, arrInt[3], somp[k]);
                           // System.out.println(ret+"==="+sum);
                            if (sum == 24) {

                                ret = int2S(arrInt[0]) + somp[i] + int2S(arrInt[1]) + somp[j] + int2S(arrInt[2]) + somp[k] + int2S(arrInt[3]);
                                isOk = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        if(isOk){
              System.out.println(ret); 
        }else{
              System.out.println("NONE");
        }
    }
    
    public static float cacl(float a,int b,String type){
        if(type.equals("+"))return a+b;
          if(type.equals("-"))return a-b;
          if(type.equals("*"))return a*b;
          if(type.equals("/"))return a/b;
        return 0;
    }
    
    public static String int2S(int n){
        if(n==11 )return "J";
        if(n==12 )return "Q";
        if(n==13 )return "K";
        if(n==1 )return "A";
         return n+"";
    }
    
    
    
}

发表于 2022-05-20 14:34:49 回复(0)

24点运算

输入描述:

输出描述:

输入

输出

说明

输入

输出

说明

输入

输出

说明

输入

输出

说明

问题信息

热门推荐

通过挑战的用户

相关试题