本文目錄一覽：
24點速算遊戲 Java 代碼
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* 用給定的4個整數通過加減乘除運算得到24點，如果有多種情況，則全部輸出，如果不能得到24點，輸出提示br
*
* @思路:將指定的4個數字進行全排列，將運算符『+』、『-』、『*』、『/』取3個進行所有情況排列，
* 然後將所有的數字排列與所有的運算符排列按順序計算，
* 如果最後計算結果等於想要的結果值比如24，則為符合條件的運算，
* 將所有符合條件的數字排列和運算符排列存儲起來，並在最後打印輸出所有可能的情況
*
* @author chenjie
*
*/
public class TwentyFourPoint {
public static void main(String[] args) {
try {
SetString set = caculate(new int[] { 18, 18, 6, 12 }, 24);
printlnResultSet(set);
} catch (Exception e) {
// e.printStackTrace();開發期間方便查找錯誤，測試通過後就無需打印錯誤信息了
System.err.println(e.getMessage());
}
}
/**
* 打印結果集
*
* @param resultSet
* 結果集
*/
private static void printlnResultSet(CollectionString resultSet) {
for (String str : resultSet) {
System.out.println(str);
}
}
/**
* 得到給定整形數組的全排列情況
*
* @param numbers
* 給定的整形數組
* @return 全排列數組
*/
private static int[][] arrangeAllNumbers(int[] numbers) {
Listint[] list = new ArrayListint[]();
allSort(numbers, 0, numbers.length – 1, list);
int[][] resultSet = new int[list.size()][list.get(0).length];
resultSet = list.toArray(resultSet);
return resultSet;
}
/**
* 得到給定的操作中出現的所有操作符排列情況
*
* @param operators
* 出現的操作符數組
* @param number
* 每組操作符的數量
* @return 所有操作符排列數組
*/
private static char[][] arrangeAllOperators(char[] operators, int number) {
int setSize = (int) Math.pow(operators.length, number);
int index = 0;
char[][] resultSet = new char[setSize][number];
for (int i = 0; i operators.length; i++) {
for (int j = 0; j operators.length; j++) {
for (int k = 0; k operators.length; k++) {
resultSet[index][0] = operators[i];
resultSet[index][1] = operators[j];
resultSet[index][2] = operators[k];
index++;
}
}
}
return resultSet;
}
/**
* 根據給定的一組整數，通過加減乘除運算，得到想要的結果，如果可以得到結果，則返回所有可能的結果的運算形式。
* 返回的運算形式，均按從左到右的順序計算，並不是遵循四則運算法則，比如：br
* 輸出的結果形式為：br
* 1 * 8 – 6 * 12 = 24 br
* 表示的運算順序是：br
* 1:1 * 8 = 8,br
* 2:8 – 6 = 2,br
* 3:2 * 12 = 24br
* 而不是按照四則運算法則計算：br
* 1:1 * 8 = 8,br
* 2:6 * 12 = 72,br
* 3:8 * 72 = 576br
*
*
* @param numbers
* 給定進行運算的一組整數，4個數為一組
* @param targetNumber
* 想要得到的結果
* @return 所有可能得到想要的結果的所有運算形式的字符串形式集合
* @throws Exception
* 如果不能得到想要的結果，則拋出該異常，表明根據指定的一組數字通過一系列的加減乘除不能得到想要的結果
*/
public static SetString caculate(int[] numbers, int targetNumber)
throws Exception {
SetString resultSet = new HashSetString();// 這裡用Set而不是用List，主要是因為當給定的一組數字中如果有重複數字的話，同一結果會被出現多次，如果用List存放的話，會將重複的結果都存放起來，而Set會自動消除重複值
char[][] operatorsArrangement = arrangeAllOperators(new char[] { ‘+’,
‘-‘, ‘*’, ‘/’ }, 3);
int[][] numbersArrangement = arrangeAllNumbers(numbers);
for (int[] nums : numbersArrangement)
for (char[] operators : operatorsArrangement) {
int result = 0;
try {
result = caculate(nums, operators);
} catch (Exception e) {// 出現非精確計算
continue;
}
if (result == targetNumber)
resultSet.add(buildString(nums, operators, targetNumber));// 如果計算後的結果等於想要的結果，就存放到集合中
}
if (resultSet.isEmpty())
throw new Exception(“給定的數字：” + Arrays.toString(numbers)
+ “不能通過加減乘除運算得到結果：” + targetNumber);
return resultSet;
}
/**
* 將一組整型數字以給定的操作符按順序拼接為一個完整的表達式字符串
*
* @param nums
* 一組整型數字
* @param operators
* 一組操作符
* @param target
* 目標值
* @return 拼接好的表達式字符串
*/
private static String buildString(int[] nums, char[] operators, int target) {
String str = String.valueOf(nums[0]);
for (int i = 0; i operators.length; i++) {
str = str + ‘ ‘ + operators[i] + ‘ ‘ + nums[i + 1];
}
str = str + ” = ” + target;
return str;
}
/**
* 將給定的一組數字以給定的操作符按順序進行運算，如：int result = caculate(new int[]{3,4,5,8}, new
* char[]{‘+’,’-‘,’*’});
*
* @param nums
* 一組數字
* @param operators
* 一組運算符，數量為數字的個數減1
* @return 最後的計算結果
* @throws Exception
* 當計算結果不精確時，拋出該異常，主要是針對除法運算，例如18 / 8 = 2，諸如這樣不精確計算將拋出該異常
*/
private static int caculate(int[] nums, char[] operators) throws Exception {
int result = 0;
for (int i = 0; i operators.length; i++) {
if (i == 0) {
result = caculate(nums[i], nums[i + 1], operators[i]);
} else {
result = caculate(result, nums[i + 1], operators[i]);
}
}
return result;
}
/**
* 根據指定操作符將兩個給定的數字進行計算
*
* @param num1
* 數字1
* @param num2
* 數字2
* @param operator
* 操作符，只能從「+、-、*、/」4個操作符中取值
* @return 計算結果
* @throws Exception
* 當計算結果不精確時，拋出該異常，主要是針對除法運算，例如18 / 8 = 2，諸如這樣不精確計算將拋出該異常
*/
private static int caculate(int num1, int num2, char operator)
throws Exception {
double result = 0;
switch (operator) {// 根據操作符做相應的計算操作
case ‘+’:
result = num1 + num2;
break;
case ‘-‘:
result = num1 – num2;
break;
case ‘*’:
result = num1 * num2;
break;
case ‘/’:
result = (double) num1 / (double) num2;
break;
}
if (!check(result))
throw new Exception(“不精確的計算數字”);
return (int) result;
}
/**
* 檢查指定的浮點數是否可以直接轉換為整型數字而不損失精度
*
* @param result
* 要檢查的浮點數
* @return 如果可以進行無損轉換，返回true，否則返回false
*/
private static boolean check(double result) {
String str = String.valueOf(result);
int pointIndex = str.indexOf(“.”);// 小數點的下標值
String fraction = str.substring(pointIndex + 1);
return fraction.equals(“0”) ? true : false;// 通過判斷小數點後是否只有一個0來確定是否可以無損轉換為整型數值
}
/**
* 對傳入的整型數組buf進行全排列
*
* @param buf
* 要進行全排列的整型數組
* @param start
* 開始的下標值
* @param end
* 結束下標值
* @param list
* 保存最後全排列結果的集合
*/
private static void allSort(int[] buf, int start, int end, Listint[] list) {
if (start == end) {// 當只要求對數組中一個字母進行全排列時，只要就按該數組輸出即可
int[] a = new int[buf.length];
System.arraycopy(buf, 0, a, 0, a.length);
list.add(a);
} else {// 多個字母全排列
for (int i = start; i = end; i++) {
int temp = buf;// 交換數組第一個元素與後續的元素
buf = buf[i];
buf[i] = temp;
allSort(buf, start + 1, end, list);// 後續元素遞歸全排列
temp = buf;// 將交換後的數組還原
buf = buf[i];
buf[i] = temp;
}
}
}
}
想用java寫個24點的遊戲、不懂、急求教、
給你兩點提示吧
1）四個數有效的運算順序一共5種，如，(1#2)#(3#4)，((1#2)#3)#4為其中的兩種。
2）將四則運算用函數完成，定義eval(int lhs, int rhs, int op)，lhs、rhs 為左右操作數，op為操作符，這樣窮舉的時候可以將op從1取到4來完成。
PS:一般玩的24點是可以交換順序的，如果須要可以再寫一個全排列的算法。
一個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點的數”);
}
}
}
已編譯通過~
原創文章，作者：RLCUB，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/324882.html
微信掃一掃 
支付寶掃一掃 