24点纸牌游戏输出可能结果

基本思路:

算法实现:

根据x值返回1234到k

用Scanner 来输入不同的数,通过输入的数调用printResult(int[] ch)方法来确定是否等于24,如果等于24,分数++;

如果不等于24,生命--;

设计Random方法来实现随机产生四个数,调用printResult(int[] ch)

采用do while分别选择随机生成四个数或者自己输入四个数

ys(double num1,double num2,char o)来设计运算赋予“+ - * /”相应的意义

Result(int[] ch,char[] o)方法统计结果,当结果为24时输出结果

printResult(int[] ch)方法统计所有结果数目

具体代码实现如下

package jj;
import java.util.Scanner;
import java.util.Random;
public class g
{

   public  static void main(String args[]) {
	  int  count=0;
	  int life=3;
	    int fenshu =0;
        int[] ch=new int[4];//声明数组
        int c,d;
        Scanner sc=new Scanner (System.in);
   
        System.out.println("*******24点纸牌游戏******");  
        
       
         do  
         {  
             System.out.println("生成纸牌:\n"); 
             Random( ch) ;//函数调用
             printResult(ch);//函数调用 
             System.out.println("1.继续游戏 2.结束 3.挑战自我\n");                           
             c=sc.nextInt();  
         }
         while(c==1);          
   
   do  
   {  
	   System.out.println("输入纸牌:\n"); 
	
		for(int i=0;i<4;i++){
			ch[i]=sc.nextInt();	
//		int f1=sc.nextInt();
//		int f2=sc.nextInt();
//		int f3=sc.nextInt();
//		int f4=sc.nextInt();
		  }
	   printResult(ch);//函数调用 
	 
//	   if(count==0){
//		    life--;
//	   }
//	   if(count !=0){
//		   fenshu++;
//	   }
//	   if(life==0){
//		   break;
//	   }
	 
	  // System.out.println("共"+count+"种方法"); 
//	   System.out.println("生命"+life +" "+"分数 "+fenshu);
	   System.out.println("1.继续游戏 2.结束 3.挑战自我\n");                           
	   d=sc.nextInt();  
   }
   while(d==3);     
  sc.close();
   }
    
//private static void printResult(int f1, int f2, int f3, int f4) {
//	// TODO Auto-generated method stub
//	
//}

	//根据x值返回1到J,Q,K
    public static char Card(int x)
    {
        if(x==1)
            return 'A';
        if(x<10)
            return (char)(x+'0');
        else if(x==10)
            return '0';
        else if(x==11)
            return 'J';
        else if(x==12)
            return 'Q';
        else if(x==13)
            return 'K'; 
        return 0;
    }
    //随机生成四个数
    public static void Random(int[] ch)  
    {
        int i; 
        Random random=new Random();
        for(i=0;i<4;i++)  
        {  
            ch[i]=(int)(random.nextInt(13)+1);
            System.out.print(Card(ch[i])+" ");  
         
        }
        System.out.println();
    }
    //四个运算符的运算
    public static  double ys(double num1,double num2,char o) 
    {
        double result=0;  
          switch(o)  
         {  
             case '+':  
             result=num1+num2;  
             break;  
            case '-': 
            {
                if(num1>=num2)
                    result=num1-num2;
                else
                    result=num2-num1;
            }

             break;  
            case '*':  
             result=num1*num2;  
             break;  
            case '/':
             result=num1/num2;  
             break;  
            default :  
                break;  
         }       
         return result;         
    }
    //如果通过运算算得的结果为24,则输出结果
    public static  int Result(int[] ch,char[] o)  
    {
        double t;  
         int a=ch[0];  
         int b=ch[1];  
         int c=ch[2];  
         int d=ch[3];        

        //1.((A*B)*C)*D  
        t=0;  
        t=ys(ys(ys(a,b,o[0]),c,o[1]),d,o[2]);       
        if(t==24)  
        {  
            System.out.println("("+"("+"("+Card(ch[0])+o[0]+Card(ch[1])+")"+o[1]+Card(ch[2])+")"+o[2]+Card(ch[3])+")");   
            return 1;  
        }        
        //2.(A*(B*C))*D  
        t=0;  
        t=ys(ys(a,ys(b,c,o[1]),o[0]),d,o[2]);      
        if((t-24)==0)   
        {  
            System.out.println("("+"("+Card(ch[0])+o[0]+"("+Card(ch[1])+o[1]+Card(ch[2])+")"+")"+Card(ch[2])+Card(ch[3])+")"); 
            return 1;  
        }  
        //3.(A*B)*(C*D)  
        t=0;  
        t=ys(ys(a,b,o[0]),ys(c,d,o[2]),o[1]);       
        if((t-24)==0)   
        {  
            System.out.println("("+"("+Card(ch[0])+o[0]+Card(ch[1])+")"+o[1]+"("+Card(ch[2])+o[2]+Card(ch[3])+")"+")"); 
            return 1;  
        }        
        //4.A*(B*(C*D))  
        t=0;  
        t=ys(a,ys(b,ys(c,d,o[2]),o[1]),o[0]);          
        if((t-24)==0)   
        {  
            System.out.println("("+Card(ch[0])+o[0]+"("+Card(ch[1])+o[1]+"("+Card(ch[2])+o[2]+Card(ch[3])+")"+")"+")"); 
           return 1;  
        }  
        //5.A*((B*C)*D)   
        t=0;  
         t=ys(a,ys(ys(b,c,o[1]),d,o[2]),o[0]);        
        if((t-24)==0)   
        {  
            System.out.println("("+Card(ch[0])+o[0]+"("+"("+Card(ch[1])+o[1]+Card(ch[2])+")"+o[2]+Card(ch[3])+")"+")1");  
            return 1;  
        }       
         return 0;  
     }
     //输出结果的数目
    public static void printResult(int[] ch)
    {	
    	 int life=3;
 	    int fenshu =0;
         char[] O={'+','-','*','/'};  
         char[] o =new char[3];  
         int i,j,k;  
      
		  int count=0;        
         for(i=0;i<4;i++)//三层for循环列出了所有运算符可能出现的情况
         {
            for(j=0;j<4;j++) 
            {
               for(k=0;k<4;k++)  
               {  
                 o[0]=O[i];  
                 o[1]=O[j];  
                 o[2]=O[k];  
                 if(Result(ch,o)==1)  //如果输出函数返回值为真,输出结果数目递加
                    count++;
               }
            }
         } 
         if(count==0){
 		    life--;
 	   }
         else{
 		   fenshu++;
 	   }
        
        System.out.println("共"+count+"种方法"); 
         System.out.println("生命"+life +" "+"分数 "+fenshu);
    }
    
}


 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
24点纸牌游戏是一个经典的数学游戏,要求通过组合四张纸牌的数字和运算符,使得结果等于24。如何使用Java实现这个游戏呢? 首先,我们需要生成一副扑克牌,包括52张牌,每张牌都有对应的点数。可以用一个数组来表示扑克牌,每个元素对应一张牌的点数。 然后,我们从这副扑克牌中任意抽取四张牌,并使用四则运算符(加、减、乘、除)来组合这四张牌的点数,目标是得到结果等于24。 为了实现这个过程,我们可以使用递归算法。可以通过一个递归函数来对所有可能的组合进行尝试。函数的输入参数是当前要计算的数字列表,以及已经得到的计算结果。函数的返回值是一个布尔值,表示是否找到了满足条件的组合。 具体的实现过程如下: 1. 定义一个递归函数,输入参数是当前要计算的数字列表,以及已经得到的计算结果。函数返回一个布尔值。 2. 在递归函数中,首先判断数字列表是否为空,如果为空,那么判断计算结果是否等于24,如果等于24,则返回True,否则返回False。 3. 如果数字列表不为空,我们可以选择其中一个数字进行组合运算。可以使用一个循环遍历数字列表中的所有数字。 4. 在循环中,我们可以将当前遍历到的数字从数字列表中移除,然后将它与已经得到的计算结果进行四则运算,并将结果加入数字列表中。 5. 然后,我们递归调用函数,传入新的数字列表和计算结果,判断是否找到了满足条件的组合。如果找到了,就返回True,表示已经找到了,可以结束递归。 6. 如果在循环中所有数字都尝试过了,都没有找到满足条件的组合,那么返回False,表示未找到满足条件的组合。 7. 在程序的入口处,我们可以调用递归函数,传入初始的数字列表和计算结果,判断是否找到了满足条件的组合。如果找到了,可以输出结果;如果没有找到,可以提示用户没有组合满足条件。 通过以上步骤,就可以使用Java实现24点纸牌游戏。可以通过调用递归函数进行计算和判断,来得到游戏的结果。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值