revert: 移除 poker 包的 matcher，改为使用 combination 包
This commit is contained in:
kercylan98
parent
de76411726
commit
8b92921230
|
|
@ -1,52 +0,0 @@
|
||||||
package poker
|
|
||||||
|
|
||||||
import (
|
|
||||||
"github.com/kercylan98/minotaur/utils/generic"
|
|
||||||
"github.com/kercylan98/minotaur/utils/hash"
|
|
||||||
)
|
|
||||||
|
|
||||||
// NewMatcher 创建一个新的匹配器
|
|
||||||
// - evaluate: 用于评估一组扑克牌的分值，分值最高的组合将被选中
|
|
||||||
func NewMatcher[P, C generic.Number, T Card[P, C]]() *Matcher[P, C, T] {
|
|
||||||
matcher := &Matcher[P, C, T]{
|
|
||||||
filter: map[string]*MatcherFilter[P, C, T]{},
|
|
||||||
}
|
|
||||||
return matcher
|
|
||||||
}
|
|
||||||
|
|
||||||
// Matcher 匹配器
|
|
||||||
// - 用于匹配扑克牌型，筛选分组等
|
|
||||||
type Matcher[P, C generic.Number, T Card[P, C]] struct {
|
|
||||||
filter map[string]*MatcherFilter[P, C, T]
|
|
||||||
sort []string
|
|
||||||
}
|
|
||||||
|
|
||||||
// RegType 注册一个新的牌型
|
|
||||||
// - name: 牌型名称
|
|
||||||
// - evaluate: 用于评估一组扑克牌的分值，分值最高的组合将被选中
|
|
||||||
// - options: 牌型选项
|
|
||||||
func (slf *Matcher[P, C, T]) RegType(name string, evaluate func([]T) int64, options ...MatcherOption[P, C, T]) *Matcher[P, C, T] {
|
|
||||||
if hash.Exist(slf.filter, name) {
|
|
||||||
panic("exist of the same type")
|
|
||||||
}
|
|
||||||
filter := &MatcherFilter[P, C, T]{
|
|
||||||
evaluate: evaluate,
|
|
||||||
}
|
|
||||||
for _, option := range options {
|
|
||||||
option(filter)
|
|
||||||
}
|
|
||||||
slf.filter[name] = filter
|
|
||||||
slf.sort = append(slf.sort, name)
|
|
||||||
return slf
|
|
||||||
}
|
|
||||||
|
|
||||||
// Group 将一组扑克牌按照匹配器的规则分组，并返回最佳组合及其牌型名称
|
|
||||||
func (slf *Matcher[P, C, T]) Group(cards []T) (name string, result []T) {
|
|
||||||
for _, n := range slf.sort {
|
|
||||||
result = slf.filter[n].group(cards)
|
|
||||||
if len(result) > 0 {
|
|
||||||
return n, result
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
package poker
|
|
||||||
|
|
||||||
import "github.com/kercylan98/minotaur/utils/generic"
|
|
||||||
|
|
||||||
type MatcherFilter[P, C generic.Number, T Card[P, C]] struct {
|
|
||||||
evaluate func([]T) int64
|
|
||||||
handles []func(cards []T) [][]T
|
|
||||||
asc bool
|
|
||||||
}
|
|
||||||
|
|
||||||
func (slf *MatcherFilter[P, C, T]) AddHandle(handle func(cards []T) [][]T) {
|
|
||||||
slf.handles = append(slf.handles, handle)
|
|
||||||
}
|
|
||||||
|
|
||||||
func (slf *MatcherFilter[P, C, T]) group(cards []T) []T {
|
|
||||||
var bestCombination = cards
|
|
||||||
|
|
||||||
for _, handle := range slf.handles {
|
|
||||||
var bestScore int64
|
|
||||||
filteredCombinations := handle(bestCombination)
|
|
||||||
if len(filteredCombinations) == 0 {
|
|
||||||
return []T{}
|
|
||||||
}
|
|
||||||
for _, combination := range filteredCombinations {
|
|
||||||
score := slf.evaluate(combination)
|
|
||||||
if slf.asc {
|
|
||||||
if score < bestScore || bestCombination == nil {
|
|
||||||
bestCombination = combination
|
|
||||||
bestScore = score
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if score > bestScore || bestCombination == nil {
|
|
||||||
bestCombination = combination
|
|
||||||
bestScore = score
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return bestCombination
|
|
||||||
}
|
|
||||||
|
|
@ -1,271 +0,0 @@
|
||||||
package poker
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"github.com/kercylan98/minotaur/utils/generic"
|
|
||||||
"github.com/kercylan98/minotaur/utils/slice"
|
|
||||||
"reflect"
|
|
||||||
"sort"
|
|
||||||
)
|
|
||||||
|
|
||||||
// MatcherOption 匹配器选项
|
|
||||||
type MatcherOption[P, C generic.Number, T Card[P, C]] func(matcher *MatcherFilter[P, C, T])
|
|
||||||
|
|
||||||
// WithMatcherScoreAsc 通过升序评估分数创建匹配器
|
|
||||||
// - 用于评估一组扑克牌的分值，分值最低的组合将被选中
|
|
||||||
// - 默认为分数最高的组合将被选中
|
|
||||||
func WithMatcherScoreAsc[P, C generic.Number, T Card[P, C]]() MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.asc = true
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherLeastLength 通过匹配最小长度的扑克牌创建匹配器
|
|
||||||
// - length: 牌型的长度，表示需要匹配的扑克牌最小数量
|
|
||||||
func WithMatcherLeastLength[P, C generic.Number, T Card[P, C]](length int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
combinations = slice.LimitedCombinations(cards, length, len(cards))
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherLength 通过匹配长度的扑克牌创建匹配器
|
|
||||||
// - length: 牌型的长度，表示需要匹配的扑克牌数量
|
|
||||||
func WithMatcherLength[P, C generic.Number, T Card[P, C]](length int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
combinations = slice.LimitedCombinations(cards, length, length)
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherContinuity 通过匹配连续的扑克牌创建匹配器
|
|
||||||
func WithMatcherContinuity[P, C generic.Number, T Card[P, C]]() MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
n := len(cards)
|
|
||||||
|
|
||||||
if n <= 0 {
|
|
||||||
return combinations
|
|
||||||
}
|
|
||||||
|
|
||||||
// 对扑克牌按点数进行排序
|
|
||||||
sort.Slice(cards, func(i, j int) bool {
|
|
||||||
return cards[i].GetPoint() < cards[j].GetPoint()
|
|
||||||
})
|
|
||||||
|
|
||||||
// 查找连续的牌型组合
|
|
||||||
for i := 0; i < n; i++ {
|
|
||||||
combination := []T{cards[i]}
|
|
||||||
for j := i + 1; j < n; j++ {
|
|
||||||
if cards[j].GetPoint()-combination[len(combination)-1].GetPoint() == 1 {
|
|
||||||
combination = append(combination, cards[j])
|
|
||||||
} else {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(combination) >= 2 {
|
|
||||||
combinations = append(combinations, combination)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherContinuityPointOrder 通过匹配连续的扑克牌创建匹配器，与 WithMatcherContinuity 不同的是，该选项将按照自定义的点数顺序进行匹配
|
|
||||||
func WithMatcherContinuityPointOrder[P, C generic.Number, T Card[P, C]](order map[P]int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
var getOrder = func(card T) P {
|
|
||||||
if v, ok := order[card.GetPoint()]; ok {
|
|
||||||
return P(v)
|
|
||||||
}
|
|
||||||
return card.GetPoint()
|
|
||||||
}
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
n := len(cards)
|
|
||||||
|
|
||||||
if n <= 0 {
|
|
||||||
return combinations
|
|
||||||
}
|
|
||||||
|
|
||||||
// 对扑克牌按点数进行排序
|
|
||||||
sort.Slice(cards, func(i, j int) bool {
|
|
||||||
return getOrder(cards[i]) < getOrder(cards[j])
|
|
||||||
})
|
|
||||||
|
|
||||||
// 查找连续的牌型组合
|
|
||||||
for i := 0; i < n; i++ {
|
|
||||||
combination := []T{cards[i]}
|
|
||||||
for j := i + 1; j < n; j++ {
|
|
||||||
if getOrder(cards[j])-getOrder(combination[len(combination)-1]) == 1 {
|
|
||||||
combination = append(combination, cards[j])
|
|
||||||
} else {
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(combination) >= 2 {
|
|
||||||
combinations = append(combinations, combination)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherFlush 通过匹配同花的扑克牌创建匹配器
|
|
||||||
func WithMatcherFlush[P, C generic.Number, T Card[P, C]]() MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
|
|
||||||
groups := GroupByColor[P, C, T](cards...)
|
|
||||||
for _, group := range groups {
|
|
||||||
combinations = append(combinations, slice.Combinations(group)...)
|
|
||||||
}
|
|
||||||
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherTie 通过匹配相同点数的扑克牌创建匹配器
|
|
||||||
func WithMatcherTie[P, C generic.Number, T Card[P, C]]() MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
groups := GroupByPoint[P, C, T](cards...)
|
|
||||||
for _, group := range groups {
|
|
||||||
for _, ts := range slice.Combinations(group) {
|
|
||||||
combinations = append(combinations, ts)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherTieCount 通过匹配相同点数的特定数量的扑克牌创建匹配器
|
|
||||||
// - count: 牌型中相同点数的牌的数量
|
|
||||||
func WithMatcherTieCount[P, C generic.Number, T Card[P, C]](count int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
groups := GroupByPoint[P, C, T](cards...)
|
|
||||||
for _, group := range groups {
|
|
||||||
if len(group) < count {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
for _, ts := range slice.Combinations(group) {
|
|
||||||
if len(ts) == count {
|
|
||||||
combinations = append(combinations, ts)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherTieCountNum 通过匹配相同点数的特定数量的扑克牌创建匹配器
|
|
||||||
// - count: 牌型中相同点数的牌的数量
|
|
||||||
// - num: 牌型中相同点数的牌的数量
|
|
||||||
func WithMatcherTieCountNum[P, C generic.Number, T Card[P, C]](count, num int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
cs := slice.LimitedCombinations(cards, count*num, count*num)
|
|
||||||
var pointCount = make(map[P]int)
|
|
||||||
for _, group := range cs {
|
|
||||||
var ok = false
|
|
||||||
for _, t := range group {
|
|
||||||
pointCount[t.GetPoint()]++
|
|
||||||
if len(pointCount) == 2 {
|
|
||||||
var matchCount = true
|
|
||||||
for _, n := range pointCount {
|
|
||||||
if n != num {
|
|
||||||
matchCount = false
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if matchCount {
|
|
||||||
ok = true
|
|
||||||
break
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if ok {
|
|
||||||
combinations = append(combinations, group)
|
|
||||||
}
|
|
||||||
for point := range pointCount {
|
|
||||||
delete(pointCount, point)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherNCarryM 通过匹配N带相同点数M的扑克牌创建匹配器
|
|
||||||
// - n: 需要匹配的主牌数量
|
|
||||||
// - m: 需要匹配的附加牌数量
|
|
||||||
func WithMatcherNCarryM[P, C generic.Number, T Card[P, C]](n, m int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
groups := GroupByPoint[P, C, T](cards...)
|
|
||||||
for _, group := range groups {
|
|
||||||
if len(group) != n {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
ms := slice.Combinations(slice.SubWithCheck(cards, group, func(a, b T) bool { return reflect.DeepEqual(a, b) }))
|
|
||||||
for i := 0; i < len(ms); i++ {
|
|
||||||
ts := GroupByPoint[P, C, T](ms[i]...)
|
|
||||||
for _, cs := range ts {
|
|
||||||
if len(cs) == m {
|
|
||||||
combinations = append(combinations, slice.Merge(group, cs))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// WithMatcherNCarryMSingle 通过匹配N带M的扑克牌创建匹配器
|
|
||||||
// - n: 需要匹配的主牌数量
|
|
||||||
// - m: 需要匹配的附加牌数量
|
|
||||||
func WithMatcherNCarryMSingle[P, C generic.Number, T Card[P, C]](n, m int) MatcherOption[P, C, T] {
|
|
||||||
return func(matcher *MatcherFilter[P, C, T]) {
|
|
||||||
matcher.AddHandle(func(cards []T) [][]T {
|
|
||||||
var combinations [][]T
|
|
||||||
groups := GroupByPoint[P, C, T](cards...)
|
|
||||||
for _, group := range groups {
|
|
||||||
if len(group) != n {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
ms := slice.Combinations(slice.SubWithCheck(cards, group, func(a, b T) bool { return reflect.DeepEqual(a, b) }))
|
|
||||||
for i := 0; i < len(ms); i++ {
|
|
||||||
ts := ms[i]
|
|
||||||
if len(ts) == m {
|
|
||||||
combinations = append(combinations, slice.Merge(group, ts))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if len(combinations) > 0 {
|
|
||||||
fmt.Println(len(combinations))
|
|
||||||
}
|
|
||||||
return combinations
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -1,117 +0,0 @@
|
||||||
package poker_test
|
|
||||||
|
|
||||||
import (
|
|
||||||
"fmt"
|
|
||||||
"github.com/kercylan98/minotaur/game/poker"
|
|
||||||
"github.com/kercylan98/minotaur/utils/generic"
|
|
||||||
"github.com/kercylan98/minotaur/utils/slice"
|
|
||||||
"testing"
|
|
||||||
"time"
|
|
||||||
)
|
|
||||||
|
|
||||||
type Card[P, C generic.Number] struct {
|
|
||||||
guid int64
|
|
||||||
point P
|
|
||||||
color C
|
|
||||||
}
|
|
||||||
|
|
||||||
func (slf *Card[P, C]) GetGuid() int64 {
|
|
||||||
return slf.guid
|
|
||||||
}
|
|
||||||
|
|
||||||
func (slf *Card[P, C]) GetPoint() P {
|
|
||||||
return slf.point
|
|
||||||
}
|
|
||||||
|
|
||||||
func (slf *Card[P, C]) GetColor() C {
|
|
||||||
return slf.color
|
|
||||||
}
|
|
||||||
|
|
||||||
func TestMatcher_Group(t *testing.T) {
|
|
||||||
|
|
||||||
evaluate := func(cards []*Card[int, int]) int64 {
|
|
||||||
score := int64(0)
|
|
||||||
for _, card := range cards {
|
|
||||||
if card.point == 1 {
|
|
||||||
score += 14
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
score += int64(card.GetPoint())
|
|
||||||
}
|
|
||||||
return score
|
|
||||||
}
|
|
||||||
|
|
||||||
matcher := poker.NewMatcher[int, int, *Card[int, int]]()
|
|
||||||
//matcher.RegType("三条", evaluate,
|
|
||||||
// poker.WithMatcherNCarryMSingle[*Card](3, 2))
|
|
||||||
matcher.RegType("皇家同花顺", evaluate,
|
|
||||||
poker.WithMatcherFlush[int, int, *Card[int, int]](),
|
|
||||||
poker.WithMatcherContinuityPointOrder[int, int, *Card[int, int]](map[int]int{1: 14}),
|
|
||||||
poker.WithMatcherLength[int, int, *Card[int, int]](5),
|
|
||||||
).RegType("同花顺", evaluate,
|
|
||||||
poker.WithMatcherFlush[int, int, *Card[int, int]](),
|
|
||||||
poker.WithMatcherContinuityPointOrder[int, int, *Card[int, int]](map[int]int{1: 14}),
|
|
||||||
poker.WithMatcherLeastLength[int, int, *Card[int, int]](3),
|
|
||||||
).RegType("四条", evaluate,
|
|
||||||
poker.WithMatcherTieCount[int, int, *Card[int, int]](4),
|
|
||||||
).RegType("葫芦", evaluate,
|
|
||||||
poker.WithMatcherNCarryM[int, int, *Card[int, int]](3, 2),
|
|
||||||
).RegType("顺子", evaluate,
|
|
||||||
poker.WithMatcherContinuityPointOrder[int, int, *Card[int, int]](map[int]int{1: 14}),
|
|
||||||
poker.WithMatcherLength[int, int, *Card[int, int]](5),
|
|
||||||
).RegType("三条", evaluate,
|
|
||||||
poker.WithMatcherNCarryMSingle[int, int, *Card[int, int]](3, 2),
|
|
||||||
).RegType("两对", evaluate,
|
|
||||||
poker.WithMatcherTieCountNum[int, int, *Card[int, int]](2, 2),
|
|
||||||
).RegType("一对", evaluate,
|
|
||||||
poker.WithMatcherTieCount[int, int, *Card[int, int]](2),
|
|
||||||
).RegType("高牌", evaluate,
|
|
||||||
poker.WithMatcherTieCount[int, int, *Card[int, int]](1),
|
|
||||||
)
|
|
||||||
|
|
||||||
var pub = []*Card[int, int]{
|
|
||||||
{point: 4, color: 3},
|
|
||||||
{point: 5, color: 2},
|
|
||||||
{point: 6, color: 1},
|
|
||||||
{point: 6, color: 2},
|
|
||||||
{point: 13, color: 2},
|
|
||||||
}
|
|
||||||
|
|
||||||
var pri = []*Card[int, int]{
|
|
||||||
{point: 1, color: 1},
|
|
||||||
{point: 1, color: 2},
|
|
||||||
{point: 4, color: 3},
|
|
||||||
{point: 5, color: 4},
|
|
||||||
}
|
|
||||||
|
|
||||||
var start = time.Now()
|
|
||||||
var usePub, usePri = slice.LimitedCombinations(pub, 3, 3), slice.LimitedCombinations(pri, 2, 2)
|
|
||||||
|
|
||||||
var topResult []*Card[int, int]
|
|
||||||
var topScore int64
|
|
||||||
var topName string
|
|
||||||
var source []*Card[int, int]
|
|
||||||
for _, handCards := range usePri {
|
|
||||||
for _, pubCards := range usePub {
|
|
||||||
cards := append(handCards, pubCards...)
|
|
||||||
name, result := matcher.Group(cards)
|
|
||||||
score := evaluate(result)
|
|
||||||
if score > topScore || topResult == nil {
|
|
||||||
topScore = score
|
|
||||||
topResult = result
|
|
||||||
topName = name
|
|
||||||
source = cards
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fmt.Println("time:", time.Since(start))
|
|
||||||
fmt.Println("result:", topName)
|
|
||||||
for _, card := range topResult {
|
|
||||||
fmt.Println(fmt.Sprintf("Point: %d Color: %d", card.GetPoint(), card.GetColor()))
|
|
||||||
}
|
|
||||||
fmt.Println("source:", topScore)
|
|
||||||
for _, card := range source {
|
|
||||||
fmt.Println(fmt.Sprintf("Point: %d Color: %d", card.GetPoint(), card.GetColor()))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in New Issue