检测扑克中的正手

Question

好的，我有下面定义的方法straight(ArrayList<Card> l)。它可以工作，但我真的很想改进它，因为我的算法运行速度很慢。

这里的想法是：获取卡片的所有值并将它们添加到数组列表中，然后检查数组列表是否包含顺子列表。如果是，将其添加到 hashmap，最后添加的数组将是最好的直线（如果有 3 个直线：1 2 3 4 5 6 7）

卡片由 2 个数组定义：价值和花色：

private String[] name = {"Joker", "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"};
private String[] suit = {"Club", "Diamond", "Spade", "Heart"};

所以我有两个问题：

1、下面的代码有什么改进的地方吗？

2，我做这个项目是为了好玩，我希望这是多人游戏。那么服务器是否应该检测每个玩家的最佳手牌或玩家这样做，然后将结果以 (String, ArrayList bestHand) 的形式发送回服务器？

public ArrayList<Card> straight(ArrayList<Card> l){
        ArrayList<Card> straight = new ArrayList<>();
        ArrayList<Card> card_value = this.removeDuplicate(l);
        ArrayList<Integer> temp_value = this.getCardValue(card_value);

        ArrayList<Integer[]> possible_straight = new ArrayList<>();
        possible_straight.add(new Integer[]{1, 2, 3, 4, 5});
        possible_straight.add(new Integer[]{2, 3, 4, 5, 6}); 
        possible_straight.add(new Integer[]{3, 4, 5, 6, 7});
        possible_straight.add(new Integer[]{4, 5, 6, 7, 8});
        possible_straight.add(new Integer[]{5, 6, 7, 8, 9});
        possible_straight.add(new Integer[]{6, 7, 8, 9, 10});
        possible_straight.add(new Integer[]{7, 8, 9, 10, 11});
        possible_straight.add(new Integer[]{8, 9, 10, 11, 12});
        possible_straight.add(new Integer[]{9, 10, 11, 12, 13});
        possible_straight.add(new Integer[]{10, 11, 12, 13, 1});

        HashMap<Integer, Integer[]> check_list = new HashMap<>();
        int controller = 0;

        for (int i = 0; i < possible_straight.size(); i++){
            Integer[] dummy = possible_straight.get(i);
            if (temp_value.containsAll(Arrays.asList(dummy))){
                check_list.put(controller++, dummy);
            }
        }

        if (!check_list.isEmpty()){
            for (int k = 0; k < check_list.get((controller - 1)).length; k++){
                for (int m = 0; m < card_value.size(); m++){
                    Card temp_card = card_value.get(m);
                    if (temp_card.getValue() == check_list.get(controller - 1)[k]){
                      straight.add(temp_card);
                    }
                }
            }
        }

        return straight;
    }

Answer 1

您的第一个问题的答案：除了特殊情况 10、11、12、13、1，您可以通过简单地对数组进行排序然后检查每个元素以查看它是否正好比元素多一个来做到这一点在它之前。除了处理这种特殊情况外，您只需要以下代码：（请注意，此解决方案返回整数列表，而不是卡片列表。您可能希望将其修改为返回卡片。）

ArrayList<int[]> straights = new ArrayList();
sort(l)//Implement some sort of sorting algorithm here.
int consecutive=0;
for(int i=1;i<l.size();i++){
    if(l.get(i).getValue()-l.get(i-1).getValue()<=1)){
        consecutive++;
        if(consecutive>=5){
            int[] values=new int[5];
            values[0]=l.get(i).getValue()-4;
            for(int j=1;j<5;j++)values[j]=values[0]+j;
            straights.add(values);
        }
    }
}

对列表进行排序后，它会查看列表中是否有任何卡片不完全比它们之前的一张多一张；如果有，则返回一个空列表，如果没有，则返回原始列表。

Answer 2

您可以像这样检索所有可能的直道：

输出

[0, 0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 8, 9, 10, 11, 12, 12, 13, 14]
Straight?: [[0, 1, 2, 3, 4], [4, 5, 6, 7, 8], [8, 9, 10, 11, 12]]

SrightDetector.java

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class StraightDetector {
    public static void main(String[] args) {
        List<Card> cards = new ArrayList<Card>();
        int lengthOfStrait = 5, numberOfStrights = 3;
        for (int i = 0; i < lengthOfStrait * numberOfStrights; i++) {
            cards.add(new Card(i));
            // Insert a duplicate after every straight. 
            if (i % (lengthOfStrait - 1) == 0) cards.add(new Card(i));
        }
        System.out.println(cards);
        List<List<Card>> strights = findStrights(cards, lengthOfStrait);
        System.out.println("Straight?: " + (!strights.isEmpty() ? strights : "Nope..."));
    }

    public static List<List<Card>> findStrights(List<Card> cards, int length) {
        List<List<Card>> straights = new ArrayList<List<Card>>();
        Collections.sort(cards);
        int consecutive = 1;
        for (int i = 1; i < cards.size(); i++) {
            if (Math.abs(cards.get(i).getRank() - cards.get(i - 1).getRank()) >= 1) {
                consecutive++;
                if (consecutive >= length) {
                    List<Card> values = new ArrayList<Card>();
                    for (int j = length - 1; j >= 0; j--) values.add(cards.get(i - j));
                    straights.add(values);
                }
            } else
                consecutive = 1;
        }
        return straights;
    }
}

卡片.java

public class Card implements Comparable<Card>, Comparator<Card> {
    private int rank;
    public int getRank() { return rank; }
    public void setRank(int rank) { this.rank = rank; }

    public Card(int rank) {
        this.rank = rank;
    }

    @Override
    public int compare(Card card1, Card card2) {
        return card1.compareTo(card2);
    }
    @Override
    public int compareTo(Card other) {
        return Integer.compare(getRank(), other.getRank());
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        return prime * result + rank;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;
        if (getClass() != obj.getClass()) return false;
        Card other = (Card) obj;
        if (rank != other.rank) return false;
        return true;
    }
    @Override
    public String toString() {
        return String.format("%d", rank);
    }
}