java24点游戏的简单介绍

博主：adminadmin 2023-01-08 08:06:11 647

今天给各位分享java24点游戏的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

java算24点代码：输入4个数算24点，能够在命令提示符下就可以运行。100多

import java.util.Scanner;

/** 给定4个数字计算24 */

public class Core {

private double expressionResult = 24;

// private int maxLine=10;

private boolean error = true;

private double numbers[] = new double[4];

public Object resultReturn;

/**

* 该对象拥有3个私有变量 expressionResult,所需结果 maxLine,输出结果每页行数 error,是否出错

* numbers[4],记录用来运算的4个数

*

* 其次,该对象拥有以下方法供外部调用 setNumbers(double[] 运算的数) 输入用来运算的数,4个时才能计算,无返回

* setMaxLine(int 行数) 输入每页的行数,无返回 getMaxLine() 返回每页的行数,类型为int

* setExpressionResult(double 所需结果) 输入所需结果,无返回 getExpressionResult()

* 返回所需结果,类型为double getExpression() 返回可得出所需结果的表达式,类型为字符串数组

*

* 最后,私有方法均为计算与表达式转换部分

*/

// 测试使用

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int[] arr = new int[4];

System.out.print("输入第一个数：");

arr[0] = scanner.nextInt();

System.out.print("输入第二个数：");

arr[1] = scanner.nextInt();

System.out.print("输入第三个数：");

arr[2] = scanner.nextInt();

System.out.print("输入第四个数：");

arr[3] = scanner.nextInt();

Core s = new Core();

s.setNumbers(arr);

String[] output = s.getExpression();

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

System.out.println(output[i]);

}

}

/** 设定被计算的四个数，由于是数组，所以具有容错功能(不为4个数) */

public void setNumbers(double[] n) {

if (n.length == 4) {

error = false;

numbers = n;

} else

error = true;

}

public void setNumbers(int[] n) {

if (n.length == 4) {

error = false;

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

numbers[i] = n[i];

}

} else

error = true;

}

/** 设定每页显示的行数 */

// public void setMaxLine(int n) {

// if (n0) {

// maxLine=n;

// }

// }

// /** 返回每页显示的行数 */

// public int getMaxLine() {

// return maxLine;

// }

/** 设定需要得到的结果 */

public void setExpressionResult(double n) {

expressionResult = n;

}

/** 返回所需结果 */

public double expressionResult() {

return expressionResult;

}

/** 返回符合条件的表达式 */

public String[] getExpression() {

if (!error) {

String[] expression = calculate(numbers);

return expression;

} else

return new String[] { "出错了,输入有误" };

}

/** cal24()，输出结果为24的表达式 */

private String[] calculate(double[] n) {

if (n.length != 4)

return new String[] { "Error" };

double[] n1 = new double[3];

double[] n2 = new double[2];

String[] resultString = new String[1024]; // 最多1000组解,暂时未溢出

int count = 0;

boolean isRepeat = false;

for (int t1 = 0; t1 6; t1++) {

for (int c1 = 0; c1 6; c1++) {

for (int t2 = 0; t2 3; t2++) {

for (int c2 = 0; c2 6; c2++) {

for (int c3 = 0; c3 6; c3++) {

if ((c1 / 3 == c2 / 3 (c1 % 3) * (c2 % 3) != 0)

|| (c2 / 3 == c3 / 3 (c2 % 3) * (c3 % 3) != 0)

|| (c1 / 3 == c3 / 3

(c1 % 3) * (c3 % 3) != 0 t2 == 2)) {

// 去除连减连除的解,因为x/(y/z)=x*z/y

continue;

}

n1 = cal1(n, t1, c1);

n2 = cal2(n1, t2, c2);

double result = cal(n2[0], n2[1], c3);

if ((result - expressionResult) 0.00000001

(expressionResult - result) 0.00000001) {

resultString[count] = calString(n, t1, c1, t2,

c2, c3)

+ "=" + (int) expressionResult;

for (int i = 0; i count; i++) {

isRepeat = false;

if (resultString[i]

.equals(resultString[count])) { // 去除完全重复的解

isRepeat = true;

break; // 提前退出循环

}

}

if (c1 == c2 c2 == c3 c1 % 3 == 0

t1 + t2 != 0) { // 连加连乘

isRepeat = true;

}

if (!isRepeat) {

count++;

}

}

}

}

}

}

}

if (count == 0)

return new String[] { "该组数无解" };

String[] resultReturn = new String[count];

System.arraycopy(resultString, 0, resultReturn, 0, count);

return resultReturn;

}

/** cal1()，将4个数计算一次后返回3个数 */

private double[] cal1(double[] n, int t, int c) { // t为原来的t1，c为原来的c1

double[] m = new double[3];

switch (t) {

case 0:

m[1] = n[2];

m[2] = n[3];

m[0] = cal(n[0], n[1], c);

break;

case 1:

m[1] = n[1];

m[2] = n[3];

m[0] = cal(n[0], n[2], c);

break;

case 2:

m[1] = n[1];

m[2] = n[2];

m[0] = cal(n[0], n[3], c);

break;

case 3:

m[1] = n[0];

m[2] = n[3];

m[0] = cal(n[1], n[2], c);

break;

case 4:

m[1] = n[0];

m[2] = n[2];

m[0] = cal(n[1], n[3], c);

break;

default:

m[1] = n[0];

m[2] = n[1];

m[0] = cal(n[2], n[3], c);

}

return m;

}

/** cal2()，将3个数计算一次后返回2个数 */

private double[] cal2(double[] n, int t, int c) { // t为原来的t2，c为原来的c2

double[] m = new double[2];

switch (t) {

case 0:

m[1] = n[2];

m[0] = cal(n[0], n[1], c);

break;

case 1:

m[1] = n[1];

m[0] = cal(n[0], n[2], c);

break;

default:

m[1] = n[0];

m[0] = cal(n[1], n[2], c);

}

return m;

}

/** cal()，将2个数计算后返回结果 */

private double cal(double n1, double n2, int c) { // n1,n2为运算数，c为运算类型

switch (c) {

case 0:

return n1 + n2;

case 1:

return n1 - n2;

case 2:

return n2 - n1;

case 3:

return n1 * n2;

case 4:

if (n2 == 0)

return 9999; // 使计算结果必不为24

else

return n1 / n2;

default:

if (n1 == 0)

return 9999; // 同上

else

return n2 / n1;

}

}

/** calString()，输出表达式 */

private String calString(double[] n, int t1, int c1, int t2, int c2, int c3) {

String[] nString = new String[4];

switch (t1) {

case 0:

nString[0] = calString2("" + (int) n[0], "" + (int) n[1], c1);

nString[1] = "" + (int) n[2];

nString[2] = "" + (int) n[3];

break;

case 1:

nString[0] = calString2("" + (int) n[0], "" + (int) n[2], c1);

nString[1] = "" + (int) n[1];

nString[2] = "" + (int) n[3];

break;

case 2:

nString[0] = calString2("" + (int) n[0], "" + (int) n[3], c1);

nString[1] = "" + (int) n[1];

nString[2] = "" + (int) n[2];

break;

case 3:

nString[0] = calString2("" + (int) n[1], "" + (int) n[2], c1);

nString[1] = "" + (int) n[0];

nString[2] = "" + (int) n[3];

break;

case 4:

nString[0] = calString2("" + (int) n[1], "" + (int) n[3], c1);

nString[1] = "" + (int) n[0];

nString[2] = "" + (int) n[2];

break;

default:

nString[0] = calString2("" + (int) n[2], "" + (int) n[3], c1);

nString[1] = "" + (int) n[0];

nString[2] = "" + (int) n[1];

}

if ((c2 / 3 c1 / 3 (t2 != 2 || c2 / 3 == c3 / 3))

|| ((c3 / 3 c1 / 3 + c2 / 3) t2 == 2)

|| (c3 == 1 c1 / 3 == 0)) // 特定情况下加上一个括号*****************************

nString[0] = '(' + nString[0] + ')';

switch (t2) {

case 0:

nString[0] = calString2(nString[0], "" + nString[1], c2);

nString[1] = nString[2];

break;

case 1:

nString[0] = calString2(nString[0], nString[2], c2);

break;

default:

nString[3] = nString[0];

nString[0] = calString2(nString[1], nString[2], c2);

nString[1] = nString[3];

}

if (c3 / 3 c2 / 3 || (c3 == 2 nString[0].indexOf('+') = 0)) // 特定情况下加上一个括号*****************************

nString[0] = '(' + nString[0] + ')';

return calString2(nString[0], nString[1], c3);

}

/** calString()，根据符号输出一部运算表达式 */

private String calString2(String n1, String n2, int c) {

switch (c) {

case 0:

return n1 + '+' + n2;

case 1:

return n1 + '-' + n2;

case 2:

return n2 + '-' + n1;

case 3:

return n1 + '*' + n2;

case 4:

return n1 + '/' + n2;

default:

return n2 + '/' + n1;

}

}

}

求设计一个程序，24点游戏 游戏规则：从键盘输入任意1-13的4个数，然后用算术运算符“+、-、*

#include stdio.h

#include math.h

double num[4];//存储4个数字

double pre = 1E-6; //精度

int go(int n)

{

int i,j;

if(n==1)

{

if(fabs(num[0]-24)1E-6)

return 1;

else

return 0;

}

else

{

for(i=0;in-1;i++)

{

double a=num[i];

double b=num[i+1];

for(j=i+1;jn-1;j++)

{

num[j]=num[j+1];

}

num[i]=a+b;

if(go(n-1)) return 1;

num[i]=a-b;

if(go(n-1)) return 1;

num[i]=a*b;

if(go(n-1)) return 1;

if(b!=0)

{

num[i]=a/b;

if(go(n-1)) return 1;

}

for(j=n-1;ji+1;j--)

{

num[j]=num[j-1];

}

num[i+1]=b;

num[i]=a;

}

}

return 0;

}

int main()

{

double sum;

int i;

do

{

sum=0;

for(i=0;i4;i++)

{

scanf("%lf",num[i]);

sum+=num[i];

}

if(sum1)

{

if(go(4))

printf("YES\n");

else

printf("NO\n");

}

}while(sum1);

return 0;

}

24点纸牌游戏 求高手给加一个含括号的四则运算算法

import java.awt.*;

import javax.swing.*;

import java.util.*;

import java.awt.event.*;

public class PointCardFrame extends JFrame {

public static final double EPISON = 1E-6;

private CenterPanel centerpanel = new CenterPanel();

private HeadPanel headpanel = new HeadPanel();

private TailPanel tailpanel = new TailPanel();

public PointCardFrame() {

HeadPanel headpanel = new HeadPanel();

TailPanel tailpanel = new TailPanel();

add(headpanel, BorderLayout.NORTH);

add(centerpanel, BorderLayout.CENTER);

add(tailpanel, BorderLayout.SOUTH);

}

public static void main(String[] args) {

JFrame frame = new PointCardFrame();

frame.setTitle("24纸牌");

frame.pack(); //根据窗口里面的布局及组件的preferedSize来确定frame的最佳大小

frame.setLocationRelativeTo(null);

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setVisible(true);

}

public class HeadPanel extends JPanel {

private JButton jbtRefresh = new JButton("发牌");

private JButton jbtSolution = new JButton("答案");

private JTextField textField = new JTextField(15);

private String[] operator = { "+", "-", "*", "/", "(", ")" };

private double[] number = new double[4];

private String[] exp = new String[4];

public HeadPanel() {

add(jbtSolution, BorderLayout.WEST);

add(textField, BorderLayout.CENTER);

add(jbtRefresh, BorderLayout.EAST);

jbtRefresh.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

centerpanel.removeAll();

centerpanel.Display();

centerpanel.updateUI();

}

});

jbtSolution.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

number[0] = (double) centerpanel.cardvaule[0];

number[1] = (double) centerpanel.cardvaule[1];

number[2] = (double) centerpanel.cardvaule[2];

number[3] = (double) centerpanel.cardvaule[3];

exp[0] = String.valueOf(centerpanel.cardvaule[0]);

exp[1] = String.valueOf(centerpanel.cardvaule[1]);

exp[2] = String.valueOf(centerpanel.cardvaule[2]);

exp[3] = String.valueOf(centerpanel.cardvaule[3]);

if (is24(4)) {

textField.setText(exp[0]);

} else

textField.setText("没有答案");

}

});

}

public boolean is24(int n) {

if (n == 1)

return (Math.abs(number[0] - 24) EPISON);

for (int i = 0; i n; i++) {

for (int j = i + 1; j n; j++) { // 进行组合

double a, b;

String expa, expb;

a = number[i];

b = number[j];

number[j] = number[n - 1];

expa = exp[i];

expb = exp[j];

exp[j] = exp[n - 1];

exp[i] = "(" + expa + "+" + expb + ")";

number[i] = a + b;

if (is24(n - 1))

return true;

exp[i] = "(" + expa + "-" + expb + ")";

number[i] = a - b;

if (is24(n - 1))

return true;

exp[i] = "(" + expb + "-" + expa + ")";

number[i] = b - a;

if (is24(n - 1))

return true;

exp[i] = "(" + expa + "*" + expb + ")";

number[i] = a * b;

if (is24(n - 1))

return true;

if (b != 0) {

exp[i] = "(" + expa + "/" + expb + ")";

number[i] = a / b;

if (is24(n - 1))

return true;

}

if (a != 0) {

exp[i] = "(" + expb + "/" + expa + ")";

number[i] = b / a;

if (is24(n - 1))

return true;

}

number[i] = a; // 恢复

number[j] = b;

exp[i] = expa;

exp[j] = expb;

}

}

return false;

}

}

public class CenterPanel extends JPanel {

private int[] cardvaule = new int[4];

private int[] usedcard = new int[4];

public CenterPanel() {

loop: for (int i = 0; i 4; i++) {

Random random = new Random();

int radomnumber = random.nextInt(13) + 1;

for (int k = 0; k i; k++) {

if (usedcard[k] == radomnumber) {

i--;

continue loop;

}

}

String string = String.valueOf(radomnumber);

add(new JLabel(new ImageIcon("D:\\card\\" + string + ".JPG")));

usedcard[i] = radomnumber;

if (radomnumber % 13 != 0)

cardvaule[i] = radomnumber % 13;

else

cardvaule[i] = 13;

}

}

public void Display() {

usedcard[0] = -1;

usedcard[1] = -1;

usedcard[2] = -1;

usedcard[3] = -1;

loop: for (int i = 0; i 4; i++) {

Random random = new Random();

int radomnumber = random.nextInt(13) + 1;

for (int k = 0; k i; k++) {

if (usedcard[k] == radomnumber) {

i--;

continue loop;

}

}

String string = String.valueOf(radomnumber);

add(new JLabel(new ImageIcon("D:\\card\\" + string + ".JPG")));

usedcard[i] = radomnumber;

if (radomnumber % 13 != 0)

cardvaule[i] = radomnumber % 13;

else

cardvaule[i] = 13;

}

}

}

public class TailPanel extends JPanel {

private JLabel message = new JLabel("请输入算式");

private JTextField textField = new JTextField("", 15);

private JButton jbtVerify = new JButton("计算");

private int result;

public TailPanel() {

add(message, BorderLayout.WEST);

add(textField, BorderLayout.CENTER);

add(jbtVerify, BorderLayout.EAST);

jbtVerify.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String experssion = textField.getText();

if (result == 24)

JOptionPane.showMessageDialog(null, "结果是 "

+ result + " 答对了 ! ^_^");

else if (result == -1999)

JOptionPane.showMessageDialog(null, "错误的表达式");

else

JOptionPane.showMessageDialog(null, "结果是"

+ result + " 答错了! _");

}

});

}

}

}

这个是源代码！

6.6.9.10算24点怎么算

算24点的技巧:有基本算式法，特性求解法，倍数法，巧用分数法，具体解法如下：

1、基本算式法

利用2*12=24,3*8=24,4*6=24求解。一般情况下，先要看四张牌中是否有2,3,4,6,8，Q，如果有，考虑用乘法，将剩余的三个数凑成对应数。如3,3,6,10可组成（10-6/3）*3=24。如果没有2,3,4,6,8，Q，看是否能先把两个数凑成其中之一，再求解24。

2、特性求解法

1）利用0、11的运算特性求解。如（3,4，4,8）可组成3*8+4-4=24。

2）如果有两个相同的6，剩下的只要能凑成2,3,4,5都能算出24，比如6,6,3可以3*6+6=24。同理，如果有两个相同的8，剩下的只要能凑成2,3,4就能算出24。

如（2,5,8,8），（5-2）*8=24，多一个8，可以用乘法的分配律消去8，将算式改为5*8-2*8，将多余的8消去；如果有两个相同的Q，剩下的只要能凑成1,2,3就能算出24，如（9，J,Q,Q）可以12*11-12*9=24。

3、倍数法

利用24的倍数求解2*24=48,3*24=72,4*24=96,5*24=120,6*24=144想办法去凑48,72,96,120,144来求解。在具体的运算过程中，先将数乘得很大，最后再除以一个数得24。

4、巧用分数法

利用24的分数求解。先将数算成分数或小数，最后乘以一个数得24。用一个数除以一个分数，相当于乘以这个数的倒数，最后得24。

24点的口诀为见3凑8，见4凑6，见2凑12等等。

稍微特殊点的规律：2乘10+4，15+9，21+3，14+10等。

扩展资料：

“算24点”作为一种扑克牌智力游戏，还应注意计算中的技巧问题。计算时，我们不可能把牌面上的4个数的不同组合形式——去试，更不能瞎碰乱凑。这里向大家介绍几种常用的、便于学习掌握的方法：

1．利用3×8＝24、4×6＝24求解。

把牌面上的四个数想办法凑成3和8、4和6，再相乘求解。如3、3、6、10可组成（10—6÷3）×3＝24等。又如2、3、3、7可组成（7＋3—2）×3＝24等。实践证明，这种方法是利用率最大、命中率最高的一种方法。

2．利用0、11的运算特性求解。

如3、4、4、8可组成3×8＋4—4＝24等。又如4、5、J、K可组成11×（5—4）＋13＝24等。

3．在有解的牌组中，用得最为广泛的是以下六种解法：（我们用a、b、c、d表示牌面上的四个数）

①(a—b）×（c＋d）

如（10—4）×（2＋2）＝24等。

②（a＋b）÷c×d

如（10＋2）÷2×4＝24等。

③（a－b÷c）×d

如（3—2÷2）×12＝24等。

④（a＋b－c）×d

如（9＋5—2）×2＝24等。

⑤a×b＋c—d

如11×3＋l—10＝24等。

⑥（a－b）×c＋d

如（4—l）×6＋6＝24等。

游戏时，同学们不妨按照上述方法试一试。

需要说明的是：经计算机准确计算，一副牌（52张）中，任意抽取4张可有1820种不同组合，其中有458个牌组算不出24点，如A、A、A、5。

经典24点

4

4

10

10

这个难点在于先要算出一个很大的数，就是100，然后再通过减4，除4就可以得到24点：(10×10-4)÷4=24。

6

9

9

10

这个也要先算大数90，然后除6，再加9即可得24点：9×10÷6+9=24。

2

2

2

9

这个并不难，只是数字比较好玩，包含了3个2，其计算方法为：(2+9)×2+2=24。

1、概述

给定4个整数，其中每个数字只能使用一次；任意使用 + - * / ( ) ，构造出一个表达式，使得最终结果为24，这就是常见的算24点的游戏。这方面的程序很多，一般都是穷举求解。本文介绍一种典型的算24点的程序算法，并给出两个具体的算24点的程序：一个是面向过程的C实现，一个是面向对象的java实现。

2、基本原理

基本原理是穷举4个整数所有可能的表达式，然后对表达式求值。

表达式的定义： expression = (expression|number) operator (expression|number)

因为能使用的4种运算符 + - * / 都是2元运算符，所以本文中只考虑2元运算符。2元运算符接收两个参数，输出计算结果，输出的结果参与后续的计算。

由上所述，构造所有可能的表达式的算法如下：

(1) 将4个整数放入数组中

(2) 在数组中取两个数字的排列，共有 P(4,2) 种排列。对每一个排列，

(2.1) 对 + - * / 每一个运算符，

(2.1.1) 根据此排列的两个数字和运算符，计算结果

(2.1.2) 改表数组：将此排列的两个数字从数组中去除掉，将 2.1.1 计算的结果放入数组中

(2.1.3) 对新的数组，重复步骤 2

(2.1.4) 恢复数组：将此排列的两个数字加入数组中，将 2.1.1 计算的结果从数组中去除掉

可见这是一个递归过程。步骤 2 就是递归函数。当数组中只剩下一个数字的时候，这就是表达式的最终结果，此时递归结束。

在程序中，一定要注意递归的现场保护和恢复，也就是递归调用之前与之后，现场状态应该保持一致。在上述算法中，递归现场就是指数组，2.1.2 改变数组以进行下一层递归调用，2.1.3 则恢复数组，以确保当前递归调用获得下一个正确的排列。

括号 () 的作用只是改变运算符的优先级，也就是运算符的计算顺序。所以在以上算法中，无需考虑括号。括号只是在输出时需加以考虑。

一个java面试题：计算24点游戏 编程

import java.util.Random;

public class test2

{

public static void main(String[] args)

{

Random random = new Random();

int a[] = new int[4];

for(int i=0; i4; i++)

{

a[i] = random.nextInt(13)+1;

}

for(int j=0; j4; j++)

{

System.out.println("第" + j +"个数：" + a[j]);

}

Calcula(a);

}

public static void Calcula(int[] a)

{

int add, sub, multi, div;

add = 0;

sub = 0;

multi = 0;

div = 0;

for(int i=0; i4; i++)

{

add = add + a[i];

sub = sub - a[i];

multi = multi * a[i];

div = div/a[i];

}

if(add==24)

{

System.out.println(a[0] + "+" + a[1] + "+" + a[2] + "+" + a[3]

+ "=" + add);

}

else if(sub==24)

{

System.out.println(a[0] + "-" + a[1] + "-" + a[2] + "-" + a[3]

+ "=" + sub);

}

else if(multi==24)

{

System.out.println(a[0] + "*" + a[1] + "*" + a[2] + "*" + a[3]

+ "=" + multi);

}

else if(div==24)

{

System.out.println(a[0] + "÷" + a[1] + "÷" + a[2] + "÷" + a[3]

+ "=" + div);

}

else

{

System.out.println("对不起，没有实现24点的数");

}

}

}

已编译通过~

java24点游戏的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、java24点游戏的信息别忘了在本站进行查找喔。

标签：