麻将 胡牌 算法（任意癞子）

最新推荐文章于 2022-06-21 23:26:31 发布
置顶 最新推荐文章于 2022-06-21 23:26:31 发布
阅读量2.1k 收藏 5
点赞数 2
分类专栏： 算法 文章标签： 麻将 算法 癞子
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jimheaven/article/details/104247371
版权

分享一个麻将胡牌算法，支持多癞子，自己对麻将胡牌的理解写的一套快速识别胡牌逻辑，核心逻辑500行代码，仅对同条万进行处理，字花牌不包含在内，易理解，1M次随机胡牌牌型大概3秒左右。原创分享，我的算法也许可以给你带来一种思路，也许你有更好的，仅供学习参考。如果有什么逻辑错误，欢迎指出。源码：https://download.csdn.net/download/jimheaven/12147500

基础类

public class MJCard {
	public static final int Tong = 0;
	public static final int Tiao = 1;
	public static final int Wan = 2;
	public static final int Feng = 3;
	public static final int Jian = 4;
	public static final int Hua = 5;
	public static final int Laizi = 6;
	
	@Getter
	private int type = 0;
	@Getter
	private int num = 0;
	
	public MJCard(int type,int num) {
		this.type = type;
		this.num = num;
	}
	
	public int getNumValue() {
		return type * 10 + num;
	}
	
	public String toString() {
		String info = "";
		if(type == Tiao) {
			info +="条"+num;
		}else if(type == Tong) {
			info += "同"+num;
		}else if(type == Wan) {
			info += "万"+num;
		}else if(type == Feng) {
			if(num == 1) {
				info = "东";
			}else if(num == 2) {
				info = "南";
			}else if(num == 3) {
				info = "西";
			}else if(num == 4) {
				info = "北";
			}
		}else if(type == Jian) {
			if(num == 1) {
				info = "红中";
			}else if(num == 2) {
				info = "发财";
			}else if(num == 3) {
				info = "白板";
			}
		}else if(type == Hua) {
			if(num == 1) {
				info = "春";
			}else if(num == 2) {
				info = "夏";
			}else if(num == 3) {
				info = "秋";
			}else if(num == 4) {
				info = "冬";
			}else if(num == 5) {
				info = "梅";
			}else if(num == 6) {
				info = "兰";
			}else if(num == 7) {
				info = "竹";
			}else if(num == 8) {
				info = "菊";
			}
		}else if(type == Laizi) {
			if(num == 1) {
				info = "系统癞子";
			}else if(num == 2) {
				info = "特殊癞子";
			}
		}
		return info;
	}
}
public class MJCards {
	private static final MJCard tong1 = new MJCard(MJCard.Tong, 1); 
	private static final MJCard tong2 = new MJCard(MJCard.Tong, 2); 
	private static final MJCard tong3 = new MJCard(MJCard.Tong, 3); 
	private static final MJCard tong4 = new MJCard(MJCard.Tong, 4); 
	private static final MJCard tong5 = new MJCard(MJCard.Tong, 5); 
	private static final MJCard tong6 = new MJCard(MJCard.Tong, 6); 
	private static final MJCard tong7 = new MJCard(MJCard.Tong, 7); 
	private static final MJCard tong8 = new MJCard(MJCard.Tong, 8); 
	private static final MJCard tong9 = new MJCard(MJCard.Tong, 9); 
	
	private static final MJCard tiao1 = new MJCard(MJCard.Tiao, 1); 
	private static final MJCard tiao2 = new MJCard(MJCard.Tiao, 2); 
	private static final MJCard tiao3 = new MJCard(MJCard.Tiao, 3); 
	private static final MJCard tiao4 = new MJCard(MJCard.Tiao, 4); 
	private static final MJCard tiao5 = new MJCard(MJCard.Tiao, 5); 
	private static final MJCard tiao6 = new MJCard(MJCard.Tiao, 6); 
	private static final MJCard tiao7 = new MJCard(MJCard.Tiao, 7); 
	private static final MJCard tiao8 = new MJCard(MJCard.Tiao, 8); 
	private static final MJCard tiao9 = new MJCard(MJCard.Tiao, 9); 
	
	private static final MJCard wan1 = new MJCard(MJCard.Wan, 1); 
	private static final MJCard wan2 = new MJCard(MJCard.Wan, 2); 
	private static final MJCard wan3 = new MJCard(MJCard.Wan, 3); 
	private static final MJCard wan4 = new MJCard(MJCard.Wan, 4); 
	private static final MJCard wan5 = new MJCard(MJCard.Wan, 5); 
	private static final MJCard wan6 = new MJCard(MJCard.Wan, 6); 
	private static final MJCard wan7 = new MJCard(MJCard.Wan, 7); 
	private static final MJCard wan8 = new MJCard(MJCard.Wan, 8); 
	private static final MJCard wan9 = new MJCard(MJCard.Wan, 9); 
	
	private static final MJCard fengdong = new MJCard(MJCard.Feng, 1); 
	private static final MJCard fengxi = new MJCard(MJCard.Feng, 2); 
	private static final MJCard fengnan = new MJCard(MJCard.Feng, 3); 
	private static final MJCard fengbei = new MJCard(MJCard.Feng, 4); 
	
	private static final MJCard zhong = new MJCard(MJCard.Jian, 1); 
	private static final MJCard fa = new MJCard(MJCard.Jian, 2); 
	private static final MJCard bai = new MJCard(MJCard.Jian, 3); 
	
	private static final MJCard chun = new MJCard(MJCard.Hua, 1); 
	private static final MJCard xia = new MJCard(MJCard.Hua, 2); 
	private static final MJCard qiu = new MJCard(MJCard.Hua, 3); 
	private static final MJCard dong = new MJCard(MJCard.Hua, 4); 
	private static final MJCard mei = new MJCard(MJCard.Hua, 5); 
	private static final MJCard lan = new MJCard(MJCard.Hua, 6); 
	private static final MJCard zu = new MJCard(MJCard.Hua, 7); 
	private static final MJCard ju = new MJCard(MJCard.Hua, 8); 
	
	private static final MJCard laiziSys = new MJCard(MJCard.Laizi, 1);
	private static final MJCard laizi = new MJCard(MJCard.Laizi, 2);
	

	/** 获取所有牌型数组 */
	public static MJCard[] getCardArr() {
		MJCard[] card = { tong1, tong2, tong3, tong4, tong5, tong6, tong7,
				tong8, tong9, tiao1, tiao2, tiao3, tiao4, tiao5, tiao6,
				tiao7, tiao8, tiao9,wan1, wan2, wan3, wan4, wan5,
				wan6, wan7, wan8, wan9, fengdong, fengnan, fengxi,
				fengbei, zhong, fa, bai, chun, xia,
				qiu, dong, mei, lan, zu, ju };
		return card;
	}

	/**
	 * 获取指定牌型
	 * 
	 * @param types
	 *            牌类集合， 0=筒，1=条子，2=万，3=风，4=将，5=花
	 * @return
	 */
	public static ArrayList<MJCard> getCardArr(Set<Integer> types) {
		ArrayList<MJCard> cardList = new ArrayList<MJCard>();
		// 放入筒子
		if (types.contains(MJCard.Tong)) {
			cardList.add(tong1);
			cardList.add(tong2);
			cardList.add(tong3);
			cardList.add(tong4);
			cardList.add(tong5);
			cardList.add(tong6);
			cardList.add(tong7);
			cardList.add(tong8);
			cardList.add(tong9);
		}
		// 放入条子
		if (types.contains(MJCard.Tiao)) {
			cardList.add(tiao1);
			cardList.add(tiao2);
			cardList.add(tiao3);
			cardList.add(tiao4);
			cardList.add(tiao5);
			cardList.add(tiao6);
			cardList.add(tiao7);
			cardList.add(tiao8);
			cardList.add(tiao9);
		}
		// 放入万
		if (types.contains(MJCard.Wan)) {
			cardList.add(wan1);
			cardList.add(wan2);
			cardList.add(wan3);
			cardList.add(wan4);
			cardList.add(wan5);
			cardList.add(wan6);
			cardList.add(wan7);
			cardList.add(wan8);
			cardList.add(wan9);
		}
		// 放入风
		if (types.contains(MJCard.Feng)) {
			cardList.add(fengdong);
			cardList.add(fengnan);
			cardList.add(fengxi);
			cardList.add(fengbei);
		}
		// 放入将
		if (types.contains(MJCard.Jian)) {
			cardList.add(zhong);
			cardList.add(fa);
			cardList.add(bai);
		}
		// 放入花
		if (types.contains(MJCard.Hua)) {
			cardList.add(chun);
			cardList.add(xia);
			cardList.add(qiu);
			cardList.add(dong);
			cardList.add(mei);
			cardList.add(lan);
			cardList.add(zu);
			cardList.add(ju);
		}
		return cardList;

	}
	
	public static MJCard getOneCard(int num,int type) {
		return getOneCard(type * 10 + num);
	}
	
	public static MJCard getOneCard(int number) {
		int num = number % 10;
		int type= number / 10;
		if(type == MJCard.Tong) {
			if(num == 1) {
				return tong1;
			}else if(num == 2) {
				return tong2;
			}else if(num == 3) {
				return tong3;
			}else if(num == 4) {
				return tong4;
			}else if(num == 5) {
				return tong5;
			}else if(num == 6) {
				return tong6;
			}else if(num == 7) {
				return tong7;
			}else if(num == 8) {
				return tong8;
			}else if(num == 9) {
				return tong9;
			}
		}else if(type == MJCard.Tiao) {
			if(num == 1) {
				return tiao1;
			}else if(num == 2) {
				return tiao2;
			}else if(num == 3) {
				return tiao3;
			}else if(num == 4) {
				return tiao4;
			}else if(num == 5) {
				return tiao5;
			}else if(num == 6) {
				return tiao6;
			}else if(num == 7) {
				return tiao7;
			}else if(num == 8) {
				return tiao8;
			}else if(num == 9) {
				return tiao9;
			}
		}else if(type == MJCard.Wan) {
			if(num == 1) {
				return wan1;
			}else if(num == 2) {
				return wan2;
			}else if(num == 3) {
				return wan3;
			}else if(num == 4) {
				return wan4;
			}else if(num == 5) {
				return wan5;
			}else if(num == 6) {
				return wan6;
			}else if(num == 7) {
				return wan7;
			}else if(num == 8) {
				return wan8;
			}else if(num == 9) {
				return wan9;
			}
		}else if(type == MJCard.Feng) {
			if(num == 1) {
				return fengdong;
			}else if(num == 2) {
				return fengnan;
			}else if(num == 3) {
				return fengxi;
			}else if(num == 4) {
				return fengbei;
			}
		}else if(type == MJCard.Jian) {
			if(num == 1) {
				return zhong;
			}else if(num == 2) {
				return fa;
			}else if(num == 3) {
				return bai;
			}
		}else if(type == MJCard.Hua) {
			if(num == 1) {
				return chun;
			}else if(num == 2) {
				return xia;
			}else if(num == 3) {
				return qiu;
			}else if(num == 4) {
				return dong;
			}else if(num == 5) {
				return mei;
			}else if(num == 6) {
				return lan;
			}else if(num == 7) {
				return zu;
			}else if(num == 8) {
				return ju;
			}
		}else if(type == MJCard.Laizi) {
			if(num == 1) {				
				return laiziSys;
			}else if(num == 2){
				return laizi;
			}
		}
		return null;
	}
}

核心算法

public class MJUtil {

	public static boolean checkHu(LinkedList<MJCard> cards, MJCard otherCard, List<MJCard> laizi,List<List<MJCard>> huCardGroup) {
		// 查将
		LinkedList<MJCard> temp = new LinkedList<MJCard>(cards);
		if (otherCard != null) {
			temp.add(otherCard);
		}
		soreCard(temp);
		List<MJCard> laiziList = new ArrayList<MJCard>();
		Iterator<MJCard> iterator = temp.iterator();
		while (iterator.hasNext()) {
			MJCard next = iterator.next();
			if (laizi.contains(next)) {
				iterator.remove();
				laiziList.add(next);
			}
		}
		if (temp.size() < 2) {
			return true;
		}
		if (temp.size() == 2) {
			MJCard c1 = temp.get(0);
			MJCard c2 = temp.get(1);
			if (c1 == c2) {
				return true;
			} else {
				if (laiziList.size() > 0) {
					if(laiziList.size() == 1 && c1.getType() == c2.getType()) {
						if (Math.abs(c1.getNum() - c2.getNum()) < 3) {
							return true;
						}
					}else if(laiziList.size() >= 3){
						return true;
					}else {
						return false;
					}
					
				}
			}
		}
		// 检查七对
		if(temp.size() + laiziList.size() == 14) {			
			boolean qidui = true;
			MJCard index = null;
			List<MJCard> laiziListTemp = new ArrayList<MJCard>(laiziList);
			int count = 0;
			for (int i = 0; i < temp.size(); i++) {
				MJCard mjCard = temp.get(i);
				if (index == null) {
					index = mjCard;
					count = 1;
				} else {
					if (index == mjCard) {
						count += 1;
					} else {
						if (count % 2 != 0) {
							if(laiziListTemp.size() > 0) {
								laiziListTemp.remove(0);
							}else {								
								qidui = false;
								break;
							}
						} else {
							index = mjCard;
							count = 1;
						}
					}
				}
			}
			if (qidui && count % 2 != 1) {
				return true;
			}
		}
		//全杠不可胡
		if(temp.size() == 14) {
			//11112222333344
			MJCard tmepFind = null;
			int tempCount = 0;
			List<MJCard> gangC = new ArrayList<MJCard>();
			for(MJCard c : temp) {
				if(tmepFind == null) {
					tmepFind = c;
					tempCount = 1;
				}else {
					if(tmepFind == c) {
						tempCount += 1;
						if(tempCount == 4) {
							gangC.add(c);
						}
					}else if(tempCount == 4) {
						tmepFind = c;
						tempCount = 1;
					}else {
						break;					
					}
				}
			}
			if(gangC.size() == 3) {
				if(gangC.get(0).getType() != gangC.get(1).getType() || gangC.get(0).getType() != gangC.get(2).getType()) {					
					return false;
				}
				if(gangC.get(0).getNum() + 1 != gangC.get(1).getNum() || gangC.get(1).getNum() + 1 != gangC.get(2).getNum()) {
					return false;
				}
			}
		}
		
		Set<MJCard> jiangList = new HashSet<MJCard>(temp);
		//幺九放最后面,牌型幺九有特殊需求
		LinkedList<MJCard> jiangListList = new LinkedList<MJCard>();
		for(MJCard c : jiangList) {
			if(c.getNum() % 10 == 1 || c.getNum() % 10 == 9) {
				jiangListList.addLast(c);
			}else {
				jiangListList.addFirst(c);
			}
		}
		for (MJCard c : jiangListList) {
			huCardGroup.clear();
			List<MJCard> tempLaizi = new ArrayList<MJCard>(laiziList);
			LinkedList<MJCard> tempCheck = new LinkedList<MJCard>(temp);
			tempCheck.remove(c);
			if (!tempCheck.contains(c)) {
				continue;
			}
			tempCheck.remove(c);
			List<MJCard> j = new ArrayList<MJCard>();
			j.add(c);
			j.add(c);
			huCardGroup.add(j);
			LinkedList<MJCard> tong = new LinkedList<MJCard>();
			LinkedList<MJCard> tiao = new LinkedList<MJCard>();
			LinkedList<MJCard> wan = new LinkedList<MJCard>();
			for (MJCard c1 : tempCheck) {
				if (c1.getType() == MJCard.Tong) {
					tong.add(c1);
				} else if (c1.getType() == MJCard.Tiao) {
					tiao.add(c1);
				} else if (c1.getType() == MJCard.Wan) {
					wan.add(c1);
				}
			}
			if (tong.size() != 0) {
				boolean checkCardList = checkCardListNew(tong, tempLaizi,huCardGroup);
				if (!checkCardList) {
					continue;
				}
			}
			if (tiao.size() != 0) {
				boolean checkCardList = checkCardListNew(tiao, tempLaizi,huCardGroup);
				if (!checkCardList) {
					continue;
				}
			}
			if (wan.size() != 0) {
				boolean checkCardList = checkCardListNew(wan, tempLaizi,huCardGroup);
				if (!checkCardList) {
					continue;
				}
			}
			if(tempLaizi.size() % 3 != 0) {
				continue;
			}
			return true;
		}
		//癞子去单
		if (laiziList.size() > 0) {
			for (MJCard mjCard : jiangListList) {
				huCardGroup.clear();
				int count = 0;
				for(MJCard c : temp) {
					if(c == mjCard) {
						count += 1;
					}
				}
				if(count > 1) {
					continue;
				}
				List<MJCard> tempLaizi = new ArrayList<MJCard>(laiziList);
				LinkedList<MJCard> tempCheck = new LinkedList<MJCard>(temp);
				tempCheck.remove(mjCard);
				MJCard remove = tempLaizi.remove(0);
				List<MJCard> j = new ArrayList<MJCard>();
				j.add(mjCard);
				j.add(remove);
				huCardGroup.add(j);
				LinkedList<MJCard> tong = new LinkedList<MJCard>();
				LinkedList<MJCard> tiao = new LinkedList<MJCard>();
				LinkedList<MJCard> wan = new LinkedList<MJCard>();
				for (MJCard c1 : tempCheck) {
					if (c1.getType() == MJCard.Tong) {
						tong.add(c1);
					} else if (c1.getType() == MJCard.Tiao) {
						tiao.add(c1);
					} else if (c1.getType() == MJCard.Wan) {
						wan.add(c1);
					}
				}
				if (tong.size() != 0) {
					int laiziCount = tempLaizi.size();
					int tongCount = tong.size();
					boolean checkCardList = checkCardListNew(tong, tempLaizi,huCardGroup);
					if (!checkCardList || (tongCount + laiziCount - tempLaizi.size()) % 3 != 0) {
						continue;
					}
				}
				if (tiao.size() != 0) {
					int laiziCount = tempLaizi.size();
					int tiaoCount = tiao.size();
					boolean checkCardList = checkCardListNew(tiao, tempLaizi,huCardGroup);
					if (!checkCardList || (tiaoCount + laiziCount - tempLaizi.size()) % 3 != 0) {
						continue;
					}
				}
				if (wan.size() != 0) {
					int laiziCount = tempLaizi.size();
					int wanCount = wan.size();
					boolean checkCardList = checkCardListNew(wan, tempLaizi,huCardGroup);
					if (!checkCardList || (wanCount + laiziCount - tempLaizi.size()) % 3 != 0) {
						continue;
					}
				}
				if(tempLaizi.size() % 3 != 0) {
					continue;
				}
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 公式AAA*z+ABC*y+AA<br>
	 * 单双不过,并且在外部已经去将牌<br>
	 * 思路<br>
	 * 1:AAAA是必拆组合,并且后两张必须存在
	 * 
	 * @param list
	 * @param laiziList
	 * @param mjCardCount
	 * @return
	 */
	private static boolean checkCardListNew(LinkedList<MJCard> list, List<MJCard> laiziList,List<List<MJCard>> huCardGroup) {
		LinkedList<MJCard> left = new LinkedList<MJCard>(list);
		LinkedList<MJCard> laiziListleft = new LinkedList<MJCard>(laiziList);
		int times = 20;
		do {
			MJCard indexTemp = null;
			int countTemp = 0;
			for (int i = 0; i < left.size(); i++) {
				if(indexTemp == null) {
					indexTemp = left.get(i);
					countTemp += 1;
				}else {
					if(indexTemp == left.get(i)) {
						countTemp += 1;
					}else {
						if(countTemp == 3) {
							indexTemp = left.get(i);
							countTemp = 1;
							continue;
						}
						break;
					}
				}
			}
			MJCard num1 = MJCards.getOneCard(indexTemp.getNum() + 1, indexTemp.getType());//隐藏牌编号10
			MJCard num2 = MJCards.getOneCard(indexTemp.getNum() + 2, indexTemp.getType());//隐藏牌编号10 11
			if(countTemp == 1) {
				//只能是第一张
				List<MJCard> temp = new ArrayList<MJCard>();
				temp.add(indexTemp);
				left.remove(indexTemp);
				if(left.contains(num1)) {
					left.remove(num1);
					temp.add(num1);
				}else {
					if(laiziListleft.size() > 0) {
						MJCard remove = laiziListleft.remove(0);
						temp.add(remove);
					}else {
						return false;
					}
				}
				if(left.contains(num2)) {
					left.remove(num2);
					temp.add(num2);
				}else {
					if(laiziListleft.size() > 0) {
						MJCard remove = laiziListleft.remove(0);
						temp.add(remove);
					}else {
						return false;
					}
				}
				huCardGroup.add(temp);
			}else if(countTemp == 2) {
				//只能是前两张
				List<MJCard> temp1 = new ArrayList<MJCard>();
				List<MJCard> temp2 = new ArrayList<MJCard>();
				temp1.add(indexTemp);
				temp2.add(indexTemp);
				left.remove(indexTemp);
				left.remove(indexTemp);
				if(left.contains(num1) || left.contains(num2)) {
					//考虑一下AA赖
					boolean isok = false;
					LinkedList<MJCard> leftTemp = new LinkedList<MJCard>(left);
					LinkedList<MJCard> laiziListleftTemp = new LinkedList<MJCard>(laiziListleft);
					if(laiziListleftTemp.size() > 0) {
						laiziListleftTemp.remove(0);
						List<List<MJCard>> huCardGroupTemp = new ArrayList<List<MJCard>>();
						isok = checkCardListNew(leftTemp, laiziListleftTemp,huCardGroupTemp);
						if(isok) {	
							MJCard remove = laiziListleft.remove(0);
							temp1.add(indexTemp);
							temp1.add(remove);
							temp2.clear();
						}
					}
					if(!isok) {						
						if(left.contains(num1)) {
							left.remove(num1);
							temp1.add(num1);
							if(left.contains(num1)) {
								left.remove(num1);
								temp2.add(num1);
							}else {
								if(laiziListleft.size() > 0) {
									MJCard remove = laiziListleft.remove(0);
									temp2.add(remove);
								}else {
									return false;
								}
							}
						}else {
							if(laiziListleft.size() > 1) {
								MJCard remove = laiziListleft.remove(0);
								laiziListleft.remove(0);
								temp1.add(remove);
								temp2.add(remove);
							}else {
								return false;
							}
						}
						if(left.contains(num2)) {
							left.remove(num2);
							temp1.add(num2);
							if(left.contains(num2)) {
								left.remove(num2);
								temp2.add(num2);
							}else {
								if(laiziListleft.size() > 0) {
									MJCard remove = laiziListleft.remove(0);
									temp1.add(remove);
								}else {
									return false;
								}
							}
						}else {
							if(laiziListleft.size() > 1) {
								MJCard remove = laiziListleft.remove(0);
								laiziListleft.remove(0);
								temp1.add(remove);
								temp2.add(remove);
							}else {
								return false;
							}
						}
					}
					huCardGroup.add(temp1);
					if(!temp2.isEmpty()) {						
						huCardGroup.add(temp2);
					}
				}else {
					if(laiziListleft.size() > 0) {
						MJCard remove = laiziListleft.remove(0);
						temp1.add(indexTemp);
						temp1.add(remove);
						temp2.clear();
						huCardGroup.add(temp1);
					}else {
						return false;
					}
				}
			}else if(countTemp == 4) {
				List<MJCard> temp = new ArrayList<MJCard>();
				temp.add(indexTemp);
				left.remove(indexTemp);
				if(left.contains(num1)) {
					left.remove(num1);
					temp.add(num1);
				}else {
					if(laiziListleft.size() > 0) {
						MJCard remove = laiziListleft.remove(0);
						temp.add(remove);
					}else {
						return false;
					}
				}
				if(left.contains(num2)) {
					left.remove(num2);
					temp.add(num2);
				}else {
					if(laiziListleft.size() > 0) {
						MJCard remove = laiziListleft.remove(0);
						temp.add(remove);
					}else {
						return false;
					}
				}
				huCardGroup.add(temp);
			}else {
				//将三张集合
				if(!left.isEmpty()) {
					for(int j=0;j<left.size() / 3 ;j++) {
						List<MJCard> temp = new ArrayList<MJCard>();
						temp.add(left.get(j));
						temp.add(left.get(j+1));
						temp.add(left.get(j+2));
						huCardGroup.add(temp);
					}
				}
				//结束
				laiziList.clear();
				laiziList.addAll(laiziListleft);
				return true;
			}
			times -= 1;
			if(left.isEmpty()) {
				laiziList.clear();
				laiziList.addAll(laiziListleft);
				return true;
			}
		}while(true && times > 0);
		if(times <= 0) {
			return false;
		}
		return true;
	}
	
	private static void soreCard(LinkedList<MJCard> cards) {
		Collections.sort(cards,new Comparator<MJCard>() {
			@Override
			public int compare(MJCard o1, MJCard o2) {
				return o1.getNumValue() - o2.getNumValue();
			}
		});
	}
}

测试函数

public static void whileCheckHu(int count,int laiziCount) {
		System.out.println("开始"+System.currentTimeMillis());
		File file = new File("d://nohu.txt");
		try (FileOutputStream fos = new FileOutputStream(file);
				OutputStreamWriter osw = new OutputStreamWriter(fos);BufferedWriter bw = new BufferedWriter(osw);){
			Random r = new Random();
			List<MJCard> laizi = new LinkedList<MJCard>();
			MJCard laizi1 = MJCards.getOneCard(1, MJCard.Laizi);
			laizi.add(laizi1);
			for(int i=0;i<count;i++) {
				Map<Integer, Integer> cardsCount = new HashMap<Integer, Integer>();
				List<Integer> allCards = new ArrayList<Integer>();
				int jiang = r.nextInt(9) + 1;
				allCards.add(jiang);
				allCards.add(jiang);
				cardsCount.put(jiang, 2);
				int zu1 = r.nextInt(5);
				int zu2 = 4 - zu1;
				while(zu1 > 0) {
					int get1 = r.nextInt(9) + 1;
					if(r.nextBoolean()) {
						//砍
						if(get1 == 8) {
							if(cardsCount.containsKey(get1)) {
								if(cardsCount.get(get1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1, 0);
							}
							if(cardsCount.containsKey(get1 - 1)) {
								if(cardsCount.get(get1 - 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 - 1, 0);
							}
							if(cardsCount.containsKey(get1 + 1)) {
								if(cardsCount.get(get1 + 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 + 1, 0);
							}
							allCards.add(get1 - 1);
							allCards.add(get1);
							allCards.add(get1 + 1);
							cardsCount.put(get1, cardsCount.get(get1) + 1);
							cardsCount.put(get1 - 1, cardsCount.get(get1 - 1) + 1);
							cardsCount.put(get1 + 1, cardsCount.get(get1 + 1) + 1);
							zu1 -= 1;
						}else if(get1 == 9) {
							if(cardsCount.containsKey(get1)) {
								if(cardsCount.get(get1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1, 0);
							}
							if(cardsCount.containsKey(get1 - 1)) {
								if(cardsCount.get(get1 - 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 - 1, 0);
							}
							if(cardsCount.containsKey(get1 - 2)) {
								if(cardsCount.get(get1 - 2) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 - 2, 0);
							}
							allCards.add(get1 - 1);
							allCards.add(get1);
							allCards.add(get1 - 2);
							cardsCount.put(get1, cardsCount.get(get1) + 1);
							cardsCount.put(get1 - 1, cardsCount.get(get1 - 1) + 1);
							cardsCount.put(get1 - 2, cardsCount.get(get1 - 2) + 1);
							zu1 -= 1;
						}else {
							if(cardsCount.containsKey(get1)) {
								if(cardsCount.get(get1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1, 0);
							}
							if(cardsCount.containsKey(get1 + 1)) {
								if(cardsCount.get(get1 + 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 + 1, 0);
							}
							if(cardsCount.containsKey(get1 + 2)) {
								if(cardsCount.get(get1 + 2) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 + 2, 0);
							}
							allCards.add(get1);
							allCards.add(get1 + 1);
							allCards.add(get1 + 2);
							cardsCount.put(get1, cardsCount.get(get1) + 1);
							cardsCount.put(get1 + 1, cardsCount.get(get1 + 1) + 1);
							cardsCount.put(get1 + 2, cardsCount.get(get1 + 2) + 1);
							zu1 -= 1;
						}
					}else {
						//碰
						if(cardsCount.containsKey(get1)) {
							if(cardsCount.get(get1) + 3 > 4) {
								continue;
							}
						}else {
							cardsCount.put(get1, 0);
						}
						allCards.add(get1);
						allCards.add(get1);
						allCards.add(get1);
						cardsCount.put(get1, cardsCount.get(get1) + 3);
						zu1 -= 1;
					}
				}
				while(zu2 > 0) {
					int get1 = r.nextInt(9) + 11;
					if(r.nextBoolean()) {
						if(get1 == 18) {
							if(cardsCount.containsKey(get1)) {
								if(cardsCount.get(get1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1, 0);
							}
							if(cardsCount.containsKey(get1 - 1)) {
								if(cardsCount.get(get1 - 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 - 1, 0);
							}
							if(cardsCount.containsKey(get1 + 1)) {
								if(cardsCount.get(get1 + 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 + 1, 0);
							}
							allCards.add(get1 - 1);
							allCards.add(get1);
							allCards.add(get1 + 1);
							cardsCount.put(get1, cardsCount.get(get1) + 1);
							cardsCount.put(get1 - 1, cardsCount.get(get1 - 1) + 1);
							cardsCount.put(get1 + 1, cardsCount.get(get1 + 1) + 1);
							zu2 -= 1;
						}else if(get1 == 19) {
							if(cardsCount.containsKey(get1)) {
								if(cardsCount.get(get1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1, 0);
							}
							if(cardsCount.containsKey(get1 - 1)) {
								if(cardsCount.get(get1 - 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 - 1, 0);
							}
							if(cardsCount.containsKey(get1 - 2)) {
								if(cardsCount.get(get1 - 2) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 - 2, 0);
							}
							allCards.add(get1 - 1);
							allCards.add(get1);
							allCards.add(get1 - 2);
							cardsCount.put(get1, cardsCount.get(get1) + 1);
							cardsCount.put(get1 - 1, cardsCount.get(get1 - 1) + 1);
							cardsCount.put(get1 - 2, cardsCount.get(get1 - 2) + 1);
							zu2 -= 1;
						}else {
							if(cardsCount.containsKey(get1)) {
								if(cardsCount.get(get1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1, 0);
							}
							if(cardsCount.containsKey(get1 + 1)) {
								if(cardsCount.get(get1 + 1) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 + 1, 0);
							}
							if(cardsCount.containsKey(get1 + 2)) {
								if(cardsCount.get(get1 + 2) + 1 > 4) {
									continue;
								}
							}else {
								cardsCount.put(get1 + 2, 0);
							}
							allCards.add(get1);
							allCards.add(get1 + 1);
							allCards.add(get1 + 2);
							cardsCount.put(get1, cardsCount.get(get1) + 1);
							cardsCount.put(get1 + 1, cardsCount.get(get1 + 1) + 1);
							cardsCount.put(get1 + 2, cardsCount.get(get1 + 2) + 1);
							zu2 -= 1;
						}
					}else {
						if(cardsCount.containsKey(get1)) {
							if(cardsCount.get(get1) + 3 > 4) {
								continue;
							}
						}else {
							cardsCount.put(get1, 0);
						}
						allCards.add(get1);
						allCards.add(get1);
						allCards.add(get1);
						cardsCount.put(get1, cardsCount.get(get1) + 3);
						zu2 -= 1;
					}
				}
				Collections.sort(allCards);
				LinkedList<MJCard> cards = new LinkedList<MJCard>();
				for(int c : allCards) {
					cards.add(MJCards.getOneCard(c % 10, c/ 10));
				}
				for(int j=0;j<laiziCount;j++) {
					cards.remove(r.nextInt(cards.size()));
					cards.add(laizi1);
				}
				soreCard(cards);
				List<List<MJCard>> huCardGroup = new ArrayList<>();
				boolean checkHu = MJUtil.checkHu(cards, null, laizi,huCardGroup);
				if(checkHu) {			
//					System.out.println(allCards+" "+checkAnGang.getType());
				}else {
					bw.write(cards.toString()+"\n");
//					System.out.println("no"+"  "+allCards);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("结束"+System.currentTimeMillis());
	}
	
	private static void soreCard(LinkedList<MJCard> cards) {
		Collections.sort(cards,new Comparator<MJCard>() {
			@Override
			public int compare(MJCard o1, MJCard o2) {
				return o1.getNumValue() - o2.getNumValue();
			}
		});
	}

 

RayJimHeaven
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
麻将胡牌算法
LG_227的博客
04-05 3518
本文实现了一个胡牌算法，目前支持视频中讲解的三种番型，更多番型或者其它番型大家可以结合当地的麻将进行二次开发，项目中不仅有后台胡牌算法，而且还配备了前台页面，开发人员可以在前台中直接输入麻将对应的数据，操作十分方便。具体细节请观看视频讲解视频和demo下载地址：wisdomdd.cn视频中的源码可以点击【下载实例】进行下载, 环境配置: Eclipse+Maven+JDK1.7环境下载地址: ht...
麻将胡牌算法(查表法 和 拆解法)
woshiyuanlei的专栏
07-06 1万+
/* 1.查表法计算麻将胡牌(原理:http://hp.vector.co.jp/authors/VA046927/mjscore/mjalgorism.html) 2.跟拆解法对比进行效率比较 */ package main import ( "fmt" "time" "sort" "os" "encoding/json" "log" "runtim
麻将算法之 ------ 胡牌算法
weixin_38082526的博客
07-15 1万+
麻将数据牌集合 private int[] cardDataArray = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 1 2 3 4 5 6 7 8 9 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //...
棋牌游戏算法——麻将系列总结
从事棋.牌行业五年，参与项目从0到1的过程，担任过海外项目的技术负责人，对业务中的俱乐部设计，玩法设计，架构，算法，数据有深刻的理解。
06-21 6618
麻将的胡牌算法，各种不同的麻将类型分析，总结。麻将的查表法，回溯法。
c++麻将胡牌算法，癞子胡牌算法
04-02
本项目主要探讨了如何使用C++语言实现麻将胡牌算法，包括普通胡牌规则以及特殊的“癞子”（也称为万能牌）胡牌规则。这里我们将深入解析这两种算法的核心原理。 首先，我们来看基础的麻将胡牌算法。麻将是一种四人...
麻将癞子胡牌算法
05-17
麻将癞子胡牌算法，效率超快。4个5个癞子都测试过，python语言写的。
golang版超高效带癞子麻将胡牌算法
10-23
golang版麻将胡牌算法，包含带癞子和不带癞子，将gui_index 设置为34 就是不带癞子的麻将胡牌算法，gui_index 设置为[0，34）就是带癞子的麻将胡牌算法
四川麻将胡牌算法
06-12
四川麻将是一种广受欢迎的麻将游戏，其规则独特，胡牌方式多样。...通过巧妙地运用递归算法，我们可以有效地检测出任意14张牌是否构成胡牌，从而在虚拟的麻将桌上体验到与真实游戏相似的智慧较量。
麻将算法源码（任意癞子）
02-10
分享一个麻将胡牌算法，支持多癞子，自己对麻将胡牌的理解写的一套快速识别胡牌逻辑，核心逻辑500行代码，仅对同条万进行处理，字花牌不包含在内，易理解，1M次随机胡牌牌型大概3秒左右。原创分享，我的算法也许可以...
node.js——麻将算法（五）胡牌算法的一些优化处理方案（有赖子版）
九日王朝
09-01 7645
以前有赖子判胡算法 http://blog.csdn.net/sm9sun/article/details/65632646 以前的帖子说明了处理赖子的两种方案：枚举代替及插空补缺，并最终选择了枚举遍历方案，因为当初考虑的是通过GetAppointList方法已经会剔除大多数无关联的牌了，且后期大家通过吃碰杠等也会减少手牌，姑且认为n的值为10，因为大多数麻将四个赖子直接胡。所以三
麻将胡牌算法思路(任意赖子)
最最亮的星的博客
11-30 1万+
看网上算法穷举，枚举，剔除特殊情况等等很乱，感觉还是写一套通用的逻辑比较好。 这个算法前后修改了几次，最终在三星s4这种老的安卓机上计算一次时间在0.04s左右。 总体思路：首先需要一对将牌，剩下的牌任意组合，都组成顺子或者坎牌就可以胡牌了。 发完牌，手牌13张，要胡牌的话是14张，我们插入一张赖子牌。 每张牌都可能做为将牌，就算只有一张，还有一张赖子牌可以组成将牌，我们先遍历麻将牌列表，...
麻将胡牌算法的Java实现
嘿嘿
10-10 2663
最近一个棋牌游戏项目中涉及对麻将胡牌的判定，网上搜了搜虽然看到一些算法，但是感觉都不尽如人意，一般麻将的胡牌为1对和4组三张牌的连牌，所以在网上搜到的算法往往都死死的为了这个目的来实现，而且多数没有考虑到对百塔牌的支持,下面贴上代码: /*  * To change this license header, choose License Headers in Project Properties...
麻将胡牌算法 极速(速度接近理论极限)
qq_38880234的博客
08-08 1万+
此麻将胡牌算法优点： 1.可处理多赖子牌（万能牌） 2.算法速度极快：1ms可大约计算1W+副手牌是否可胡（带赖子、0.08us左右），不带赖子的牌型更快。（最新版的算法速度感觉已很接近理论极限值） 3.不同玩法的麻将，可用同一套胡牌算法，加载不同的胡牌配置文件即可。 4.查bug方便 先讲下理论基础： 将麻将的牌 所有牌值对应的索引设为下面的值 static const B
麻将胡牌判定的判定算法
pyb的博客
01-13 7606
麻将胡牌判定的判定算法 问题背景 : 简化了麻将规则,给定[1s-9s],[1b-9b],[1t-9t]一共27种牌,每种牌都有4张。需要判断给定的牌是不是胡牌。 胡牌的定义为: 14张牌里面由一个对子,四个坎组成。其中对子代表两张一样的牌,坎代表三张一样的牌,或者三张连续的牌(连续指: 1s,2s,3s | 4t,5t,6t) 举例： 1s,1s,2t,3t,4
麻将胡牌万能公式：
热门推荐
嘿嘿
10-09 19万+
基本胡牌类型: M*AAA + N*ABC + DD （AAA 是三个刻字， ABC 是顺子， DD 是将牌）  麻将总共14张，m和n系数，AAA代表一样的三个，ABC代表连着的三个。DD代表两张一样的。所以和牌的方法就有，当m=0、n=4再加上DD，或者当m=1、n=3 再加上DD，或者当m=2、n=2再加上DD，或者当m=3，n=1再加上DD。 扩展资料： 5个问题+1个公式，1分钟麻...
golang麻将胡牌算法
最新发布
10-29
麻将胡牌算法是用来判断一手牌是否能够胡牌的算法，它是在麻将游戏中非常重要的一部分。 Golang中可以使用递归的方式实现麻将胡牌算法。首先，我们需要定义麻将的牌型和点数，例如万、筒、索，以及相应的编号。然后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值