福彩3D-JAVA继承

题目描述

根据福彩3D的不同玩法，输出奖金金额

玩法附件中提供

输入：

开奖号码 玩的次数n 

n次输入 玩法 用户投注号码

输出：

最高中奖金额 

样例输入输出

样例1

输入:

745 5
single 745
tractor
package 745
general 745
oned *4*

输出:

1040

样例2

输入:

111 7 
single 145 
tractor 
package 897 
general 745 
oned *1* 
guess1d 1 
sum 3

输出:

230

玩法：

附录1：福彩3D游戏设奖方案详解

输入选择	游戏		规则解释	中奖条件	通俗解释	举例	奖金
single	单选	单选	是指对三个号码以唯一的排列方式进行投注	投注号码与当期开奖号码按位全部相同（百位+十位+个位），即中奖	购买号码与开奖号码完全相同，且位置相同	买456开456	1040
group	组选	组选3	是指将三个号码的所有排列方式作为一注投注号码进行投注。如果一注组选的三个号码中有两个号码相同，则包括三种不同的排列方式，称为“组选3”；如果一注组选的三个号码各不相同，则包括六种不同的排列方式，称为“组选6”	当期开奖号码的三位数中任意两位数字相同，且投注号码与当期开奖号码相同（顺序不限），即中奖	购买号码与开奖号码完全相同，位置随意	买112，开112、121、211	346
		组选6		当期开奖号码的三位数各不相同，且投注号码与当期开奖号码相同（顺序不限），即中奖		买123，开123、132、213、231、312、321	173
oned	1D	1D投注	是指对百位、十位或个位中某一特定位置上的号码进行投注	投注号码与当期开奖号码中对应位置的号码相同，即中奖	对某一位置上的号码进行投注	买*1*，开*1*	10
guess1d	猜1D	猜中1	是指对百位、十位或个位中任意一个位置上的号码进行投注	投注号码与当期开奖号码中任意一个位置的号码相同，即中奖	所选号码在开奖号码中出现，位置不限，出现一次中猜中1，出现两次中猜中2，出现三次（豹子）中猜中3	买1开出1**、*1*、1**	2
		猜中2		投注号码与当期开奖号码中任意两个位置的号码相同，即中奖		买1开出11*、1*1、*11	12
		猜中3		投注号码与当期开奖号码中全部三个位置的号码相同，即中奖		买1开出111	230
towd	2D	2D投注	是指对百位和十位、十位和个位或百位和个位号码，以唯一的排列方式进行投注。	投注号码与当期开奖号码中对应两个位置的号码按位相同，即中奖	买2个号码，数字正确，位置相同	买*12，开*12	104
	猜2D	两同号	是指对百位、十位或个位中任意两个位置上的号码进行投注	投注号码为两个相同的号码，且当期开奖号码中包含投注的两个相同号码，即中奖	买2个相同号码，数字正确，位置随意	买11，开出11*、1*1、*11	37
		两不同号		投注号码为两个不同的号码，且当期开奖号码中包含投注的两个不同号码（顺序不限），即中奖	买2个不同号码，数字正确，位置随意	买12，开12*、1*2、*12、*21、21*、2*1	19
general	通选	通选1	是指对三个号码以唯一的排列方式进行投注	投注号码与当期开奖号码按位全部相同（百位+十位+个位），即中奖	两次中奖机会，先中通选1，若不中可再中通选2	买456开456	470
		通选2		投注号码与当期开奖号码中任意两个位置的号码按位相同，即中奖		买123，开12*、1*3、*23	21
sum	和数	和数投注	是指对三个号码相加之和进行投注	投注号码与当期开奖号码的三个号码相加之和相同，即中奖	买0-27任意数值，与开奖号码三个数字相加之和相同	买和2，开002、020、200、011、101、110	14-1040
package	包选	包选三全中	是指同时用单选和组选的方式对三个号码进行投注。如果三个号码中有两个号码相同，则包括三种不同的排列方式，称为“包选3”；如果三个号码各不相同，则包括六种不同的排列方式，称为“包选6”	投注号码的三位数中任意两位数字相同，且投注号码与当期开奖号码按位全部相同，即中奖	两次中奖机会，先对全中，若不中可再对组中	买011，开011	693
		包选三组中		投注号码的三位数中任意两位数字相同，且投注号码与当期开奖号码全部相同（顺序不同），即中奖		买011，开101、110	173
		包选六全中		投注号码的三位数各不相同，且投注号码与当期开奖号码按位全部相同，即中奖	两次中奖机会，先对全中，若不中可再对组中	买123，开123	606
		包选六组中		投注号码的三位数各不相同，且投注号码与当期开奖号码全部相同（顺序不同），即中奖		买123，开132、213、231、312、321	86
	猜大小	猜大小投注	是指对三个号码相加之和的大、小性质进行投注。其中，三个号码相加之和在19（含）至27（含）之间时为大，在0（含）至8（含）之间时为小	投注号码与当期开奖号码的三个号码相加之和的大、小性质相同，即中奖。其中，三个号码相加之和在19（含）至27（含）之间时为大，在0（含）至8（含）之间时为小	票面没有数字，只显示大、小	买大，开出和值在19-27之间	6
	猜三同	猜三同投注	是指对全部三个相同的号码进行投注	当期开奖号码为三个相同的号码，即中奖	猜是否出豹子号	开出豹子号	104
tractor	拖拉机	拖拉机投注	是指对全部以升序或降序连续排列的号码进行投注（890、098、901、109除外）	当期开奖号码的三个号码为以升序或降序连续排列的号码（890、098、901、109除外），即中奖	票面没有数字，只显示拖拉机	开出拖拉机	65
	猜奇偶	猜奇偶投注	是指对全部三个号码的奇数、偶数性质进行投注。其中，1、3、5、7、9为奇，0、2、4、6、8为偶	当期开奖号码的三个号码全部为奇数或偶数，且投注号码与当期开奖号码的三个号码的奇数、偶数性质相同，即中奖。其中，1、3、5、7、9为奇，0、2、4、6、8为偶	票面没有数字，只显示奇、偶	买奇，开奖号码为1、3、5、7、9的任意组合即中奖	8

附录2：和数投注奖金表

1.和数0或27：单注奖金固定为1040元；

2.和数1或26：单注奖金固定为345元；

3.和数2或25：单注奖金固定为172元；

4.和数3或24：单注奖金固定为104元；

5.和数4或23：单注奖金固定为69元；

6.和数5或22：单注奖金固定为49元；

7.和数6或21：单注奖金固定为37元；

8.和数7或20：单注奖金固定为29元；

9.和数8或19：单注奖金固定为23元；

10.和数9或18：单注奖金固定为19元；

11.和数10或17：单注奖金固定为16元；

12.和数11或16：单注奖金固定为15元；

13.和数12或15：单注奖金固定为15元；

14.和数13或14：单注奖金固定为14元。

import java.util.Scanner;
import java.util.Arrays;

abstract class Lottery {
	protected int winNumber[];
	protected int userNumber[];
	protected String userInput;
	Lottery(String s){
		winNumber=createWinNumber(s);
	}
	int[] createWinNumber(String s) {
		int[] winnu = new int[3];
		try {
			Integer i = Integer.valueOf(s);
			if (i >= 0 && i < 1000) {
				for (int j = 0; j < 3; j++) {
					winnu[2 - j] = i % 10;
					i = i / 10;
				}
				return winnu;
			} else
				return winnu;
		} catch (Exception e) {
			return null;
		}
		//return winnu;
	}

	boolean getUserInput(String s) {
		s = s.trim();
		userNumber= new int [3];
		userInput = s;
		try {
			Integer i = Integer.valueOf(s);
			if (i >= 0 && i < 1000) {
				for (int j = 0; j < 3; j++) {
					userNumber[2 - j] = i % 10;
					i = i / 10;
				}
				return true;
			} else
				return false;
		} catch (Exception e) {
			return false;
		}
	}

	abstract int getwinlevel(int[] winnumber, String s);

	int getwinlevel() {
		return getwinlevel(this.winNumber, this.userInput);
	}
	int getwinlevel(String s) {
		return getwinlevel(this.winNumber,s);
	}

	public void setUserNumber(int[] userNumber) {
		this.userNumber = userNumber;
	}

}

class Group extends Lottery {
	Group(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}

	int[] arrange(int[] winnumber) {
		int[] newwinnumber = Arrays.copyOf(winnumber, winnumber.length);
		Arrays.sort(newwinnumber);
		return newwinnumber;
	}

	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		if (this.getUserInput(s)) {
			int[] newwinnumber = arrange(winnumber);
			int[] newuserinput = arrange(this.userNumber);
			int maxequal = 0;
			int currequal = 0;
			for (int i = 0; i < newwinnumber.length - 1; i++) {
				if (newwinnumber[i] == newwinnumber[i + 1]) {
					currequal++;
					if (currequal > maxequal) {
						maxequal = currequal;
					}
				} else
					currequal = 0;
			}
			boolean equals = true;

			for (int i = 0; i < newwinnumber.length - 1; i++) {
				if (newwinnumber[i] != newuserinput[i]) {
					equals = false;
					break;
				}
			}
			if (equals) {
				switch (maxequal) {
				case 0:
					return 173;
				case 1:
					return 346;
				default:
					return 0;
				}
			} else
				return 0;

		} else
			return 0;
	}

}

class Single extends Lottery {

	Single(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}

	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
			boolean win = true;
			for (int i = 0; i < userNumber.length; i++) {
				if (userNumber[i] != winnumber[i]) {
					win = false;
					break;
				} 
				}
			if (win) {
				return 1040;

			} else
				return 0;
		} 
	}
class Oned extends Lottery{
	Oned(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}

	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
		int t=0,place=0;
		char[]wins = new char[3];
		for(int i=0;i<3;i++) {
			if(s.charAt(i)>='0'&&s.charAt(i)<='9') {
				place=i;
				t=(int)s.charAt(i);
			}
		}
		if(t-48==winnumber[place])return 10;
		else return 0;
}

	}
class Guess1d extends Lottery{
	Guess1d(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}

	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
		int m = Integer.parseInt(s);
		if(m>9||m<0)return 0;
		int sum=0;
		for(int i=0;i<3;i++) {
			if(m==winnumber[i])sum++;
		}
		if(sum==1)return 2;
		else if(sum==2)return 12;
		else if(sum==3)return 230;
		else return 0;
	}
	
}
class Sum extends Lottery{
	Sum(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
		Integer sum1 = Integer.valueOf(s);
		int sum2=winnumber[0]+winnumber[1]+winnumber[2],price=0;
				if (sum1!=sum2) {
					return 0;
				}
				else {
				switch(sum1) {
				case 0:price= 1040;break;
				case 27:price= 1040;break;
				case 1:price=345;break;
				case 26:price=345;break;
				case 2:price= 172;break;
				case 25:price=172;break;
				case 3:price= 104;break;
				case 24:price=104;break;
				case 4:price=69;break;
				case 23:price= 69;break;
				case 5:price=49;break;
				case 22:price=49;break;
				case 6:price=37;break;
				case 21:price=37;break;
				case 7:price=29;break;
				case 20:price=29;break;
				case 8:price=23;break;
				case 19:price=23;break;
				case 9:price=19;break;
				case 18:price=19;break;
				case 10:price=16;break;
				case 17:price=16;break;
				case 11:price=15;break;
				case 12:price=15;break;
				case 15:price=15;break;
				case 16:price=15;break;
				case 13:price=14;break;
				case 14:price=14;break;
				}
		}
				return price; 
	}
}
class Tractor extends Lottery{
	Tractor(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}
	int getwinlevel(int[] winnumber,String s) {
		// TODO Auto-generated method stub
		if((winnumber[2]-winnumber[1]==1)&&(winnumber[1]-winnumber[0]==1))return 65;
		else if((winnumber[2]-winnumber[1]==-1)&&(winnumber[1]-winnumber[0]==-1)) return 65;
		else return 0;
	}
}
class General extends Lottery{

	General(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}
	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
			int sum=0;
			
			for (int i = 0; i < s.length(); i++) {
				if (userNumber[i]==winnumber[i]) {
					sum++;
				}
				}
			if(sum==3)return 470;
			else if(sum==2) return 21;
			else return 0;
	}
}
class Package extends Lottery{

	Package(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}
	int[] arrange(int[] winnumber) {
		int[] newwinnumber = Arrays.copyOf(winnumber, winnumber.length);
		Arrays.sort(newwinnumber);
		return newwinnumber;
	}
	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
		int t=0;
		boolean same=false;
		if(winnumber[0]==winnumber[1]||winnumber[1]==winnumber[2]||winnumber[0]==winnumber[2]) {same=true;}
		for(int i=0;i<3;i++) {
			if(winnumber[i]==userNumber[i])
				t++;
		}
		if(t==3&&same==true)return 693;
		else if(t==3&&same==false)return 606;
		int[] newwinnumber = arrange(winnumber);
		int[] newuserinput = arrange(this.userNumber);
		int maxequal = 0;
		int currequal = 0;
		for (int i = 0; i < newwinnumber.length - 1; i++) {
			if (newwinnumber[i] == newwinnumber[i + 1]) {
				currequal++;
				if (currequal > maxequal) {
					maxequal = currequal;
				}
			} else
				currequal = 0;
		}
		boolean equals = true;

		for (int i = 0; i < newwinnumber.length - 1; i++) {
			if (newwinnumber[i] != newuserinput[i]) {
				equals = false;
				break;
			}
		}
		if (equals) {
			switch (maxequal) {
			case 0:
				return 86;
			case 1:
				return 173;
			default:
				return 0;
			}
		} else
			return 0;
	}
	
}
class Towd extends Lottery{

	Towd(String s) {
		super(s);
		// TODO Auto-generated constructor stub
	}

	@Override
	int getwinlevel(int[] winnumber, String s) {
		// TODO Auto-generated method stub
		this.getUserInput(s);
		int t=0;
		char[]wins = new char[3];
		for(int i=0;i<3;i++) {
			if(s.charAt(i)>='0'&&s.charAt(i)<='9') {
				if(s.charAt(i)-48==winnumber[i])
					t++;
			}
		}
		if(t==2)return 104;
		else return 0;
	}
}
public class Main {

	public static  Lottery getusertype(String s,String wins) {
		Lottery l=null;
		switch (s) {
		case "single":
			l=new Single(wins);
			break;
		case "group":
			l=new Group(wins);
			break;
		case "oned":
			l=new Oned(wins);
			break;
		case "guess1d":
			l=new Guess1d(wins);
			break;
		case "sum":
			l=new Sum(wins);
			break;
		case"tractor":
			l=new Tractor(wins);
			break;
		case "general":
			l=new General(wins);
			break;
		case"package":
			l=new Package(wins);
			break;
		case"towd":
			l=new Towd(wins);
			break;
		}
		return l;
		
	}
	public static void main(String[] arg) {
		Scanner s=new Scanner(System.in);
		String wins=s.next();
		int times=s.nextInt();
		int maxlevel=0;
		for(int i=0;i<times;i++) {
			String type=s.next();
			Lottery l=getusertype(type,wins);
			String userinput;
			if(type.equals("tractor"))userinput=null;
			else userinput=s.next();
			int curr=l.getwinlevel(userinput);
			if(maxlevel<curr) {
				maxlevel=curr;
			};
		}
		System.out.println(maxlevel);
			s.close();	
	}
}