如果子集具有共同的值

Question

我正在尝试创建一种方法，该方法将返回具有邻居的最大卡片组。例如，如果我有list<RANK> rankList = [FIVE, QUEEN, KING, ACE, TEN]，它将返回[KING, ACE, QUEEN]。我没有完全实现它，但我得到了那个部分，在一组较小的集合中分割了一组。

private boolean isStraight(List<Card> cards) {
        Set<RANK> rankList = cards.stream()
            .map(Card::getRank)
            .distinct()
            .collect(Collectors.toSet());


        List<Set<RANK>> subSets = new ArrayList<>();

        for(RANK rank : rankList) {
            int currRankValue = rank.getValue();
            RANK prevRank = RANK.getRank(currRankValue - 1);
            RANK nextRank = RANK.getRank(currRankValue + 1);

            if(!subSets.stream().anyMatch(set -> set.contains(rank))) {
                Set<RANK> newSet = new HashSet<>();
                newSet.add(rank);
                subSets.add(newSet);
            }

            subSets.stream()
                .filter(set -> (set.contains(prevRank) || set.contains(nextRank)))
                .forEach( set -> set.add(rank));
        }

        System.out.print(subSets);
        return false;
    }

Card.java ：

 public static enum RANK {
        NONE(0),
        TWO(2), THREE(3), FOUR(4), FIVE(5),
        SIX(6), SEVEN(7), EIGHT(8), NINE(9),
        TEN(10), JACK(11), QUEEN(12), KING(13), ACE(14);

        private final int value;

        private RANK(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }

        public static RANK getRank(int value) {
            for(RANK r : RANK.values() ) {
                if (r.getValue() == value)
                    return r;
            }
            return NONE;
        }
    }

在我检查是否有5张或更多牌可以直接进行之前，我已经组合了具有至少一个共同值的子集。我该怎么做？我想不出任何不涉及很多循环的事情。

EDITED

添加了整个 Card.java ：

ppackage deck;

public class Card implements Comparable {

    public static enum SUIT {
        SPADES,
        HEARTS,
        CLUBS,
        DIAMONDS
    }

    public static enum RANK {
        NONE(0),
        TWO(2), THREE(3), FOUR(4), FIVE(5),
        SIX(6), SEVEN(7), EIGHT(8), NINE(9),
        TEN(10), JACK(11), QUEEN(12), KING(13), ACE(14);

        private final int value;

        private RANK(int value) {
            this.value = value;
        }

        public int getValue() {
            return value;
        }

        public static RANK getRank(int value) {
            for(RANK r : RANK.values() ) {
                if (r.getValue() == value)
                    return r;
            }
            return NONE;
        }
    }

    private final RANK rank;
    private final SUIT suit;

    public Card(RANK rank, SUIT suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public RANK getRank() {
        return rank;
    }

    public SUIT getSuit() {
        return suit;
    }

    @Override
    public String toString() {
        return "Card{" +
            "rank=" + rank +
            ", suit=" + suit +
            '}';
    }

    @Override
    public int compareTo(Object that) {
        return this.rank.getValue() - ((Card) that).rank.getValue();
    }
}

EDITED

添加了循环解决方案： 在方法返回之前添加它。

for(int index = 0; index < subSets.size(); index++) {
           for(int index2 = 1; index2 < subSets.size(); index2++) {
               if(!Collections.disjoint(subSets.get(index), subSets.get(index2)) && index != index2) {
                    subSets.get(index).addAll(subSets.remove(index2));
                    index2--;
               }
           }
       }

Answer 1

假设“直”由五个相邻的RANK组成，我们不应该认为太复杂，只是测试我们是否找到这样的范围：

boolean isStraight(List<Card> cards) {
    BitSet set=cards.stream().map(Card::getRank).mapToInt(Card.RANK::ordinal)
        .collect(BitSet::new, BitSet::set, BitSet::or);
    for(int s=set.nextSetBit(0), e; s>=0; s=set.nextSetBit(e)) {
        e=set.nextClearBit(s);
        if(e-s >= 5) return true;
    }
    return false;
}

此代码未绑定到特定的手大小，并且可以轻松适应其他直接大小。

处理ordinal()和BitSet可能看起来有点低级，我真的希望有一个使用EnumSet或EnumMap的解决方案就像这样简单，但是，这些更高级别的课程在这里没有用（他们甚至没有实现SortedSet / SortedMap）...

请注意，此方法会返回boolean作为您问题中的代码。所以它并不关心实际的牌组成直线。 Afaik，在大多数扑克变种中，它确实无关紧要。

然而，从字面上看你的问题的介绍，获得“有邻居的最大的卡片组”可以如下完成：

Set<Card> largestStraightCandidate(List<Card> cards) {
    BitSet set=cards.stream().map(Card::getRank).mapToInt(Card.RANK::ordinal)
        .collect(BitSet::new, BitSet::set, BitSet::or);
    int min=0, max=0;
    for(int s=set.nextSetBit(0), e; s>=0; s=set.nextSetBit(e)) {
        e=set.nextClearBit(s);
        if(e-s >= max-min) {
            min=s;
            max=e;
        }
    }
    if(max==min) return Collections.emptySet();// cards was empty
    Card.RANK[] all=Card.RANK.values();
    EnumSet<Card.RANK> rankSet=EnumSet.range(all[min], all[max-1]);
    return cards.stream().filter(card-> rankSet.contains(card.getRank()))
      .collect(Collectors.toSet());
}

不同之处在于，一旦我们找到了足够大的范围，我们现在记住最大范围而不是返回。然后，我们通过过滤该范围内所有卡的原始卡列表来重新构建卡片。

这意味着

• 对于多个最大集合，由于BitSet上的循环，将返回具有较高等级的集合，即列表中的顺序无关紧要
• 如果该范围内存在相同RANK的多张卡片，则所有这些卡片都会包含在Set的{​​{1}}中;不要使用它的大小来决定直线的大小，你必须首先转换为Card的{​​{1}}，或者如果仔细查看代码，你会看到{{在构建Set的{​​{1}} 之前，RANK已经存在的1}}

Answer 2

我专注于与“有邻居的最大牌组”有关的问题。如果对卡等级值列表进行排序，则会转换为对列表运行进行分段，然后从这些段中选择最长运行的问题。

精明的读者会注意到与this question的相似性。我将使用类似my answer的技术来解决这个问题。

首先，让我们从包含OP示例的输入列表开始。但是，以下技术适用于任何输入。

    List<Rank> rankList = [FIVE, QUEEN, KING, ACE, TEN];

让我们排序并使这个列表具有独特的元素：

    List<Rank> sorted = rankList.stream()
        .distinct()
        .sorted()
        .collect(toList());

  

[五，十，女王，王，ACE]

现在让我们计算应该将列表拆分为连续排名值的单独运行的位置。这发生在列表中彼此相邻的值不是连续的等级值的位置。我们通过索引列表（从1开始）并通过检查列表中的相邻值来过滤索引来完成此操作：

    List<Integer> splits = IntStream.range(1, sorted.size())
        .filter(i -> sorted.get(i).ordinal() != sorted.get(i-1).ordinal() + 1)
        .boxed()
        .collect(toCollection(ArrayList::new));

  

[1,2]

这些之间的位置。这几乎是创建子列表的足够信息，但它省略了第一个子列表的开头和最后一个子列表末尾的索引。要添加这些内容，我们只需在前面添加 0 ，在结尾添加 size ：

    splits.add(0, 0);
    splits.add(list.size());

  

[0,1,2,5]

现在我们可以使用每对索引来生成包含每个运行的子列表：

    List<List<Rank>> runs = IntStream.range(1, splits.size())
        .mapToObj(i -> list.subList(splits.get(i-1), splits.get(i)))
        .collect(toList());

  

[[FIVE]，[TEN]，[QUEEN，KING，ACE]]

我们可以找到最长的运行，然后打印出与其长度匹配的运行：

    int longest = runs.stream()
        .mapToInt(list -> list.size())
        .max()
        .getAsInt();
    runs.stream()
        .filter(list -> list.size() == longest)
        .forEach(System.out::println);

  

[QUEEN，KING，ACE]

总而言之，我们有：

static void split(List<Rank> rankList) {
    List<Rank> sorted = rankList.stream()
        .distinct()
        .sorted()
        .collect(toList());

    List<Integer> splits = IntStream.range(1, sorted.size())
        .filter(i -> sorted.get(i).ordinal() != sorted.get(i-1).ordinal() + 1)
        .boxed()
        .collect(toCollection(ArrayList::new));

    splits.add(0, 0);
    splits.add(sorted.size());

    List<List<Rank>> runs = IntStream.range(1, splits.size())
        .mapToObj(i -> sorted.subList(splits.get(i-1), splits.get(i)))
        .collect(toList());

    int longest = runs.stream()
        .mapToInt(list -> list.size())
        .max()
        .getAsInt();

    runs.stream()
        .filter(list -> list.size() == longest)
        .forEach(System.out::println);
}

Answer 3

（我仍然遇到java功能API编码风格的麻烦。）我会使用一个不同的排序流，并使用Lists来制作子列表。 不同的列表被分成连续排名的子列表。我希望看到更好的解决方案，使用flatMap，reduce等等。

static boolean isStraight(List<Card> cards) {
    List<List<Rank>> rankList = cards.stream()
            .map(Card::getRank)
            .sorted(Comparator.comparingInt(Rank::getValue))
            .distinct()
            .collect(LinkedList::new,
                    (list, rank) -> {
                        boolean startNextList = false;
                        if (list.isEmpty()) {
                            startNextList = true;
                        } else {
                            List<Rank> priorRanks = list.get(list.size() - 1);
                            if (priorRanks.get(priorRanks.size() - 1).getValue()
                                       < rank.getValue() - 1) {
                                startNextList = true;
                            }
                        }
                        if (startNextList) {
                            List<Rank> priorRanks = new LinkedList<>();
                            list.add(priorRanks);
                        }
                        List<Rank> priorRanks = list.get(list.size() - 1);
                        priorRanks.add(rank);
                    },
                    (list1, list2) -> {
                        list1.addAll(list2);
                    });

转储：

    rankList.stream().forEach((list) -> {
        System.out.printf("# %d - ", list.size());
        list.stream().forEach((r) -> System.out.printf("%s, ", r));
        System.out.println();
    });
    ...

Answer 4

鉴于可能的直道很少，您是否考虑过一种简单的方法来预先计算它们？

// using .ordinal() instead of .value to keep it short.  
// Shouldn't be too hard to change it to use values
final Set<EnumSet<RANK>> STRAIGHTS = EnumSet.range(TWO, TEN).stream()
        .map(rank -> EnumSet.range(rank, RANK.values()[rank.ordinal() + 4]))
        .collect(toSet());

然后

boolean isStraight(List<Card> cards) {
    EnumSet<RANK> ranks = cards.stream()
        .map(Card::getRank)
        .collect(toCollection(() -> EnumSet.noneOf(RANK.class)));

    return STRAIGHTS.contains(ranks);
}