173 lines
3.4 KiB
Go
173 lines
3.4 KiB
Go
package joker
|
|
|
|
import "sort"
|
|
|
|
// Cards is a slice of Cards.
|
|
type Cards []Card
|
|
|
|
// StandardCards is a slice of standard cards.
|
|
var StandardCards = Cards{
|
|
Card{FaceAce, SuitHearts},
|
|
Card{Face2, SuitHearts},
|
|
Card{Face3, SuitHearts},
|
|
Card{Face4, SuitHearts},
|
|
Card{Face5, SuitHearts},
|
|
Card{Face6, SuitHearts},
|
|
Card{Face7, SuitHearts},
|
|
Card{Face8, SuitHearts},
|
|
Card{Face9, SuitHearts},
|
|
Card{Face10, SuitHearts},
|
|
Card{FaceJack, SuitHearts},
|
|
Card{FaceQueen, SuitHearts},
|
|
Card{FaceKing, SuitHearts},
|
|
Card{FaceAce, SuitDiamonds},
|
|
Card{Face2, SuitDiamonds},
|
|
Card{Face3, SuitDiamonds},
|
|
Card{Face4, SuitDiamonds},
|
|
Card{Face5, SuitDiamonds},
|
|
Card{Face6, SuitDiamonds},
|
|
Card{Face7, SuitDiamonds},
|
|
Card{Face8, SuitDiamonds},
|
|
Card{Face9, SuitDiamonds},
|
|
Card{Face10, SuitDiamonds},
|
|
Card{FaceJack, SuitDiamonds},
|
|
Card{FaceQueen, SuitDiamonds},
|
|
Card{FaceKing, SuitDiamonds},
|
|
Card{FaceAce, SuitClubs},
|
|
Card{Face2, SuitClubs},
|
|
Card{Face3, SuitClubs},
|
|
Card{Face4, SuitClubs},
|
|
Card{Face5, SuitClubs},
|
|
Card{Face6, SuitClubs},
|
|
Card{Face7, SuitClubs},
|
|
Card{Face8, SuitClubs},
|
|
Card{Face9, SuitClubs},
|
|
Card{Face10, SuitClubs},
|
|
Card{FaceJack, SuitClubs},
|
|
Card{FaceQueen, SuitClubs},
|
|
Card{FaceKing, SuitClubs},
|
|
Card{FaceAce, SuitSpades},
|
|
Card{Face2, SuitSpades},
|
|
Card{Face3, SuitSpades},
|
|
Card{Face4, SuitSpades},
|
|
Card{Face5, SuitSpades},
|
|
Card{Face6, SuitSpades},
|
|
Card{Face7, SuitSpades},
|
|
Card{Face8, SuitSpades},
|
|
Card{Face9, SuitSpades},
|
|
Card{Face10, SuitSpades},
|
|
Card{FaceJack, SuitSpades},
|
|
Card{FaceQueen, SuitSpades},
|
|
Card{FaceKing, SuitSpades},
|
|
}
|
|
|
|
func (c Cards) Len() int {
|
|
return len(c)
|
|
}
|
|
|
|
func (c Cards) Less(i, j int) bool {
|
|
return c[i].Value() < c[j].Value()
|
|
}
|
|
|
|
func (c Cards) Swap(i, j int) {
|
|
c[i], c[j] = c[j], c[i]
|
|
}
|
|
|
|
// Copy returns a copy of the supplied cards.
|
|
func (c Cards) Copy() Cards {
|
|
cc := make(Cards, len(c))
|
|
copy(cc, c)
|
|
return cc
|
|
}
|
|
|
|
// Remove returns the supplied cards excluding the card at the specified index.
|
|
func (c Cards) Remove(i int) Cards {
|
|
cc := c.Copy()
|
|
return append(cc[:i], cc[i+1:]...)
|
|
}
|
|
|
|
// Contains returns whether the supplied cards contain the specified card.
|
|
func (c Cards) Contains(card Card) bool {
|
|
for _, compcard := range c {
|
|
if compcard.Equal(card) {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Count returns the number of occurrences of the specified card.
|
|
func (c Cards) Count(card Card) int {
|
|
var n int
|
|
for _, compcard := range c {
|
|
if compcard.Equal(card) {
|
|
n++
|
|
}
|
|
}
|
|
|
|
return n
|
|
}
|
|
|
|
// Equal returns whether the supplied cards are equal to another set of cards.
|
|
func (c Cards) Equal(cards Cards) bool {
|
|
if len(c) != len(cards) {
|
|
return false
|
|
}
|
|
|
|
for _, compcard := range c {
|
|
if c.Count(compcard) != cards.Count(compcard) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Sorted returns the supplied cards in order.
|
|
func (c Cards) Sorted() Cards {
|
|
cc := c.Copy()
|
|
sort.Sort(cc)
|
|
return cc
|
|
}
|
|
|
|
// Reversed returns the supplied cards in reverse order.
|
|
func (c Cards) Reversed() Cards {
|
|
l := len(c)
|
|
cc := make(Cards, l)
|
|
for i := 0; i < l; i++ {
|
|
cc[i] = c[l-i-1]
|
|
}
|
|
return cc
|
|
}
|
|
|
|
// Low returns the lowest valued card.
|
|
func (c Cards) Low() Card {
|
|
if len(c) == 0 {
|
|
return Card{}
|
|
}
|
|
|
|
l := c[0]
|
|
for _, comp := range c[1:] {
|
|
if comp.Value() < l.Value() {
|
|
l = comp
|
|
}
|
|
}
|
|
return l
|
|
}
|
|
|
|
// High returns the highest valued card.
|
|
func (c Cards) High() Card {
|
|
if len(c) == 0 {
|
|
return Card{}
|
|
}
|
|
|
|
h := c[0]
|
|
for _, comp := range c[1:] {
|
|
if comp.Value() > h.Value() {
|
|
h = comp
|
|
}
|
|
}
|
|
return h
|
|
}
|