24点游戏：用户初始生命值为一给定值(比如3)，初始分数为0。随机生成4个代表扑克牌牌面的数字或字母，由用户输入包含这4个数字或字母的运算表达式(可包含括号)，如果表达式计算结果为24则代表用户赢了此局。
- 算法分析
(1)将13张牌面以字符串的形式存入列表，随机从列表中取出四张牌面，并将牌面字符串转换为字符型存入字符数组ch[]中，供后面使用。
(2)输入包含程序生成的数字或字母的表达式，筛选出表达式中的字母或数字，并与ch[]数组做匹配，判断是否包含全部生成字符，如果包含，则进行表达式计算，如果不包含，则需重新输入表达式。
(3)计算表达式时，先通过Change类的changeM（）方法将表达式中的字母转换为对应数字，然后再带入SuffixExpression类中的calculateSuffixExpression（）方法计算表达式的值。
(4)如果表达式值为24则此局胜利，加1分，负责生命值-1，如果输入表达式不包含程序所给字母数字达到三次，则生命值-1，生命值初始值为3，当生命值为0时，游戏结束。 - 源代码
import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
public class Point24 {
public static void main(String[] args) {
int lifeV=3;
int score=0;
int chance=0;
int begin;
Scanner s=new Scanner(System.in);
List<String> list = Arrays.asList("A","2","3","4","5","6","7",
"8","9","10","J","Q","K");
System.out.println("游戏说明：游戏开始将随机产生四个数字或字母，您可使用这四个数字或字母进行四则运算,");
System.out.println("您有60秒时间写出表达式，如果计算结果为24，则本局胜利，您将得1分，否则");
System.out.println("您将损失1点生命值，进入下一局，当输入表达式未包含上述未包含程序生成的数字或字母达到三次时");
System.out.println("您将损失1点生命值，当生命值为0时，游戏结束");
System.out.println();
System.out.println("是否开始游戏？(输入1开始)");
begin=s.nextInt();
if(begin==1) {
do {
int index1 = (int) (Math.random()* list.size());
int index2 = (int) (Math.random()* list.size());
int index3 = (int) (Math.random()* list.size());
int index4 = (int) (Math.random()* list.size());
String a=list.get(index1);
String b=list.get(index2);
String c=list.get(index3);
String d=list.get(index4);
char e=a.charAt(0);
char f=b.charAt(0);
char g=c.charAt(0);
char h=d.charAt(0);
char[] ch=new char[] {e,f,g,h};
System.out.println("☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆");
System.out.println("随机生成4个代表扑克牌牌面的数字或字母：");
System.out.println("第一个随机生成的牌面为："+a);
System.out.println("第二个随机生成的牌面为："+b);
System.out.println("第三个随机生成的牌面为："+c);
System.out.println("第四个随机生成的牌面为："+d);
System.out.println("请输入包含以上四个数字或字母的运算表达式（运算符可为+-*/,可带括号）:");
String st=s.next();
String str=st.replaceAll("[^A-Z0-9]", "");
char[] charArray=str.toCharArray();
int l=0;
for(int i=0;i<charArray.length;i++) {
for(int j=0;j<4;j++) {
if(charArray[i]==ch[j]) {
ch[j]=0;
l++;
break;
}
}
}
if(l==4) {
Change cc=new Change();
String cs=cc.changeM(st);
Queue<String> strings = SuffixExpression.infixConverSuffixExpression(cs);
int sign=SuffixExpression.calculateSuffixExpression(strings);
System.out.println("表达式计算结果为："+sign);
if(sign==24) {
System.out.println("恭喜您，此局胜利！");
score++;
System.out.println("您当前生命值为："+lifeV+" 您当前得分为："+score);
}else {
System.out.println("很遗憾，此局失败！");
lifeV--;
System.out.println("您当前生命值为："+lifeV+" 您当前得分为："+score);
}
System.out.println();
}else {
System.out.println("输入表达式未包含上述四个数字字母！");
chance++;
if(chance==3) {
lifeV--;
chance=0;
System.out.println("您的表达式输入已经错误三次！生命值-1");
System.out.println("您当前生命值为："+lifeV);
}
}
}while(lifeV!=0);
System.out.println("GAME OVER!");
System.out.println("您的最终得分为："+score);
}
}
}
public class Change {
public String changeM(String x) {
String str=x;
if(str.indexOf("A")!=-1) {
str=str.replace("A","1");
}
if(str.indexOf("J")!=-1) {
str=str.replace("J","11");
}
if(str.indexOf("Q")!=-1) {
str=str.replace("Q","12");
}
if(str.indexOf("K")!=-1) {
str=str.replace("K","13");
}
return str;
}
import java.util.Queue;
import java.util.Stack;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SuffixExpression {
public static Queue<String> infixConverSuffixExpression(String expression){
char[] expressionArr=expression.toCharArray();
Stack<Character> symbolStack=new Stack<>();
Queue<String> contentQueue=new ConcurrentLinkedQueue<>();
String numberLinked="";
for(int index=0;index<expressionArr.length;index++){
Character currentChar=expressionArr[index];
if(currentChar==' ')continue;
if(isSymbol(currentChar+"")){
if(currentChar=='-'&&index==0||!isNumeric(expressionArr[index-1]+"")&&expressionArr[index-1]!=')'&&expressionArr[index-1]!=' '){
numberLinked+=currentChar;
}else{
while(!symbolStack.isEmpty()){
if(symbolLevel(currentChar)<=symbolLevel(symbolStack.peek())){
contentQueue.add(symbolStack.pop()+"");
}else{
break;
}
}
symbolStack.push(currentChar);
}
}
else if(currentChar=='('|| currentChar==')'){
if(currentChar=='('){
symbolStack.push(currentChar);
}else{
while(!symbolStack.isEmpty()){
char currPopChar=symbolStack.pop();
if(currPopChar!='('){
contentQueue.add(currPopChar+"");
}else{
break;
}
}
}
}else{
numberLinked+=currentChar;
if(index>=expressionArr.length-1){
contentQueue.add(numberLinked);
}else{
if(!isNumeric(expressionArr[index+1]+"")){
contentQueue.add(numberLinked);
numberLinked="";
}
}
}
}
while(!symbolStack.isEmpty()){
contentQueue.add(symbolStack.pop()+"");
}
return contentQueue;
}
public static Integer calculateSuffixExpression(Queue<String> contentQueue){
Stack<Integer> numberStack=new Stack<>();
while(!contentQueue.isEmpty()){
String currentContent=contentQueue.poll();
if(isSymbol(currentContent)){
int num1=numberStack.pop();
int num2=numberStack.pop();
numberStack.push(calculate(num1,num2,currentContent.toCharArray()[0]));
}else{
numberStack.push(Integer.parseInt(currentContent));
}
}
return numberStack.pop();
}
public static boolean isSymbol(String ch){
return ch.equals("+") || ch.equals("-") || ch.equals("*") || ch.equals("/");
}
public static boolean isNumeric(String str){
Pattern pattern = Pattern.compile("^-?\\d+(\\.\\d+)?$");
Matcher isNum = pattern.matcher(str);
if( !isNum.matches() ){
return false;
}
return true;
}
public static int symbolLevel(int ch){
if(ch=='+'|| ch=='-'){
return 1;
}else if(ch=='*'|| ch=='/'){
return 2;
}else{
return -1;
}
}
public static int calculate(int num1,int num2,Character ch){
switch (ch){
case '+':
return num2+num1;
case '-':
return num2-num1;
case '*':
return num2*num1;
case '/':
return num2/num1;
default:
return -1;
}
}
}
1782
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
