devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java实现德州扑克比较大小_java 德州七选五

作者：羊村懒王 | 2024-04-02 16:19:55

赞

踩

java 德州七选五

源码

https://gitee.com/wangLi1997/poker_run

业务流程：

接口一：每个用户发放7张牌
接口二：用户选中其中5张牌

具体业务实现：

步骤一：先对牌做等级的划分（防止相同牌型出现并列排名的问题）
步骤二：再对相同牌型做排序
规则参考

在这里插入图片描述

规则明细

https://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2FOKobrQZryfH0ufaPNA0eeZ00zkfj1ZB8rz8pEgDihJL5t1517883939520compressflag.jpg&thumbnail=660x2147483647&quality=80&type=jpg

德州扑克规则
先比较牌型大小

牌型大小：
（1）基本法则是：“先比牌型后比点数”。
（2）牌型的大小顺序为：同花顺＞铁支＞葫芦＞同花＞顺子＞三条＞二对＞对子＞散牌
（3）点数大小顺序为：A＞K＞Q＞J＞10＞9＞8＞7＞6＞5＞4＞3＞2
（4）共有9种牌型。分别是：同花顺 铁支 葫芦 同花 顺子 三条 二对 对子 散牌
（5）牌型的大小顺序为：同花顺＞铁支＞葫芦＞同花＞顺子＞三条＞二对＞对子＞散牌
（6）不同牌型之间的大小按上方的大小顺序来比较。如果是相同牌型之间的比较呢？下面将逐一介绍
当牌型相同的时候，按照以下规则比较大小

1. 皇家同花顺之间的比较：
    2个玩家都是皇家同花顺，和。

2. 同花顺之间的比较：
    A、同花顺虽然以花色成牌型，但两个同花顺相比时不比花色，只比点数，从最大的一张牌开始比起，大者胜；
    B、如果相同，则再比稍小一点的那张，大者胜；
    C、如果再相同再往下比，直到分出大小来；
    D、若是五张牌的点数都一样大，则两个同花顺同样大小。
    E、比如黑桃的10、J、Q、K、A与梅花的10、J、Q、K、A相比，两者是同样大小的。

3. 铁支之间的比较：
    A、铁支的大小比较只看4条的点数。
    B、4条点数大的胜。
    C、如果4条点数相同（只有都取公牌时才会出现这种情况），则比杂牌大小，杂牌大者胜。如果杂牌点数也相等，则同大。

4. 葫芦之间的比较：
    A、葫芦的大小比较只看3条的点数。
    B、3条点数大的胜。
    C、如果3条点数相同（只有都取公牌时才会出现这种情况），则比一对的大小，一对大者胜，如果一对也相等，则同大。
    
5. 同花之间的比较：
    A、同花之间的比较不看花色，而看单张最大一张牌的点数。
    B、如果最大的一张牌的点数一样大，则比相对小一点的那张牌点数；
    C、如果还一样大，再往下比，直到分出大小来；
    D、如果五张牌的点数都一样大，那么判断为同等大小。 （同花中，“A”为最大的牌）

6. 顺子之间的比较：
    A、顺子之间的比较跟同花顺的相同，也是从最大的第一张牌比起。
    B、如果最大的第一张牌相同，则再比稍小一点的那张。
    C、如果再相同再往下比，直到分出大小来。
    D、若是五张牌的点数都一样大，则两个顺子同样大小。
    E、A在做顺子牌型的时候，只会出现在顺首和顺尾，并且会有截然不同的效果。比如下面的例子：
    A、K、Q、J、10 在此牌型中“A”为顺尾，它作为最大的牌使用。
    5、4、3、2、A 在此牌型中“A”为顺首，它作为最小的牌使用。
    比如： 5、4、3、2、A 就比 6、5、4、3、2 要小。

7. 三条之间的比较
    三条之间的比较是先比3条的点数，3条大者胜。如果3条同大。则比最大的一张杂牌的大小，大者胜。如果最大的杂牌点数也相等，则比第二张杂牌的大小，大者胜。若还是相等，则同大。

8. 二对之间的比较
    A、二对之间的比较先看最大的一对，点数大的胜；
    B、如果点数相同，则比第二对，同样是点数大的胜；
    C、若第二对也相同，则比杂牌的大小，杂牌点数大者胜；
    D、要是连杂牌点数都一样了，判断为相同大小。

9. 对子之间的比较
    A、对子之间的比较先看对子的大小，点数大的胜；
    B、若点数相同，则再看最大的第一张杂牌，点数大的胜；
    C、最大的一张杂牌点数相同的话，比第二张大的杂牌，点数大的胜；
    D、如果再相同，则比最后一张杂牌的大小，点数大的胜；
    E、若都相同，则判断为相同大小。

10. 散牌之间的比较
    A、散牌之间的比较先看最大的一张牌的点数，大者胜；
    B、最大的牌相同的话，比第二大牌的点数，大者胜；
    C、再相同，再比下一张，大者胜；一直到比出为止；
    D、如果五张牌点数都一样大，则判断为相同大小。
    E、散牌比较中，“A”为最大的牌。



  • 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
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
牌型预估


import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.Map.Entry.comparingByKey;
import static java.util.Map.Entry.comparingByValue;
import static java.util.stream.Collectors.toMap;

/**
 * ClassName PokerHelper
 *
 * @author wang
 * Date 2022/3/21 18:15
 */
@Component
@Slf4j
public class PokerHelper {

    public static PokerInfoData POKER_INFO_DATA = null;

    public static final Integer DIFF_NUM = 2;

    @PostConstruct
    public static void init() {
        log.info("init poker data...");
        JSONObject map = new JSONObject();
        int i = 0;
        for (PokerColorEnum pokerColor : PokerColorEnum.values()) {
            for (PokerEnum poker : PokerEnum.values()) {
                i++;
                PokerData pokerData = new PokerData();
                pokerData.setDetail(pokerColor.getName() + poker.getName());
                pokerData.setPoker(poker.getWeight());
                pokerData.setPokerColor(pokerColor.toString());
                pokerData.setIdx(i);
                map.put(i + "", pokerData);
            }
        }
        POKER_INFO_DATA = new PokerInfoData();
        POKER_INFO_DATA.setPokerMap(map);
        log.info("init poker data end");
    }

    public static PokerInfoData initPokerGame() {
        return POKER_INFO_DATA;
    }


    /**
     * 发牌
     *
     * @param grantNum
     * @param pokerGame
     * @return
     */
    public static List<PokerData> grantPoker(Integer grantNum, GameRoom pokerGame) {
        List<PokerData> result = new ArrayList<>();
        JSONObject pokerMap = JSONObject.parseObject(pokerGame.getAllPokerList());
        Set<String> strings = pokerMap.keySet();
        if (pokerMap.size() < grantNum) {
            throw new ApiException(ApiStatus.POKER_HAS_RUN_OUT_FAIL);
        }
        LinkedList<String> indexList = new LinkedList<>(strings);
        for (int i = 1; i <= grantNum; i++) {
            Collections.shuffle(indexList);
            String poll;
            if (i % 2 == 0) {
                poll = indexList.pollFirst();
            } else {
                poll = indexList.pollLast();
            }
            assert poll != null;
            Object value = pokerMap.remove(poll);
            PokerData pokerData = JSONObject.parseObject(JSONObject.toJSONString(value), PokerData.class);
            result.add(pokerData);
        }
        pokerGame.setAllPokerList(pokerMap.toJSONString());
        return result;
    }

    /**
     * 计算得分
     *
     * @param list 前台选中的牌
     */
    public static Integer getPokerLevel(List<PokerData> list) {
        // 基础分数
        int level = 0;
        if (isSameColor(list) && isStraightV2(list)) {
            log.debug(PokerLevelEnum.STRAIGHT_FLUSH.toString());
            level = PokerLevelEnum.STRAIGHT_FLUSH.getWeight();
        } else if (isFourKind(list)) {
            log.debug(PokerLevelEnum.FOUR_OF_A_KIND.toString());
            level = PokerLevelEnum.FOUR_OF_A_KIND.getWeight();
        } else if (isFlushHouse(list)) {
            log.debug(PokerLevelEnum.FLUSH_HOUSE.toString());
            level = PokerLevelEnum.FLUSH_HOUSE.getWeight();
        } else if (isSameColor(list)) {
            log.debug(PokerLevelEnum.FLUSH.toString());
            level = PokerLevelEnum.FLUSH.getWeight();
        } else if (isStraightV2(list)) {
            log.debug(PokerLevelEnum.STRAIGHT.toString());
            level = PokerLevelEnum.STRAIGHT.getWeight();
        } else if (isThreeKind(list)) {
            log.debug(PokerLevelEnum.THREE_OF_A_KIND.toString());
            level = PokerLevelEnum.THREE_OF_A_KIND.getWeight();
        } else if (isTwoPair(list)) {
            log.debug(PokerLevelEnum.TWO_PAIR.toString());
            level = PokerLevelEnum.TWO_PAIR.getWeight();
        } else if (isOnePair(list)) {
            log.debug(PokerLevelEnum.ONE_PAIR.toString());
            level = PokerLevelEnum.ONE_PAIR.getWeight();
        } else if (isHighCard(list)) {
            level = PokerLevelEnum.HIGH_CARD.getWeight();
        }
        return level;
    }


    /**
     * 是不是同花
     *
     * @param requestPokerList
     * @return
     */
    public static boolean isSameColor(List<PokerData> requestPokerList) {
        String pokerColor = requestPokerList.get(0).getPokerColor();
        boolean flag = true;
        for (int i = 0; i < requestPokerList.size(); i++) {
            if (!pokerColor.equals(requestPokerList.get(i).getPokerColor())) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    /**
     * 是不是顺子
     *
     * @param
     * @return
     */
    public static boolean isStraight(List<PokerData> requestPokerList) {
        boolean flag = true;
        int[] poker = requestPokerList.stream().mapToInt(PokerData::getPoker).toArray();
        Arrays.sort(poker);
        int temp = poker[0];
        for (int i = 1; i < poker.length; i++) {
            if (poker[i] - temp == 1) {
                temp = poker[i];
            } else {
                flag = false;
                break;
            }
        }
        return flag;
    }

    /**
     * 是不是顺子
     *
     * @param
     * @return
     */
    public static boolean isStraightV2(List<PokerData> requestPokerList) {
        boolean flag = true;
        // 正序排序
        List<Integer> list = requestPokerList.stream().map(PokerData::getPoker).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
        list.removeIf(next -> next.equals(CompareHelper.BIG_ACE));
        int temp = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i) - temp == 1) {
                temp = list.get(i);
            } else {
                flag = false;
                break;
            }
        }
        if(flag){
            Integer first = list.get(0);
            Integer last = list.get(list.size() - 1);
            if(first == PokerEnum.TWO.getWeight() || last == PokerEnum.KING.getWeight()){
                return true;
            }
            flag = false;
        }
        return flag;
    }



    /**
     * 是不是四条
     *
     * @return
     */
    public static boolean isFourKind(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.TWO.getWeight()) {
            Collection<Integer> values = map.values();
            if (values.contains(PokerEnum.FOUR.getWeight()) && values.contains(CompareHelper.ONE)) {
                return true;
            }
        }
        return false;
    }


    /**
     * @param requestPokerList
     * @return （val - valCnt ）
     */
    public static Map<Integer, Integer> listToMap(List<PokerData> requestPokerList) {
        List<Integer> list = requestPokerList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer val : list) {
            map.put(val, map.containsKey(val) ? map.get(val) + 1 : 1);
        }
        return map;
    }


    /**
     * 是不是葫芦（三带二）
     *
     * @return
     */
    public static boolean isFlushHouse(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.TWO.getWeight()) {
            Collection<Integer> values = map.values();
            if (values.contains(PokerEnum.TWO.getWeight()) && values.contains(PokerEnum.THREE.getWeight())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是不是三条（如：3、3、3、4、10）
     *
     * @return
     */
    public static boolean isThreeKind(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        Collection<Integer> values = map.values();
        if (values.contains(PokerEnum.THREE.getWeight())) {
            return true;
        }
        return false;
    }

    /**
     * 是不是两对（如：3、3、4、4、10）
     *
     * @return
     */
    public static boolean isTwoPair(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.THREE.getWeight()) {
            Collection<Integer> values = map.values();
            Integer sum = values.stream().reduce(Integer::sum).orElse(0);
            if (sum == PokerEnum.FIVE.getWeight()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是不是一对（如：3、3、4、7、10）
     *
     * @return
     */
    public static boolean isOnePair(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.FOUR.getWeight()) {
            Collection<Integer> values = map.values();
            Integer sum = values.stream().reduce(Integer::sum).orElse(0);
            if (sum == PokerEnum.FIVE.getWeight()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是不是高牌（如：3、7、4、J、10）
     *
     * @return
     */
    public static boolean isHighCard(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.FIVE.getWeight()) {
            return true;
        }
        return false;
    }

    /**
     * 根据扑克等级排序
     * 如果等级相同，需要比较牌大小
     *
     * @param playerList
     */
    public static List<GameRecord> orderByPokerLevel(List<GameRecord> playerList) {
        // 未确认的先取出来
        List<GameRecord> nullLevel = new ArrayList<>();
        Iterator<GameRecord> iterator = playerList.iterator();
        while (iterator.hasNext()) {
            GameRecord next = iterator.next();
            if(Objects.isNull(next.getPokerLevel())){
                nullLevel.add(next);
                iterator.remove();
            }
        }
        List<GameRecord> result = new ArrayList<>();
        Map<Integer, List<GameRecord>> map = playerList.stream()
                .collect(Collectors.groupingBy(GameRecord::getPokerLevel, LinkedHashMap::new, Collectors.toList()));
        // 按key降序
        Map<Integer, List<GameRecord>> integerListMap = sortByKey(map, true);
        if (playerList.size() == map.size()) {
            return playerList;
        }
        for (Map.Entry<Integer, List<GameRecord>> integerListEntry : integerListMap.entrySet()) {
            List<GameRecord> value = integerListEntry.getValue();
            List<GameRecord> ret;
            if (value.size() == 1) {
                ret = value;
            } else {
                ret = compareAndSwap(value);
            }
            result.addAll(ret);
        }
        // 未确认的放到最后
        if(CollectionUtil.isNotEmpty(nullLevel)){
            result.addAll(nullLevel);
        }
        // 设置分数、排名
        int rankNum = 0;
        for (GameRecord gameRecord : result) {
            rankNum++;
            gameRecord.setRankNum(rankNum);
        }
        return result;
    }

    /**
     * 根据map的key排序
     *
     * @param map 待排序的map
     * @param isDesc 是否降序，true：降序，false：升序
     * @return 排序好的map
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }



    /**
     * 比较并且交换
     *
     * @param playerList
     * @return
     */
    public static List<GameRecord> compareAndSwap(List<GameRecord> playerList) {
        GameRecord[] players = new GameRecord[playerList.size()];
        for (int i = 0; i < playerList.size(); i++) {
            players[i] = playerList.get(i);
        }
        GameRecord temp;
        for (int i = 0; i < players.length - 1; i++) {
            // 定义一个布尔类型的变量，标记数组是否已达到有序状态
            boolean flag = true;
            for (int j = 0; j < players.length - 1 - i; j++) {
                GameRecord curr = players[j];
                GameRecord next = players[j + 1];
                int num = compareEqualsLevelPoker(curr, next);
                if (num == -1) {
                    temp = players[j];
                    players[j] = players[j + 1];
                    players[j + 1] = temp;
                    // 本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
                    flag = false;
                }
            }
            // 根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
            if (flag) {
                break;
            }
        }
        return Arrays.asList(players);
    }

    public static void main(String[] args) {
        List<PokerData> requestPokerList = new ArrayList<>();
        PokerData item = new PokerData();
        item.setPoker(2);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(14);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(4);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(3);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(5);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        List<PokerData> pokerData = orderByPoker(requestPokerList, 5);
        System.out.println(pokerData);
    }


    /**
     * curr > next  1
     * curr == next  0
     * curr < next  -1
     *
     * @param curr
     * @param next
     * @return
     */
    public static int compareEqualsLevelPoker(GameRecord curr, GameRecord next) {
        Integer pokerLevel = next.getPokerLevel();
        List<PokerData> currList = JSONObject.parseArray(curr.getConfirmPokerInfo(), PokerData.class);
        List<PokerData> nextList = JSONObject.parseArray(next.getConfirmPokerInfo(), PokerData.class);
        if (PokerLevelEnum.STRAIGHT_FLUSH.getWeight() == pokerLevel) {
            return CompareHelper.compareSameColorOrStraight(currList, nextList);
        } else if (PokerLevelEnum.FOUR_OF_A_KIND.getWeight() == pokerLevel) {
            return CompareHelper.compareFourKind(currList, nextList);
        } else if (PokerLevelEnum.FLUSH_HOUSE.getWeight() == pokerLevel) {
            return CompareHelper.compareFlushHouse(currList, nextList);
        } else if (PokerLevelEnum.FLUSH.getWeight() == pokerLevel) {
            return CompareHelper.compareSameColor(currList, nextList);
        } else if (PokerLevelEnum.STRAIGHT.getWeight() == pokerLevel) {
            return CompareHelper.compareSameColorOrStraight(currList, nextList);
        } else if (PokerLevelEnum.THREE_OF_A_KIND.getWeight() == pokerLevel) {
            return CompareHelper.compareThreeKind(currList, nextList);
        } else if (PokerLevelEnum.TWO_PAIR.getWeight() == pokerLevel) {
            return CompareHelper.compareTwoPair(currList, nextList);
        } else if (PokerLevelEnum.ONE_PAIR.getWeight() == pokerLevel) {
            return CompareHelper.compareOnePair(currList, nextList);
        } else if (PokerLevelEnum.HIGH_CARD.getWeight() == pokerLevel) {
            return CompareHelper.compareHighCard(currList, nextList);
        } else {
            return 0;
        }
    }

    /**
     * 从小到大排序
     * @param pokerList
     * @param pokerLevel
     * @return
     */
    public static List<PokerData> orderByPoker(List<PokerData> pokerList, Integer pokerLevel) {
        // 默认升序
        List<PokerData> list = pokerList.stream().sorted(Comparator.comparing(PokerData::getPoker)).collect(Collectors.toList());
        if(PokerLevelEnum.STRAIGHT.getWeight() == pokerLevel || PokerLevelEnum.STRAIGHT_FLUSH.getWeight() == pokerLevel){
            // 如果是  2 3 4 5 A ，需要交换位置
            Integer first = list.get(0).getPoker();
            Integer last = list.get(list.size() - 1).getPoker();
            if(first == PokerEnum.TWO.getWeight() && last == PokerEnum.ACE.getWeight()){
                LinkedList<PokerData> linkedList = new LinkedList<>(list);
                PokerData pokerData = linkedList.pollLast();
                linkedList.add(0, pokerData);
                return linkedList;
            }
        }
        return list;
    }
}



  • 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
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348
  • 349
  • 350
  • 351
  • 352
  • 353
  • 354
  • 355
  • 356
  • 357
  • 358
  • 359
  • 360
  • 361
  • 362
  • 363
  • 364
  • 365
  • 366
  • 367
  • 368
  • 369
  • 370
  • 371
  • 372
  • 373
  • 374
  • 375
  • 376
  • 377
  • 378
  • 379
  • 380
  • 381
  • 382
  • 383
  • 384
  • 385
  • 386
  • 387
  • 388
  • 389
  • 390
  • 391
  • 392
  • 393
  • 394
  • 395
  • 396
  • 397
  • 398
  • 399
  • 400
  • 401
  • 402
  • 403
  • 404
  • 405
  • 406
  • 407
  • 408
  • 409
  • 410
  • 411
  • 412
  • 413
  • 414
  • 415
  • 416
  • 417
  • 418
  • 419
  • 420
  • 421
  • 422
  • 423
  • 424
  • 425
  • 426
  • 427
  • 428
  • 429
  • 430
  • 431
  • 432
  • 433
  • 434
  • 435
  • 436
  • 437
  • 438
  • 439
  • 440
  • 441
  • 442
  • 443
  • 444
  • 445
  • 446
  • 447
  • 448
  • 449
  • 450
  • 451
  • 452
  • 453
  • 454
  • 455
  • 456
  • 457
  • 458
  • 459
  • 460
  • 461
  • 462
  • 463
  • 464
  • 465
  • 466
  • 467
  • 468
  • 469
  • 470
  • 471
  • 472
  • 473
  • 474
  • 475
  • 476
  • 477
  • 478
  • 479
  • 480
  • 481
  • 482
  • 483
  • 484
  • 485
  • 486
  • 487
  • 488
  • 489
  • 490
  • 491
  • 492
  • 493
  • 494
  • 495
  • 496
  • 497
  • 498
  • 499
  • 500
  • 501
相同牌型比较


import java.util.*;
import java.util.stream.Collectors;

/**
 * ClassName CompareHelper
 *
 * @author wang
 * Date 2022/4/7 8:54
 */
public class CompareHelper {

    public static final Integer BIG_ACE = 14;

    public static final Integer ONE = 1;

    public static final Integer TWO = 2;

    public static final Integer THREE = 3;

    public static final Integer FOUR = 4;

    /**
     *  同花顺、顺子比较大小
     *  比较最大值，如果最大值相等
     *  注意：
     *  最小 A 2 3 4 5
     *  最大 10 J Q K A
     * @return
     */
    public static int compareSameColorOrStraight(List<PokerData> currList, List<PokerData> nextList) {
        // 先去除A，找到最大值
        List<Integer> curr = currList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        if(curr.contains(BIG_ACE)){
            curr.removeIf(c -> c.equals(BIG_ACE));
        }
        List<Integer> next = nextList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        if(next.contains(BIG_ACE)){
            next.removeIf(n -> n.equals(BIG_ACE));
        }
        return compareHighValue(curr, next);
//        Integer num1 = curr.stream().reduce(Integer::max).orElse(0);
//        Integer num2 = next.stream().reduce(Integer::max).orElse(0);
//        int i = num1.compareTo(num2);
        // 如果是同花 或 同花顺，会出现牌相同，但花色不同，比较花色优先级
//        if (i != 0) {
//            return i;
//        }
//        // 降序
//        currList = currList.stream().sorted(Comparator.comparing(PokerData::getPoker).reversed()).collect(Collectors.toList());
//        nextList = nextList.stream().sorted(Comparator.comparing(PokerData::getPoker).reversed()).collect(Collectors.toList());
//        Integer val1 = PokerColorEnum.map.get(currList.get(0).getPokerColor());
//        Integer val2 = PokerColorEnum.map.get(nextList.get(0).getPokerColor());
//        return val1.compareTo(val2);
    }

    /**
     * 四条比较大小
     *
     * @return
     */
    public static int compareFourKind(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, FOUR, ONE);
    }

    /**
     * 葫芦比较大小
     *
     * @return
     */
    public static int compareFlushHouse(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, THREE, TWO);
    }

    /**
     * 同花比较大小
     *
     * @return
     */
    public static int compareSameColor(List<PokerData> currList, List<PokerData> nextList) {
        List<Integer> curr = currList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        List<Integer> next = nextList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        return compareHighValue(curr, next);
    }


    /**
     * 三条比较大小
     *
     * @return
     */
    public static int compareThreeKind(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, THREE, null);
    }

    /**
     * 两对比较大小
     *
     * @return
     */
    public static int compareTwoPair(List<PokerData> currList, List<PokerData> nextList) {
        Map<Integer, Integer> currMap = PokerHelper.listToMap(currList);
        Map<Integer, Integer> nextMap = PokerHelper.listToMap(nextList);
        // 如果是两对，需要特殊处理
        // {7=1, 2=2, 3=2}
        Integer one1 = 0;
        // 取出只出现一次的牌
        for (Map.Entry<Integer, Integer> integerIntegerEntry : currMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(ONE)){
                one1 = integerIntegerEntry.getKey();
                currMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        Integer one2 = 0;
        // 取出只出现一次的牌
        for (Map.Entry<Integer, Integer> integerIntegerEntry : nextMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(ONE)){
                one2 = integerIntegerEntry.getKey();
                nextMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        Integer num1 = currMap.keySet().stream().reduce(Integer::max).orElse(0);
        Integer num2 = nextMap.keySet().stream().reduce(Integer::max).orElse(0);
        if(!num1.equals(num2)){
            return num1.compareTo(num2);
        }
        // 如果最大的一对相等，比较 小的一对
        Integer num11 = currMap.keySet().stream().reduce(Integer::min).orElse(0);
        Integer num22 = nextMap.keySet().stream().reduce(Integer::min).orElse(0);
        if(!num11.equals(num22)){
            return num11.compareTo(num22);
        }
        // 如果最大、最小的一对都相等，比较 单数
        return one1.compareTo(one2);
    }

    /**
     * 一对比较大小
     *
     * @return
     */
    public static int compareOnePair(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, TWO, null);
    }

    /**
     * 高牌比较大小
     *
     * @return
     */
    public static int compareHighCard(List<PokerData> currList, List<PokerData> nextList) {
        // 降序
        List<Integer> curr = currList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        List<Integer> next = nextList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        return compareHighValue(curr, next);
//        if(i != 0){
//            return i;
//        }
        // 两组牌大小相同，依次比较花色
//        return compareHighValueColor(currList, nextList);
    }

    /**
     * 比较花色
     * @param currList
     * @param nextList
     * @return
     */
    private static int compareHighValueColor(List<PokerData> currList, List<PokerData> nextList) {
        for (int i = 0; i < currList.size(); i++) {
            Integer num1 = PokerColorEnum.map.get(currList.get(i).getPokerColor());
            Integer num2 = PokerColorEnum.map.get(nextList.get(i).getPokerColor());
            if(num1.equals(num2)){
                continue;
            }
            return num1.compareTo(num2);
        }
        return 0;
    }

    /**
     * 相同长度集合 比较大小
     *
     * @return
     */
    private static int compareHighValue(List<Integer> curr, List<Integer> next) {
        // 降序
        curr.sort(Comparator.reverseOrder());
        next.sort(Comparator.reverseOrder());
        for (int i = 0; i < curr.size(); i++) {
            Integer num1 = curr.get(i);
            Integer num2 = next.get(i);
            if(num1.equals(num2)){
                continue;
            }
            return num1.compareTo(num2);
        }
        return 0;
    }

    /**
     * @param currList
     * @param nextList
     * @param val1     出现的次数
     * @param val2     出现的次数
     * @return
     */
    public static int compare(List<PokerData> currList, List<PokerData> nextList, Integer val1, Integer val2) {

        Map<Integer, Integer> currMap = PokerHelper.listToMap(currList);
        Map<Integer, Integer> nextMap = PokerHelper.listToMap(nextList);
        // 如 一对 {5=1, 3=1, 7=1, 6=2} ，对应牌 {6,6,3,5,7}
        Integer num1 = 0;
        for (Map.Entry<Integer, Integer> integerIntegerEntry : currMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(val1)){
                num1 = integerIntegerEntry.getKey();
                currMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        Integer num2 = 0;
        for (Map.Entry<Integer, Integer> integerIntegerEntry : nextMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(val1)){
                num2 = integerIntegerEntry.getKey();
                nextMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        if (!num1.equals(num2)) {
            return num1.compareTo(num2);
        }
        if (Objects.nonNull(val2)) {
            for (Map.Entry<Integer, Integer> integerIntegerEntry : currMap.entrySet()) {
                if(integerIntegerEntry.getValue().equals(val2)){
                    num1 = integerIntegerEntry.getKey();
                    currMap.remove(integerIntegerEntry.getKey());
                    break;
                }
            }
            for (Map.Entry<Integer, Integer> integerIntegerEntry : nextMap.entrySet()) {
                if(integerIntegerEntry.getValue().equals(val2)){
                    num2 = integerIntegerEntry.getKey();
                    nextMap.remove(integerIntegerEntry.getKey());
                    break;
                }
            }
            return num1.compareTo(num2);
        } else {
            // 三条或者一对，比较杂牌大小
            return compareHighValue(new ArrayList<>(currMap.keySet()), new ArrayList<>(nextMap.keySet()));
        }
    }

    public static void main(String[] args) {

        List<PokerData> requestPokerList = new ArrayList<>();
        PokerData item = new PokerData();
        item.setPoker(13);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(14);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(3);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(4);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(5);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);

        List<PokerData> requestPokerList2 = new ArrayList<>();
        item = new PokerData();
        item.setPoker(14);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(12);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(5);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(7);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(11);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);

//        int i = compareSameColorOrStraight(requestPokerList, requestPokerList2);
//        int i = compareFourKind(requestPokerList, requestPokerList2);
//        int i = compareFlushHouse(requestPokerList, requestPokerList2);
//        int i = compareSameColor(requestPokerList, requestPokerList2);
//        int i = compareThreeKind(requestPokerList, requestPokerList2);
//        int i = compareTwoPair(requestPokerList, requestPokerList2);
//        int i = compareOnePair(requestPokerList, requestPokerList2);
        int i = compareHighCard(requestPokerList, requestPokerList2);
        System.out.println(i);
    }


}



  • 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
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
其他类


import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * ClassName PositionData
 *
 * @author wang
 * Date 2022/3/21 17:17
 */
@Data
@ApiModel("发牌信息")
public class PokerData {

    @ApiModelProperty(value = "扑克牌", example = "2(2) || 11(J)")
    private Integer poker;

    @ApiModelProperty(value = "扑克花色( SPADE(\"黑桃\", 5), HEARTS(\"红桃\", 4), BLOCK(\"方块\", 3), CLUB(\"梅花\", 2); )", example = "CLUB")
    private String pokerColor;

    @ApiModelProperty(value = "描述")
    private String detail;

    @ApiModelProperty(value = "下标", hidden = true)
    private Integer idx;

}




import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Classname CardsEnum
 *
 * @author wang
 * Date 2022/3/21 18:56
 */
@Getter
public enum PokerEnum {

    TWO("2", 2),
    THREE("3", 3),
    FOUR("4", 4),
    FIVE("5", 5),
    SIX("6", 6),
    SEVEN("7", 7),
    EIGHT("8", 8),
    NINE("9", 9),
    TEN("10", 10),
    JACK("J", 11),
    QUEEN("Q", 12),
    KING("K", 13),
    ACE("A", 14),
    ;
    private String name;
    private int weight;

    PokerEnum(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }


}



import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Classname CardColorEnum
 *
 * @author wang
 * Date 2022/3/21 18:53
 */
@Getter
public enum PokerColorEnum {

    //♦♣♥♠
    SPADE("黑桃", 5), HEARTS("红桃", 4), BLOCK("方块", 3), CLUB("梅花", 2);
    private String name;
    private int weight;

    PokerColorEnum(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public static Map<String, Integer> map = new LinkedHashMap<>();

    static {
        for (PokerColorEnum value : PokerColorEnum.values()) {
            map.put(value.toString(), value.getWeight());
        }
    }


}




import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 扑克等级
 *
 * @author wang
 * Date 2022/3/21 18:56
 */
@Getter
public enum PokerLevelEnum {

    ROYAL_FLUSH("皇家同花顺", "ROYAL_FLUSH", 10),
    STRAIGHT_FLUSH("同花顺", "STRAIGHT_FLUSH", 9),
    FOUR_OF_A_KIND("四条", "FOUR_OF_A_KIND", 8),
    FLUSH_HOUSE("葫芦", "FLUSH_HOUSE", 7),
    FLUSH("同花", "FLUSH", 6),
    STRAIGHT("顺子", "STRAIGHT", 5),
    THREE_OF_A_KIND("三条", "THREE_OF_A_KIND", 4),
    TWO_PAIR("两对", "TWO_PAIR", 3),
    ONE_PAIR("一对", "ONE_PAIR", 2),
    HIGH_CARD("高牌", "HIGH_CARD", 1),
    ;
    private String name;
    private String engName;
    private int weight;

    PokerLevelEnum(String name, String engName, int weight) {
        this.name = name;
        this.engName = engName;
        this.weight = weight;
    }

    public static Map<String, Integer> map = new LinkedHashMap<>();

    static {
        for (PokerLevelEnum value : PokerLevelEnum.values()) {
            map.put(value.getName(), value.getWeight());
        }
    }

}



import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.models.auth.In;
import lombok.Data;

import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName PositionData
 *
 * @author wang
 * Date 2022/3/21 17:17
 */
@Data
@ApiModel("发牌缓存信息")
public class PokerInfoData {

    @ApiModelProperty(value = "扑克集合")
    private JSONObject pokerMap;

}



import com.baomidou.mybatisplus.annotation.TableName;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

import java.time.LocalDateTime;

/**
 * <p>
 * 
 * </p>
 *
 * @author Wang
 * @since 2022-03-30
 */
@Data
@Accessors(chain = true)
@TableName("game_record")
@ApiModel(value = "游戏记录对象", description = "")
public class GameRecord extends AbstractEntity {

    @ApiModelProperty(value = "玩家游戏状态：  JOINED(1)，PLAYING(2)，ABANDON(3)， FINISHED(4)， CONFIRMED(5)")
    private Integer playerGameStatus;

    @ApiModelProperty(value = "点位置信息")
    private String positionInfo;

    @ApiModelProperty(value = "分数")
    private Integer score;

    @ApiModelProperty(value = "排名")
    private Integer rankNum;

    @ApiModelProperty(value = "扑克级别")
    private Integer pokerLevel;

    @ApiModelProperty(value = "发放扑克信息")
    private String grantPokerInfo;

    @ApiModelProperty(value = "确认扑克信息")
    private String confirmPokerInfo;

    @ApiModelProperty(value = "游戏记录编号")
    private String recordNo;

}





  • 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
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/353024
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号