作业3 容器 5、模拟保皇游戏开始的发牌过程

作业3 容器 5、模拟保皇游戏开始的发牌过程。

此题目来自计算机学院张老师

规则：4副扑克，5个玩家。
1）有一个大王标记为皇上。每次发牌时，所发牌中有该大王的玩家是皇上。
2）皇帝选择侍卫（也叫保儿、腿子，游戏过程中与皇帝一伙）：作为皇上的玩家从自己的牌中选择一张拥有相同三张（点数和花色都相同）的一张牌（不能是2、3、大小王），其他四个玩家中有这张牌的就是侍卫。例如，皇上有三个红桃5，其他四个玩家中有红桃5的玩家就是侍卫。
特殊情况是：
1）皇上有一套四张牌相同的点数的牌，皇帝可以自己做侍卫；
2）皇帝没有满足要求的牌，无法获得侍卫。程序要求：程序启动后生成5个玩家，并自动给他们发牌。
然后输出：
1）皇帝和侍卫的名字及其手里的牌（每张牌输出为“花色”+“点数”，如红桃5，牌之间用“，”分割），并按照大王、小王、2、A、K、Q、J、10、9、8、7、6、5、4、3的顺序排列，相同点数但不同花色的牌要把相同花色的牌放在一起；
2）那张作为侍卫所特有的牌（“花色”+“点数”）。
如果无法得到侍卫，则程序输出相应的提示。
例如，程序运行后输出如下的结果：

皇帝是：玩家1
皇帝的牌是：[皇上, 小王, 小王, 小王, 小王, 方片2, 黑桃2, 黑桃A, 黑桃A, 红桃A, 方片K, 梅花K, 黑桃K, 红桃K, 梅花Q, 梅花Q, 黑桃Q, 方片J, 方片J, 方片J, 红桃J, 梅花9, 黑桃9, 黑桃9, 方片8, 梅花8, 红桃8, 梅花7, 黑桃7, 黑桃7, 红桃7, 梅花6, 梅花6, 黑桃6, 黑桃6, 方片5, 梅花5, 黑桃5, 黑桃5, 梅花4, 梅花4, 梅花4, 方片3, 红桃3]
侍卫对应的牌是：方片J
侍卫是：玩家2侍卫的牌是：[方片2, 黑桃2, 红桃2, 方片A, 方片K, 梅花K, 梅花K, 黑桃K, 红桃K, 红桃K, 黑桃Q, 红桃Q, 方片J, 方片10, 黑桃10, 红桃10, 红桃10, 红桃10, 方片9, 红桃9, 方片8, 梅花8, 梅花8, 黑桃8, 黑桃8, 黑桃8, 红桃8, 红桃8, 方片7, 黑桃7, 黑桃7, 方片6, 黑桃6, 黑桃5, 梅花4, 黑桃4, 红桃4, 红桃4, 方片3, 梅花3, 黑桃3, 红桃3, 红桃3]

代码

代码仅供参考

import java.util.*;

class Scard implements Comparable {
    private String point;
    private int value;

    public Scard(String point, int value) {
        this.point = point;
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public String getPoint() {
        return point;
    }

    public void setPoint(String point) {
        this.point = point;
    }

    @Override
    public String toString() {
        return point;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Scard)) return false;
        Scard scard = (Scard) o;
        return point.equals(scard.point);
    }

    @Override
    public int hashCode() {
        return Objects.hash(point);
    }

    @Override
    public int compareTo(Object o) {
        Scard scard = (Scard) o;
        return -(this.value - scard.getValue());
    }

}

class Card extends Scard implements Comparable {

    private String color;

    public Card(String color, String points, int value) {
        super(points, value);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return this.getColor() + this.getPoint();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Card)) return false;
        if (!super.equals(o)) return false;
        Card card = (Card) o;
        return color.equals(card.color);
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), color);
    }

    @Override
    public int compareTo(Object o) {
        if (super.compareTo(o) != 0) {
            return super.compareTo(o);
        } else {
            Card card = (Card) o;
            return this.getColor().compareTo(card.getColor());
        }
    }
}

class Person {
    private String name;
    private List playingCards;
    private String emperorStatus;
    private String guardStatus;

    public Person(String name, List playingcards) {
        this.name = name;
        this.playingCards = playingcards;
        this.emperorStatus = "平民";
        this.guardStatus = "平民";
    }

    public String getIdentity() {
        if (emperorStatus.equals("皇上") && guardStatus.equals("侍卫")) {
            return emperorStatus + "和" + guardStatus;
        } else if (emperorStatus.equals("皇上")) {
            return emperorStatus;
        } else if (guardStatus.equals("侍卫")) {
            return guardStatus;
        } else {
            return "平民";
        }
    }

    public void setIdentity(String identity) {
        if (identity.equals("皇上")) {
            this.emperorStatus = identity;
        } else if (identity.equals("侍卫")) {
            this.guardStatus = identity;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List getPlayingCards() {
        return playingCards;
    }

    public void setPlayingCards(List playingCards) {
        this.playingCards = playingCards;
    }

    public int getPlayingCardsNum() {
        return this.playingCards.size();
    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", PlayingcardsNum=" + getPlayingCardsNum() + '\'' +
                ", Identity=" + getIdentity() + '\'' +
                ", Playingcards=" + playingCards +
                "}\n";
    }
}

public class Main {
    public static int playingCradNum = 4;
    public static int personNum = 5;

    public static List<List<Object>> listSplit(List<Object> list, int n) {
        List<List<Object>> res = new ArrayList<>();
        int remainder = list.size() % n;
        int quotient = list.size() / n;

        for (int i = 1; i <= n; i++) {
            List<Object> value;
            if (remainder == 0) {
                value = list.subList((i - 1) * quotient, i * quotient);
            } else if (i <= remainder) {
                value = list.subList((i - 1) * quotient, i * quotient + 1);
            } else {
                value = list.subList((i - 1) * quotient + 1, i * quotient + 1);
            }
            res.add(value);
        }
        return res;

    }

    public static int findEmperor(Person[] person) {

        int i;
        outer:
        for (i = 0; i < person.length; i++) {
            for (Object o : person[i].getPlayingCards()) {
                if (o instanceof Scard) {
                    Scard s = (Scard) o;
                    if (s.getPoint().equals("皇上")) {
                        person[i].setIdentity("皇上");
                        break outer;
                    }
                }
            }

        }

        return i;

    }

    public static Object judgeGuard(List list) {

        HashMap<Object, Integer> map = new HashMap<>();
        HashMap<Object, Integer> finalMap = new HashMap<>();

        for (Object o : list) {
            map.put(o, Collections.frequency(list, o));
        }

        List<Map.Entry<Object, Integer>> slist = new ArrayList<>(map.entrySet());

        slist.sort((o1, o2) -> -(o1.getValue() - o2.getValue()));

        Iterator<Map.Entry<Object, Integer>> iter = slist.iterator();

        for (int i = 0; i < slist.size(); i++) {
            Map.Entry<Object, Integer> entry = iter.next();
            if ((entry.getValue() >= 3)) {
                finalMap.put(entry.getKey(), entry.getValue());
            }
        }

        finalMap.remove(new Scard("大王", 19));
        finalMap.remove(new Scard("小王", 18));

        return finalMap;
    }

    public static int findGuard(Person[] person, int empFg, Object o) {

        int guaFg = -1;
        Card card = (Card) o;
        outer:
        for (int i = 0; i < person.length; i++) {
            if (i == empFg) {
                i++;
            }
            List list = person[i].getPlayingCards();
            for (Object value : list) {
                if (value.equals(card)) {
                    person[i].setIdentity("侍卫");
                    guaFg = i;
                    break outer;
                }
            }
        }
        return guaFg;
    }

    public static void main(String[] args) {

        String[] colors = new String[]{"方片", "黑桃", "红桃", "梅花"};
        String[] points = new String[]{"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};

        ArrayList<Object> list = new ArrayList<>();
        for (int i = 0; i < playingCradNum; i++) {

            if (i == 0) {
                list.add(new Scard("皇上", 20));
            } else {
                list.add(new Scard("大王", 19));
            }
            list.add(new Scard("小王", 18));

            for (String c : colors) {
                for (int j = 0; j < points.length; j++) {
                    list.add(new Card(c, points[j], 17 - j));
                }
            }

        }
        
        Collections.shuffle(list);

        List<List<Object>> listSplit = listSplit(list, personNum);
        
        int empFg = -1;//皇帝的下标
        int guaFg = -1;//侍卫的下标

        Person[] person = new Person[personNum];
        for (int i = 0; i < person.length; i++) {
            person[i] = new Person("玩家" + (i + 1), listSplit.get(i));
        }
        for (Person per : person) {
            Collections.sort(per.getPlayingCards());
        }

        empFg = findEmperor(person);//皇帝的下标

        HashMap<Object, Integer> guardMap = (HashMap<Object, Integer>) judgeGuard(person[empFg].getPlayingCards());

        List<Map.Entry<Object, Integer>> guardList = new ArrayList<>(guardMap.entrySet());

        if (guardList.size() == 0) {
            System.out.println("皇帝没有满足要求的牌，无法获得侍卫。");
        } else if (guardList.get(0).getValue() == 4) {
            person[empFg].setIdentity("侍卫");
            guaFg = empFg;
            System.out.println("皇上有一套四张牌相同的点数的牌，皇帝自己做侍卫");
        } else {

            guaFg = findGuard(person, empFg, guardList.get(0).getKey());//侍卫的下标
        }

        System.out.println("-----------------------------------------");
        System.out.println("皇帝是：" + person[empFg].getName());
        System.out.println("皇帝的牌是：" + person[empFg].getPlayingCards());
        if (guardList.size() != 0) {
            System.out.println("侍卫对应的牌是：" + guardList.get(0).getKey());
            System.out.println("侍卫是：" + person[guaFg].getName());
            System.out.println("侍卫的牌是：" + person[guaFg].getPlayingCards());
        }
    }
}