project euler 54

最新推荐文章于 2019-02-18 17:36:00 发布
最新推荐文章于 2019-02-18 17:36:00 发布
阅读量602 收藏
点赞数
分类专栏： project euler
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whuawell/article/details/50180075
版权

Problem 54

Poker hands

In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way:

  • High Card: Highest value card.
  • One Pair: Two cards of the same value.
  • Two Pairs: Two different pairs.
  • Three of a Kind: Three cards of the same value.
  • Straight: All cards are consecutive values.
  • Flush: All cards of the same suit.
  • Full House: Three of a kind and a pair.
  • Four of a Kind: Four cards of the same value.
  • Straight Flush: All cards are consecutive values of same suit.
  • Royal Flush: Ten, Jack, Queen, King, Ace, in same suit.

The cards are valued in the order:2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, Ace.

If two players have the same ranked hands then the rank made up of the highest value wins; for example, a pair of eights beats a pair of fives (see example 1 below). But if two ranks tie, for example, both players have a pair of queens, then highest cards in each hand are compared (see example 4 below); if the highest cards tie then the next highest cards are compared, and so on.

Consider the following five hands dealt to two players:

Hand Player 1 Player 2 Winner
1 5H 5C 6S 7S KD 2C 3S 8S 8D TD Player 2
  Pair of Fives Pair of Eights  
2 5D 8C 9S JS AC 2C 5C 7D 8S QH Player 1
  Highest card Ace Highest card Queen  
3 2D 9C AS AH AC 3D 6D 7D TD QD Player 2
  Three Aces Flush with Diamonds  
4 4D 6S 9H QH QC 3D 6D 7H QD QS Player 1
  Pair of Queens Pair of Queens  
  Highest card Nine Highest card Seven  
5 2H 2D 4C 4D 4S 3C 3D 3S 9S 9D Player 1
  Full House Full House  
  with Three Fours with Three Threes  

The file, poker.txt, contains one-thousand random hands dealt to two players. Each line of the file contains ten cards (separated by a single space): the first five are Player 1’s cards and the last five are Player 2’s cards. You can assume that all hands are valid (no invalid characters or repeated cards), each player’s hand is in no specific order, and in each hand there is a clear winner.

How many hands does Player 1 win?

扑克手牌

在扑克游戏中，玩家的手牌由五张牌组成，其等级由低到高分别为：

  • 单牌：牌面最大的一张牌。
  • 对子：两张牌面一样的牌。
  • 两对：两个不同的对子。
  • 三条：三张牌面一样的牌。
  • 顺子：五张牌的牌面是连续的。
  • 同花：五张牌是同一花色。
  • 葫芦：三条带一个对子。
  • 四条：四张牌面一样的牌。
  • 同花顺：五张牌的牌面是连续的且为同一花色。
  • 同花大顺：同一花色的10、J、Q、K、A。

牌面由小到大的顺序是：2、3、4、5、6、7、8、9、10、J、Q、K、A。

如果两名玩家的手牌处于同一等级，那么牌面较大的一方获胜；例如，一对8胜过一对5（参见例1）；如果牌面相同，例如双方各有一对Q，那么就比较玩家剩余的牌中最大的牌（参见例4）；如果最大的牌相同，则比较次大的牌，依此类推。

考虑以下五局游戏中双方的手牌：

手牌 玩家1 玩家2 胜者
1 红桃5 草花5 黑桃6 黑桃7 方片K 草花2 黑桃3 黑桃8 方片8 方片10 玩家2
  一对5 一对8  
2 方片5 草花8 黑桃9 黑桃J 草花A 草花2 草花5 方片7 黑桃8 红桃Q 玩家1
  单牌A 单牌Q  
3 方片2 草花9 黑桃A 红桃A 草花A 方片3 方片6 方片7 方片10 方片Q 玩家2
  三条A 同花方片  
4 方片4 黑桃6 红桃9 红桃Q 草花Q 方片3 方片6 红桃7 方片Q 黑桃Q 玩家1
  一对Q 一对Q  
  最大单牌9 最大单牌7  
5 红桃2 方片2 草花4 方片4 黑桃4 草花3 方片3 黑桃3 黑桃9 方片9 玩家1
  葫芦 葫芦  
  （三条4） （三条3）  

在这个文本文件poker.txt中，包含有两名玩家一千局的手牌。每一行包含有10张牌（均用一个空格隔开）：前5张牌属于玩家1，后5张牌属于玩家2。你可以假定所有的手牌都是有效的（没有无效的字符或是重复的牌），每个玩家的手牌不一定按顺序排列，且每一局都有确定的赢家。

其中有多少局玩家1获胜？

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

import PokerHandRankEnum.PokerHand;
import PokerHandRankEnum.PokerHandList;
import junit.framework.TestCase;

public class Prj54 extends TestCase {

	
	static int NUM_OF_PLAYER1 = 0;
	static int NUM_OF_PLAYER2 = 0;
	
	static final String PATH = "D:\\Prj54.txt";
	
	public void testPokerHands() throws IOException {

		BufferedReader reader = new BufferedReader(new InputStreamReader(
				new FileInputStream(PATH), "utf8"));

		String str = "";

		while ((str = reader.readLine()) != null) {

			String[] spStrs = splitStrs(str);

			parserPokerHands(spStrs, str);

		}

		reader.close();

	}

	private void parserPokerHands(String[] spStrs, String str) {

		assert (spStrs.length == 10);
		PokerHandList lfList = new PokerHandList();
		PokerHandList rtList = new PokerHandList();

		for (int i = 0; i < spStrs.length; i++) {
			PokerHand pk = new PokerHand();
			pk.suite = String.valueOf(spStrs[i].charAt(1));
			pk.card = PokerHandCardEnum.getCard(String.valueOf(spStrs[i]
					.charAt(0)));

			if (i < 5) {
				lfList.dataList.add(pk);
			} else {
				rtList.dataList.add(pk);
			}
		}
		
		int cmp = lfList.compareTo(rtList);
		if( cmp == 0){
			
		}else if( cmp < 0){
			NUM_OF_PLAYER2 ++;
		}else{
			NUM_OF_PLAYER1 ++;
		}

		
		String fstr = "NUM_OF_PLAYER1=%d,NUM_OF_PLAYER2=%d, Str=%s";
		fstr = String.format(fstr, NUM_OF_PLAYER1, NUM_OF_PLAYER2, str);
		System.out.println(fstr);
	}

	public static String[] splitStrs(String str) {

		StringTokenizer tk = new StringTokenizer(str);
		List<String> strList = new ArrayList<String>();
		while (tk.hasMoreElements()) {
			strList.add(tk.nextToken(" "));
		}

		String[] strs = new String[strList.size()];
		for (int i = 0; i < strList.size(); i++) {
			strs[i] = strList.get(i);
		}
		return strs;
	}

	public static enum PokerHandCardEnum {
		N2(2), N3(3), N4(4), N5(5), N6(6), N7(7), N8(8), N9(9), N10(10), J(11), Q(
				12), K(13), A(14);

		private int val;

		PokerHandCardEnum(int val) {
			this.val = val;
		}

		public static PokerHandCardEnum getCard(String sign) {
			
			if( sign.equals("2")){
				return N2;
			}else if( sign.equals("3")){
				return N3;
			}else if( sign.equals("4")){
				return N4;
			}else if( sign.equals("5")){
				return N5;
			}else if( sign.equals("6")){
				return N6;
			}else if( sign.equals("7")){
				return N7;
			}else if( sign.equals("8")){
				return N8;
			}else if( sign.equals("9")){
				return N9;
			}else if( sign.equals("T")){
				return N10;
			}else if( sign.equals("J")){
				return J;
			}else if( sign.equals("Q")){
				return Q;
			}else if( sign.equals("K")){
				return K;
			}else if( sign.equals("A")){
				return A;
			}
			
			
			return null;
		}

		public int getValue() {
			return val;
		}
	}

	public static enum PokerHandRankEnum {
		High_Card(1), One_Pair(2), Two_Pairs(3), Three_of_a_Kind(4), Straight(5), Flush(
				6), Full_House(7), Four_of_a_Kind(8), Straight_Flush(9), Royal_Flush(
				10);

		private int val;

		PokerHandRankEnum(int val) {
			this.val = val;
		}

		public int getValue() {
			return val;
		}

		public static PokerHandRankEnum getPokerHandRankEnum(
				List<PokerHand> dataList) {

			PokerHand o1 = dataList.get(0);
			PokerHand o2 = dataList.get(1);
			PokerHand o3 = dataList.get(2);
			PokerHand o4 = dataList.get(3);
			PokerHand o5 = dataList.get(4);

			Set<String> suites = new HashSet<String>();
			suites.addAll(Arrays.asList(new String[] { o1.suite, o2.suite,
					o3.suite, o4.suite, o5.suite }));

			Set<PokerHandCardEnum> cards = new HashSet<PokerHandCardEnum>();
			cards.addAll(Arrays.asList(new PokerHandCardEnum[] { o1.card,
					o2.card, o3.card, o4.card, o5.card }));

			if (suites.size() == 1) {
				// Royal_Flush
				if (o1.card.equals(PokerHandCardEnum.N10)
						&& o1.card.equals(PokerHandCardEnum.J)
						&& o1.card.equals(PokerHandCardEnum.Q)
						&& o1.card.equals(PokerHandCardEnum.K)
						&& o1.card.equals(PokerHandCardEnum.A)) {
					return Royal_Flush;
				}

				// Straight_Flush
				if (cards.size() == 5) {
					if (o5.card.getValue() - o1.card.getValue() == 4) {
						return Straight_Flush;
					}
				}
			}

			// Four_of_a_Kind
			if (o1.card.equals(o2.card) && o1.card.equals(o3.card)
					&& o1.card.equals(o4.card)) {
				return Four_of_a_Kind;
			}

			if (o5.card.equals(o2.card) && o5.card.equals(o3.card)
					&& o5.card.equals(o4.card)) {
				return Four_of_a_Kind;
			}

			// Full_House
			if (o1.card.equals(o2.card) && o1.card.equals(o3.card)
					&& o4.card.equals(o5.card)) {
				return Full_House;
			}

			if (o5.card.equals(o3.card) && o5.card.equals(o4.card)
					&& o1.card.equals(o2.card)) {
				return Full_House;
			}

			// Flush
			if (suites.size() == 1) {
				return Flush;
			}

			// Straight
			if (cards.size() == 5) {
				if (o5.card.getValue() - o1.card.getValue() == 4) {
					return Straight;
				}
			}

			// Three_of_a_Kind
			if (o1.card.equals(o2.card) && o1.card.equals(o3.card)) {
				return Three_of_a_Kind;
			}

			if (o2.card.equals(o3.card) && o2.card.equals(o4.card)) {
				return Three_of_a_Kind;
			}
			if (o3.card.equals(o4.card) && o3.card.equals(o5.card)) {
				return Three_of_a_Kind;
			}

			// Two_Pairs
			if (o1.card.equals(o2.card) && o3.card.equals(o4.card)) {
				return Two_Pairs;
			}

			if (o1.card.equals(o2.card) && o4.card.equals(o5.card)) {
				return Two_Pairs;
			}
			if (o2.card.equals(o3.card) && o4.card.equals(o5.card)) {
				return Two_Pairs;
			}

			// One_Pair
			if (o1.card.equals(o2.card)) {
				return One_Pair;
			}
			if (o2.card.equals(o3.card)) {
				return One_Pair;
			}
			if (o3.card.equals(o4.card)) {
				return One_Pair;
			}
			if (o4.card.equals(o5.card)) {
				return One_Pair;
			}

			return High_Card;
		}

		public static int compareSame(List<PokerHand> dataList,
				List<PokerHand> dataList2, PokerHandRankEnum type) {

			switch (type) {
			case Straight_Flush: {
				return comp(dataList.get(0).card.getValue(),
						dataList2.get(0).card.getValue());
			}
			case Four_of_a_Kind: {
				return compFourOfAKind(dataList, dataList2);
			}
			case Full_House: {
				return compFull_House(dataList, dataList2);
			}

			case Flush: {
				return compFlush(dataList, dataList2);
			}

			case Straight: {
				return compStraight(dataList, dataList2);
			}

			case Three_of_a_Kind: {

				return compThree_of_a_Kind(dataList, dataList2);
			}

			case Two_Pairs: {
				return compTwo_Pairs(dataList, dataList2);
			}

			case One_Pair: {
				return compOne_Pair(dataList, dataList2);
			}

			case High_Card: {
				return compHigh_Card(dataList, dataList2);
			}

			default:
				break;
			}
			return 0;
		}

		private static int compHigh_Card(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			for (int i = dataList.size() - 1; i >= 0; i--) {
				PokerHandCardEnum p1 = dataList.get(i).card;
				PokerHandCardEnum p2 = dataList2.get(i).card;

				if (p1.getValue() == p2.getValue()) {
					continue;
				} else if (p1.getValue() < p2.getValue()) {
					return -1;
				} else {
					return 1;
				}

			}
			return 0;
		}

		private static int compOne_Pair(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			PokerHand o1 = dataList.get(0);
			PokerHand o2 = dataList.get(1);
			PokerHand o3 = dataList.get(2);
			PokerHand o4 = dataList.get(3);
			PokerHand o5 = dataList.get(4);

			PokerHand o11 = dataList2.get(0);
			PokerHand o21 = dataList2.get(1);
			PokerHand o31 = dataList2.get(2);
			PokerHand o41 = dataList2.get(3);
			PokerHand o51 = dataList2.get(4);

			PokerHandCardEnum p11 = null;
			PokerHandCardEnum p12 = null;
			PokerHandCardEnum p13 = null;
			PokerHandCardEnum p14 = null;

			PokerHandCardEnum p21 = null;
			PokerHandCardEnum p22 = null;
			PokerHandCardEnum p23 = null;
			PokerHandCardEnum p24 = null;

			if (o1.card.getValue() == o2.card.getValue()) {
				p11 = o1.card;
				p12 = o5.card;
				p13 = o4.card;
				p14 = o3.card;
			}
			if (o2.card.getValue() == o3.card.getValue()) {
				p11 = o2.card;
				p12 = o5.card;
				p13 = o4.card;
				p14 = o1.card;
			}
			if (o3.card.getValue() == o4.card.getValue()) {
				p11 = o3.card;
				p12 = o5.card;
				p13 = o2.card;
				p14 = o1.card;
			}
			if (o4.card.getValue() == o5.card.getValue()) {
				p11 = o4.card;
				p12 = o3.card;
				p13 = o2.card;
				p14 = o1.card;
			}

			if (o11.card.getValue() == o21.card.getValue()) {
				p21 = o11.card;
				p22 = o51.card;
				p23 = o41.card;
				p24 = o31.card;
			}
			if (o21.card.getValue() == o31.card.getValue()) {
				p21 = o21.card;
				p22 = o51.card;
				p23 = o41.card;
				p24 = o11.card;
			}
			if (o31.card.getValue() == o41.card.getValue()) {
				p21 = o31.card;
				p22 = o51.card;
				p23 = o21.card;
				p24 = o11.card;
			}
			if (o41.card.getValue() == o51.card.getValue()) {
				p21 = o41.card;
				p22 = o31.card;
				p23 = o21.card;
				p24 = o11.card;
			}

			List<PokerHandCardEnum> pList1 = Arrays
					.asList(new PokerHandCardEnum[] { p11, p12, p13, p14 });
			List<PokerHandCardEnum> pList2 = Arrays
					.asList(new PokerHandCardEnum[] { p21, p22, p23, p24 });

			for (int i = 0; i < pList1.size(); i++) {

				PokerHandCardEnum p1 = pList1.get(i);
				PokerHandCardEnum p2 = pList2.get(i);

				if (p1.getValue() == p2.getValue()) {
					continue;
				} else if (p1.getValue() < p2.getValue()) {
					return -1;
				} else {
					return 1;
				}
			}

			return 0;

		}

		private static int compTwo_Pairs(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			PokerHand o1 = dataList.get(0);
			PokerHand o2 = dataList.get(1);
			PokerHand o3 = dataList.get(2);
			PokerHand o4 = dataList.get(3);
			PokerHand o5 = dataList.get(4);

			PokerHand o11 = dataList2.get(0);
			PokerHand o21 = dataList2.get(1);
			PokerHand o31 = dataList2.get(2);
			PokerHand o41 = dataList2.get(3);
			PokerHand o51 = dataList2.get(4);

			PokerHandCardEnum p11 = null;
			PokerHandCardEnum p12 = null;
			PokerHandCardEnum p13 = null;

			PokerHandCardEnum p21 = null;
			PokerHandCardEnum p22 = null;
			PokerHandCardEnum p23 = null;

			if (o1.card.getValue() == o2.card.getValue()
					&& o3.card.getValue() == o4.card.getValue()) {
				p11 = o3.card;
				p12 = o1.card;
				p13 = o5.card;
			}
			if (o1.card.getValue() == o2.card.getValue()
					&& o4.card.getValue() == o5.card.getValue()) {
				p11 = o4.card;
				p12 = o1.card;
				p13 = o3.card;
			}
			if (o2.card.getValue() == o3.card.getValue()
					&& o4.card.getValue() == o5.card.getValue()) {
				p11 = o4.card;
				p12 = o2.card;
				p13 = o1.card;
			}

			if (o11.card.getValue() == o21.card.getValue()
					&& o31.card.getValue() == o41.card.getValue()) {
				p21 = o31.card;
				p22 = o11.card;
				p23 = o51.card;
			}
			if (o11.card.getValue() == o21.card.getValue()
					&& o41.card.getValue() == o51.card.getValue()) {
				p21 = o41.card;
				p22 = o11.card;
				p23 = o31.card;
			}
			if (o21.card.getValue() == o31.card.getValue()
					&& o41.card.getValue() == o51.card.getValue()) {
				p21 = o41.card;
				p22 = o21.card;
				p23 = o11.card;
			}

			if (p11.getValue() == p21.getValue()) {

				if (p12.getValue() == p22.getValue()) {

					if (p13.getValue() == p23.getValue()) {
						return 0;
					} else if (p13.getValue() < p23.getValue()) {
						return -1;
					} else {
						return 1;
					}

				} else if (p12.getValue() < p22.getValue()) {
					return -1;
				} else {
					return 1;
				}

			} else if (p11.getValue() < p21.getValue()) {
				return -1;
			} else {
				return 1;
			}

		}

		private static int compThree_of_a_Kind(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			PokerHand o1 = dataList.get(0);
			PokerHand o2 = dataList.get(1);
			PokerHand o3 = dataList.get(2);
			PokerHand o4 = dataList.get(3);
			PokerHand o5 = dataList.get(4);

			PokerHand o11 = dataList2.get(0);
			PokerHand o21 = dataList2.get(1);
			PokerHand o31 = dataList2.get(2);
			PokerHand o41 = dataList2.get(3);
			PokerHand o51 = dataList2.get(4);

			PokerHandCardEnum p11 = null;
			PokerHandCardEnum p12 = null;
			PokerHandCardEnum p13 = null;

			PokerHandCardEnum p21 = null;
			PokerHandCardEnum p22 = null;
			PokerHandCardEnum p23 = null;

			if (o1.card.getValue() == o2.card.getValue()
					&& o2.card.getValue() == o3.card.getValue()) {
				p11 = o1.card;
				p12 = o5.card;
				p13 = o4.card;
			}
			if (o2.card.getValue() == o3.card.getValue()
					&& o3.card.getValue() == o4.card.getValue()) {
				p11 = o2.card;
				p12 = o5.card;
				p13 = o1.card;
			}
			if (o3.card.getValue() == o4.card.getValue()
					&& o4.card.getValue() == o5.card.getValue()) {
				p11 = o3.card;
				p12 = o2.card;
				p13 = o1.card;
			}

			if (o11.card.getValue() == o21.card.getValue()
					&& o21.card.getValue() == o31.card.getValue()) {
				p21 = o11.card;
				p22 = o51.card;
				p23 = o41.card;
			}
			if (o21.card.getValue() == o31.card.getValue()
					&& o31.card.getValue() == o41.card.getValue()) {
				p21 = o21.card;
				p22 = o51.card;
				p23 = o11.card;
			}
			if (o31.card.getValue() == o41.card.getValue()
					&& o41.card.getValue() == o51.card.getValue()) {
				p21 = o31.card;
				p22 = o21.card;
				p23 = o11.card;
			}

			if (p11.getValue() == p21.getValue()) {

				if (p12.getValue() == p22.getValue()) {

					if (p13.getValue() == p23.getValue()) {
						return 0;
					} else if (p13.getValue() < p23.getValue()) {
						return -1;
					} else {
						return 1;
					}

				} else if (p12.getValue() < p22.getValue()) {
					return -1;
				} else {
					return 1;
				}

			} else if (p11.getValue() < p21.getValue()) {
				return -1;
			} else {
				return 1;
			}

		}

		private static int compStraight(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			PokerHandCardEnum card1 = dataList.get(4).card;
			PokerHandCardEnum card2 = dataList2.get(4).card;
			if (card1.getValue() == card2.getValue()) {
				return 0;
			} else if (card1.getValue() < card2.getValue()) {
				return -1;
			} else {
				return 1;
			}
		}

		private static int compFlush(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			for (int i = dataList.size() - 1; i >= 0; i--) {
				PokerHandCardEnum card1 = dataList.get(i).card;
				PokerHandCardEnum card2 = dataList2.get(i).card;
				if (card1.getValue() == card2.getValue()) {
					continue;
				} else if (card1.getValue() < card2.getValue()) {
					return -1;
				} else {
					return 1;
				}
			}

			return 0;

		}

		private static int compFull_House(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			PokerHand o1 = dataList.get(0);
			PokerHand o3 = dataList.get(2);
			PokerHand o5 = dataList.get(4);

			PokerHand o11 = dataList2.get(0);
			PokerHand o31 = dataList2.get(2);
			PokerHand o51 = dataList2.get(4);

			PokerHandCardEnum p11 = null;
			PokerHandCardEnum p12 = null;
			PokerHandCardEnum p21 = null;
			PokerHandCardEnum p22 = null;

			if (o3.card.getValue() == o1.card.getValue()) {
				p11 = o1.card;
				p12 = o5.card;
			} else {
				p11 = o5.card;
				p12 = o1.card;
			}

			if (o31.card.getValue() == o11.card.getValue()) {
				p21 = o11.card;
				p22 = o51.card;
			} else {
				p21 = o51.card;
				p22 = o11.card;
			}

			if (p11.getValue() == p21.getValue()) {
				if (p12.getValue() == p22.getValue()) {
					return 0;
				} else if (p12.getValue() < p22.getValue()) {
					return -1;
				} else {
					return 1;
				}
			} else if (p11.getValue() < p21.getValue()) {
				return -1;
			} else {
				return 1;
			}
		}

		private static int compFourOfAKind(List<PokerHand> dataList,
				List<PokerHand> dataList2) {

			PokerHand o1 = dataList.get(0);
			PokerHand o2 = dataList.get(1);
			PokerHand o5 = dataList.get(4);

			PokerHand o11 = dataList2.get(0);
			PokerHand o21 = dataList2.get(1);
			PokerHand o51 = dataList2.get(4);

			PokerHandCardEnum p11 = null;
			PokerHandCardEnum p12 = null;
			PokerHandCardEnum p21 = null;
			PokerHandCardEnum p22 = null;

			if (o1.card.equals(o2.card)) {
				p12 = o5.card;
				p11 = o1.card;
			} else {
				p12 = o1.card;
				p11 = o5.card;
			}

			if (o11.card.equals(o21.card)) {
				p22 = o51.card;
				p21 = o11.card;
			} else {
				p22 = o11.card;
				p21 = o51.card;
			}

			if (p11.getValue() == p21.getValue()) {

				if (p12.getValue() == p22.getValue()) {
					return 0;
				} else if (p12.getValue() < p22.getValue()) {
					return -1;
				} else {
					return 1;
				}

			} else if (p11.getValue() < p21.getValue()) {
				return -1;
			} else {
				return 1;
			}

		}

		public static int comp(int i, int j) {
			if (i < j) {
				return -1;
			} else if (i == j) {
				return 0;
			} else {
				return 1;
			}
		}

		public static class PokerHand implements Comparable<PokerHand> {

			public PokerHandCardEnum card;
			public String suite;

			@Override
			public int compareTo(PokerHand o) {

				return comp(card.getValue(), o.card.getValue());
			}

		}

		public static class PokerHandList implements Comparable<PokerHandList> {
			public List<PokerHand> dataList = new ArrayList<PokerHand>();

			@Override
			public int compareTo(PokerHandList o) {

				Collections.sort(dataList);
				Collections.sort(o.dataList);

				PokerHandRankEnum o1 = PokerHandRankEnum
						.getPokerHandRankEnum(dataList);
				PokerHandRankEnum o2 = PokerHandRankEnum
						.getPokerHandRankEnum(o.dataList);

				String rankStr = "p1=%s ,p2=%s";
				rankStr = String.format(rankStr, o1.name(), o2.name());
				System.out.println(rankStr);
				
				if (o1.getValue() == o2.getValue()) {
					return PokerHandRankEnum.compareSame(dataList, o.dataList,
							o1);
				} else if (o1.getValue() < o2.getValue()) {
					return -1;
				} else {
					return 1;
				}
			}
		}

	}
}


whuawell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Project Euler 36-40题
PFCC的博客
09-26 485
第36题 题目来源ProjectEuler这一题求的是小于1,000,000的所有数中，在十进制和二进制表示下都是回文数的数的和。 枚举每个数，检验即可，复杂度O(nlogn)O(n\log n) 另一种方法，可枚举前一半的位上的数字，然后将整个数加上去，由于这样产生的所有数都是结果的一部分，省去了许多冗余的运算，会更快一些。但是代码复杂度更高一些。 我使用的是第一种方法：#include<
Project Euler 31-35题
PFCC的博客
09-20 1102
第31题 题目来源ProjectEuler这一题求200可以由1，2，5，10，20，50，100，200以多少种不同的方式相加而成。 将硬币分别标记为f[1]=1;f[2]=2;f[3]=5;f[4]=10;f[5]=20;f[6]=50;f[7]=100];f[8]=200; 使用dp[i][j]dp[i][j]表示利用最大面额为f[j]的纸币组成i有多少种方法。 转移就是dp[i][j
Project Euler
01-03
C语言练习题，不记得是在哪里找到的了，自己还没看完 下来试试看 htm格式的
Project Euler 54
weixin_30343157的博客
02-18 95
#include<bits/stdc++.h> using namespace std; string ss[5]; string tt[5]; int num=0; map<char,int> mp; //map<char,char> cc; int x,x1,x2,x3,x4,x5; int y,y1,y2,y3,y4,y5; bool...
Euler Project 54
weixin_42147487的博客
06-04 352
In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way:High Card: Highest value card.One Pair: Two cards of the same value.Two Pairs: Two di...
Project Euler ：Problem 54 Poker hands
312小公举的专栏
07-07 1174
In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way: High Card: Highest value card.One Pair: Two cards of the same value.Two Pairs: Tw
Project Euler 54 Poker hands(模拟+hash)
Uranux
01-25 758
超级传送门：http://projecteuler.net/problem=54   刚看到题目描述，就联想到天津Regional的A题麻将那题，可惜没能AC，遗憾了好久。 这题比麻将那题要简单一些，规则描述比较清楚，要比较两手梭哈牌的大小，我用了hash来存牌，定义了各种判定判断函数来进行判断。 代码量还是比较大的，差不多600行，写的过程中很容易错。Unix/Linux设计思想——小即
Project Euler 问题 54 的解决方案：在扑克游戏中，玩家 1 赢了多少手？-matlab开发
06-01
这是这里发现的问题的解决方案： 当我解决这个问题时，我发现代码是模块化和简单的。 我认为它可以帮助其他人学习逻辑思维以及如何将一个大问题简化为几个小问题。 这就是为什么我认为我在这里提交解决方案并没有...
projecteuler.net:我对 Project Euler 问题的一些解决方案
07-20
在这个"projecteuler.net:我对 Project Euler 问题的一些解决方案"中，我们可以预见到包含的是作者对 Project Euler 题目的Java实现。 在项目中，"projecteuler.net-master"很可能是一个GitHub仓库的名字，通常这样...
project-euler:我对projecteuler.net上问题的解决方案
04-13
在这个压缩包“project-euler-master”中，很显然包含了作者对Project Euler问题的Python解决方案。 在Python编程语言中解决Project Euler问题，我们可以学习到许多关键的编程概念和技术。以下是一些可能涵盖的知识...
project_euler:欧拉计划（Project Euler）是一系列具有挑战性的数学计算机编程问题，这些问题不仅需要数学方面的知识来解决。 尽管数学将帮助您找到优雅而有效的方法，但仍需要使用计算机和编程技能来解决大多数问题。 发起Euler项目及其延续的动机是为研究者提供一个平台，使他们能够探索陌生的领域并在娱乐和休闲的环境中学习新的概念
03-30
欧拉计划 欧拉计划（Project Euler）是一系列具有挑战性的数学/计算机编程问题，需要解决的不仅仅是数学方面的知识。 尽管数学将帮助您找到优雅而有效的方法，但仍需要使用计算机和编程技能来解决大多数问题。 发起Euler项目及其延续的动机是为研究者提供一个平台，使他们能够探索陌生的领域并在娱乐和休闲的环境中学习新的概念。 您可以找到更多详细 该存储库仅包含前一百个问题的解决方案。 问题1 问题2 问题3 问题4 问题5 问题6 问题7 问题8 问题9 问题10 问题11 问题12 问题13 问题14 问题15 问题16 问题17 问题18 问题19 问题20 问题21 问题22 问题23 问题24 问题25 问题26 问题27 问题28 问题29 问题30 问题31 问题32 问题33 问题34 问题35 问题
Project-Euler:欧拉计划（Project Euler）是一系列具有挑战性的数学计算机编程问题，这些问题不仅需要数学方面的知识来解决。尽管数学将帮助您找到优雅而有效的方法，但仍需要使用计算机和编程技巧来解决大多数问题。发起Euler项目及其延续的动机是为研究者提供一个平台，使他们能够探索陌生的领域并在娱乐和休闲的环境中学习新的概念。该存储库是我针对Euler项目尝试的每个问题的所有解决方案
03-19
项目欧拉 欧拉计划（Project Euler）是一系列具有挑战性的数学/计算机编程问题，不仅需要数学方面的知识来解决，还需要更多。尽管数学将帮助您找到优雅而有效的方法，但仍需要使用计算机和编程技巧来解决大多数问题。 发起Euler项目及其延续的动机是为研究者提供一个平台，使他们能够探索陌生的领域并在娱乐和休闲的环境中学习新的概念。该存储库是我针对Euler项目尝试的每个问题的所有解决方案。
Project-Euler:ProjectEuler +解决方案
05-15
该软件包包含我针对Euler项目问题​​的解决方案代码。 源代码包括对所涉及数学的详细说明，以证明程序中的逻辑合理。 此代码仅供“参考”。 您需要事先获得书面许可才能执行以下任何操作：逐字重新发布代码，发布经过修改的代码，将部分代码合并到您自己的工作中，等等。 版权所有:copyright:2015 Project Peeyushy95。 版权所有。 没有保修。
ProjectEuler:Project Euler 问题的解决方案
06-12
"Project Euler: Project Euler 问题的解决方案"是一个与编程挑战相关的项目，主要集中在使用JavaScript解决数学和计算问题。Project Euler是一个著名的在线平台，它提供了一系列的数学和计算机科学问题，旨在提升...
Project Euler problem 54
水
11-06 590
一道有点复杂的模拟题吧。。 也不算难写 细节上注意一下就行了。。 首先就是判断rank。 这个还是好判断的。 如果rank一样就要把每个人手中的牌按优先级排列一下，两人按顺序比较 这个优先级，说例子吧。 假如是两个对儿的。  优先比较的肯定是大的那个对儿，然后是小的那个对儿，再然后是那个单张的 再说一个 有一对儿还有三张一样的。 优先比较的是三张的，再比较一对儿的 再一个例子，就有一个对
Project Euler Problem 54： Poker hands【模拟】
nobleman
02-11 497
PE其他解题报告请参考这里,本题答案在留言首条 Poker hands Problem 54 In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way: High Card: Highest value card. One ...
Project Euler Problem 54 (C++和Python代码实现和解析)***
jiafengfu的CSDN博客
12-19 548
Problem 54: Poker hands In the card game poker, a hand consists of five cards and are ranked, from lowest to highest, in the following way: High Card: Highest value card. One Pair: Two cards of the s...
openeuler安装openstack
最新发布
12-02
以下是在openeuler上安装OpenStack的步骤： 1. 确保你的openeuler系统已经安装了必要的软件包和依赖项。可以使用以下命令安装： ```shell sudo dnf install -y python3-devel libffi-devel gcc openssl-devel `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值