347 lines
7.0 KiB
Go
347 lines
7.0 KiB
Go
package thirteen
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// 牌序- A, K, Q, J,10, 9, 8, 7, 6, 5, 4, 3, 2
|
|
// 黑桃-51,50,49,48,47,46,45,44,43,42,41,40,39
|
|
// 红桃-38,37,36,35,34,33,32,31,30,29,28,27,26
|
|
// 梅花-25,24,23,22,21,20,19,18,17,16,15,14,13
|
|
// 方片-12,11,10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
|
|
var pokersTest = []int{12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 38,
|
|
37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39}
|
|
|
|
var pokers2Test = append(pokersTest, pokersTest...)
|
|
|
|
func arrEqual(a, b [][]int) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
|
|
for i := 0; i < len(a); i++ {
|
|
if len(a[i]) != len(b[i]) {
|
|
return false
|
|
}
|
|
|
|
cp := make([]int, len(a[i]))
|
|
copy(cp, a[i])
|
|
for _, v := range b[i] {
|
|
cp = DelCards(cp, []int{v})
|
|
}
|
|
if len(cp) > 0 {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
type item struct {
|
|
cards []int
|
|
lai []int
|
|
target []int
|
|
}
|
|
|
|
func goResult(cards []int) string {
|
|
buf := strings.Builder{}
|
|
buf.WriteString("[]int{")
|
|
|
|
for m, n := range cards {
|
|
buf.WriteString(fmt.Sprint(n))
|
|
if m < len(cards)-1 {
|
|
buf.WriteString(",")
|
|
}
|
|
}
|
|
|
|
buf.WriteString("}")
|
|
return buf.String()
|
|
}
|
|
|
|
func printTest(t *testing.T, cards []int, target, result, change []int) {
|
|
// 牌应该都在原牌堆中存在，这里检查一下
|
|
for _, vv := range result {
|
|
has := false
|
|
for _, c := range cards {
|
|
if vv == c {
|
|
has = true
|
|
}
|
|
}
|
|
if !has {
|
|
t.Logf("%v,%v 不存在\n", PokerName(vv), vv)
|
|
}
|
|
}
|
|
|
|
t.Logf("goResult: %s", goResult(result))
|
|
t.Fatal()
|
|
}
|
|
|
|
func findFuncTest(t *testing.T, data []item, find func([]int, []int) ([]int, []int)) {
|
|
for _, v := range data {
|
|
result, change := find(v.cards, v.lai)
|
|
t.Logf(" cards: %s\n", PokersShow(v.cards))
|
|
t.Logf(" cards: %v\n", v.cards)
|
|
t.Logf("target: %s %v\n", PokersShow(v.target), v.target)
|
|
t.Logf("result: %s %v \n", PokersShow(result), result)
|
|
t.Logf("change: %s %v \n\n", PokersShow(change), change)
|
|
if !arrEqual([][]int{v.target}, [][]int{result}) {
|
|
printTest(t, v.cards, v.target, result, change)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFindMaxPairs(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: []int{9, 8, 7, 6, 5, 20, 19, 18, 17, 16, 32, 31, 30, 29, 28, 27, 26, 38},
|
|
target: []int{20, 7},
|
|
},
|
|
{
|
|
cards: []int{5, 4, 3, 2, 1, 0, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13},
|
|
target: []int{18, 5},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{51, 51},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
lai: []int{52, 53},
|
|
target: []int{51, 51},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 2, 3, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 53},
|
|
},
|
|
{
|
|
cards: []int{1, 0, 2, 3, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{53, 52},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxPairs)
|
|
}
|
|
|
|
func TestFindMaxThreeAAA(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{25, 38, 51},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{51, 51, 38},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 2, 3, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 53, 52},
|
|
},
|
|
{
|
|
cards: []int{1, 0, 2, 3, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{3, 53, 52},
|
|
},
|
|
{
|
|
cards: []int{1, 0, 2, 3, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{53, 52, 52},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxThreeAAA)
|
|
}
|
|
|
|
func TestFindMaxFlush(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{47, 48, 49, 50, 51},
|
|
},
|
|
{
|
|
cards: []int{12, 3, 2, 1, 0},
|
|
target: []int{12, 0, 1, 2, 3},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{47, 48, 49, 50, 51},
|
|
},
|
|
{
|
|
cards: []int{0, 1, 2, 3, 4, 5},
|
|
lai: []int{52, 53},
|
|
target: []int{5, 4, 3, 2, 1},
|
|
},
|
|
{
|
|
cards: []int{0, 2, 4, 5, 7, 8, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{53, 8, 7, 52, 5},
|
|
},
|
|
{
|
|
cards: []int{0, 2, 4, 8, 9, 10, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{53, 52, 10, 9, 8},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 1, 2, 4, 6, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{6, 53, 4, 52, 2},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 1, 2, 8, 9, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 53, 52, 9, 8},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 1, 2, 8, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{52, 2, 1, 0, 51},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxFlush)
|
|
}
|
|
|
|
func TestFindMaxSameColors(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{47, 48, 49, 50, 51},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{49, 50, 50, 51, 51},
|
|
},
|
|
{
|
|
cards: []int{39, 38, 34, 33, 30},
|
|
target: []int{},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 1, 2, 8, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{8, 2, 1, 0, 52},
|
|
},
|
|
{
|
|
cards: []int{51, 0, 1, 2, 22, 52, 53},
|
|
lai: []int{52, 53},
|
|
target: []int{2, 1, 0, 53, 52},
|
|
},
|
|
{
|
|
cards: []int{51, 50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 50, 53, 52, 52},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxSameColors)
|
|
}
|
|
|
|
func TestFindMaxGourdCards(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{25, 37, 38, 50, 51},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{51, 51, 38, 38, 25},
|
|
},
|
|
{
|
|
cards: []int{51, 50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 53, 52, 50, 52},
|
|
},
|
|
{
|
|
cards: []int{51, 12, 50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 12, 53, 52, 52},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxGourdCards)
|
|
}
|
|
|
|
func TestFindMaxFourAAAA(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{12, 25, 38, 51},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{51, 51, 38, 38},
|
|
},
|
|
{
|
|
cards: []int{51, 12, 50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 12, 53, 52},
|
|
},
|
|
{
|
|
cards: []int{12, 50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{12, 53, 52, 52},
|
|
},
|
|
{
|
|
cards: []int{50, 1, 2, 22, 52, 53, 52, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{53, 52, 52, 52},
|
|
},
|
|
{
|
|
cards: []int{50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{50, 53, 52, 52},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxFourAAAA)
|
|
}
|
|
|
|
func TestFindMaxSameColorFlush(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{47, 48, 49, 50, 51},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{47, 48, 49, 50, 51},
|
|
},
|
|
{
|
|
cards: []int{50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{53, 52, 52, 2, 1},
|
|
},
|
|
{
|
|
cards: []int{0, 1, 2, 4, 9, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{4, 52, 2, 1, 0},
|
|
},
|
|
{
|
|
cards: []int{12, 1, 2, 3, 9, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{3, 2, 1, 52, 12},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxSameColorFlush)
|
|
}
|
|
|
|
func TestFindMaxFive(t *testing.T) {
|
|
data := []item{
|
|
{
|
|
cards: pokersTest,
|
|
target: []int{},
|
|
},
|
|
{
|
|
cards: pokers2Test,
|
|
target: []int{51, 51, 38, 38, 25},
|
|
},
|
|
{
|
|
cards: []int{50, 1, 2, 22, 52, 53, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{},
|
|
},
|
|
{
|
|
cards: []int{51, 51, 51, 51, 12, 52},
|
|
lai: []int{52, 53},
|
|
target: []int{51, 51, 51, 51, 12},
|
|
},
|
|
}
|
|
findFuncTest(t, data, FindMaxFive)
|
|
}
|