def test_trix2(self):
tri2 = tcards('k2 r2 b2')
tri3 = tcards('r3 g3 b3')
distraction = tcards('g5 b8 r9 k10 k11 k13')
cards = distraction + tri2 + tri3
pr = TMultiFinder(3, True)
out, le = pr.recognize(cards)
pytest.assume(len(out) == 2)
pytest.assume(tri2 == out[2])
pytest.assume(tri3 == out[3])
def __init__(self, cards: Set[Card]):
if len(cards) < 5:
raise ValueError("Fullhouse takes at least 5 Cards")
triples, le3 = TMultiFinder(3, False).recognize(cards, True)
pairs, le2 = TMultiFinder(2, True).recognize(le3, True)
if le2:
raise ValueError("{} are leftover.\nNo card should left behind. Use the "
"Finder class for that purpose...".format(le2))
if len(triples) > 0 and len(triples) + len(pairs) > 1:
# Everything ok, a Fullhouse is buildable
self.triples = triples
self.pairs = pairs
else:
raise ValueError("Not a valid fullhouse")
self.rank = max(self.triples)
self.redundant_cards = []
self.essential_cards = []
if len(triples) > 1 and len(pairs) > 0:
self.redundant_cards += triples.items()
else:
self.essential_cards += triples.items()
if len(pairs) > 1 or len(triples):
self.redundant_cards += pairs.items()
else:
self.essential_cards += pairs.items()
def recognize(self, cards: Set[Card], phoenix=False) -> int:
if not phoenix:
return find_bombs(cards)
else:
mr = TMultiFinder(4, phoenix)
pass
def start(self):
doublestr = TDoubleStraightFinder().recognize(self.hand, True)
straights = TStraightFinder().recognize(self.hand, True)
fh = TFullHouseFinder().recognize(self.hand, True)
triples, l3 = TMultiFinder(3, True).recognize(self.hand)
pairs, l2 = TMultiFinder(2, True).recognize(self.hand)
singles, l1 = TMultiFinder(1, True).recognize(self.hand)
tmin = min(triples.items()) if triples else (100, set())
pmin = min(pairs.items()) if pairs else (99, set())
smin = min(singles.items()) if singles else (98, set())
cards = min((tmin, pmin, smin))
card = min(self.hand, key=lambda c: c.rank)
# cards = {card}
return cards[1]
def find(self, cards, higher=True):
pairRec = TMultiFinder(2, True)
tripleRec = TMultiFinder(3, True)
pairs,a = pairRec.recognize(cards)
triples,b = tripleRec.recognize(cards)
lipairs = list(pairs.values())
ltriples = list(triples.values())
li = list(flatten(lipairs+ltriples))
try:
fh = TFullHouse(li)
return [fh]
except:
return []
def __find_fullhouse__(cards: Set[Card]):
pairRec = TMultiFinder(2, True)
tripleRec = TMultiFinder(3, True)
pairs,a = pairRec.recognize(cards)
triples,b = tripleRec.recognize(cards)
num_pairs = len(pairs)
num_triples = len(triples)
if (num_triples > 0):
diff = num_pairs - num_triples;
if (diff) >= 0:
return min(num_pairs, num_triples);
else:
matching = num_pairs # because num_triples < num_pairs, ergo num_pairs is the number of matching pairs
# print('matching', matching)
additional = (num_triples - num_pairs) // 2;
# print('additional', additional)
return matching + additional
def test_3ph(self):
cards = tcards('k2 g2 ph b3 g3')
pr = TMultiFinder(3, False)
out, le = pr.recognize(cards, True)
assert {2: (tcards('k2 g2 ph')), 3: (tcards('b3 g3 ph'))} == out
def test_2x2(self):
cards = tcards('k2 r2 b3 g3')
pr = TMultiFinder(2, True)
out, le = pr.recognize(cards)
assert out == {2: (tcards('k2 r2')), 3: (tcards('b3 g3'))}
def test_3fail(self):
cards = tcards('k2 r2 b3 g3')
pr = TMultiFinder(3, True)
out, le = pr.recognize(cards)
assert out == {}
def test_4simpleph(self):
cards = tcards('k2 r2 b2 b3')
pr = TMultiFinder(4, True)
out, le = pr.recognize(cards)
assert out == {}
def test_4simple(self):
cards = tcards('k2 r2 b2 g2')
pr = TMultiFinder(4, True)
out, le = pr.recognize(cards)
assert {2: (cards)} == out