个人中心
gpt4 book ai didi

Java编写的24点纸牌游戏

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 24 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java编写的24点纸牌游戏由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

任意4个1-13数字，加减乘除计算24点.

实现原理:

1）排列组合4个数字 2）计算每次排列组合的可能性 。

Cal24.java 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
import java.util.HashSet;
import java.util.Set;
 
 
public class Cal24 {
 
   private static final double precision = 0.00001 ;
   private static final int target = 24 ;
   
 
   public String[] execute(String[] inputs) {
     int [] digits = new int [ 4 ];
     for ( int i = 0 ; i < inputs.length; i++) {
       digits[i] = Integer.valueOf(inputs[i]);
     }
     return new String[]{calc(digits)};
   }
 
   
   
   private String calc( final int data[]){
     final Set<String> out = new HashSet<String>();
     Combination digit = new Combination() {
       
       @Override
       protected void handle( int [] result) {
         final int [] r = result;
         Combination oper = new Combination(){
           @Override
           protected void handle( int [] c) {
             double x = r[ 0 ];
             for ( int i = 0 ; i < r.length - 1 ; i++) {
               x = doCalculate(x, r[i + 1 ], c[i]);
             }
             if (Math.abs(Math.abs(x) - target) < precision || Math.abs(Math.abs( 1 /x) - target) < precision){
               StringBuilder sb = new StringBuilder();
               for ( int j = 0 ; j < r.length; j++) {
                 sb.append(r[j]);
                 if (j != r.length - 1 ){
                   sb.append(getOperation(c[j]));
                 }
               }
               out.add(sb.toString());
             }
             
           }
         };
         oper.combine( new int []{ 0 , 1 , 2 , 3 }, data.length - 1 , true );
         
       }
     };
     
     digit.combine(data);
     
     StringBuilder sb = new StringBuilder();
     for (String string : out) {
       sb.append(string);
       sb.append( "\n" );
     }
     return sb.toString();
   }
   
   
   
   
   private double doCalculate( double x, double y, int operation){
     switch (operation) {
     case 0 :
       return x + y;
     case 1 :
       return x - y;
     case 2 :
       return x * y;
     case 3 :
       return x / y;
     default :
       return 0 ;
     }
   }
   
   private static String getOperation( int operation){
     switch (operation) {
     case 0 :
       return "+" ;
     case 1 :
       return "-" ;
     case 2 :
       return "*" ;
     case 3 :
       return "/" ;
     default :
       return "" ;
     }
   }
 
 
   public static void main(String[] args) {
     System.out.println( new Cal24().calc( new int []{ 1 , 5 , 5 , 5 }));
   }
}

Combination.java 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public abstract class Combination {
   private boolean repeat;
   private int total = 0;
   
   public void combine(int data[]){
     combine(data, data.length, false );
   }
   
   public void combine(int data[], int count){
     combine(data, count, false );
   }
   
   public void combine(int data[], int count, boolean repeat){
     this .repeat = repeat;
     int times = data.length;
     int size = (int)Math.pow(times, count);
     for (int i = 0; i < size; i++) {
       int[] result = toArray(data, i, count);
       if (result != null ){
         handle(result);
         total ++;
       }
     }
   }
   
   
   private int[] toArray(int data[], int i, int count){
     int [] indices = new int[count];
     int times = data.length;
     for (int j = 0; j < count; j++) {
       int temp = 0;
       if (i > 0){
         temp = i%times;
         i = (i - temp)/times;
       }
       indices[j] = temp;
     }
     
     
     if (!repeat){
       //remove repetition
       for (int x = 0; x < count; x++) {
         for (int y = 0; y < count; y++){
           if (x != y){
             if (indices[x] == indices[y])
               return null ;
           }
         }
       }
     }
     
     int [] result = new int[count];
     for (int x = 0; x < count; x++) {
       int selected = data[indices[x]];
       result[x] = selected;
     }
     
     return result;
   }
   
   public int getTotal() {
     return total;
   }
   protected abstract void handle(int[] result);
}

以上所述就是本文的全部内容了，希望大家能够喜欢.

最后此篇关于Java编写的24点纸牌游戏的文章就讲到这里了,如果你想了解更多关于Java编写的24点纸牌游戏的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

24 4 0
文章推荐： 编写android拨打电话apk应用实例代码
文章推荐： 十个最常见的Java字符串问题(翻译)
文章推荐： java实现简单美女拼图游戏
文章推荐： java使用OGEngine开发2048
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com