Krazy King二十一点【难度：3级】--（Python Solutions）最佳题目答案合集（含多种解法）--景越编程训练之挑战1000道Python面试题

Krazy King二十一点【难度：3级】:

答案1：

from itertools import product

def krazy_king_blackjack(hand, king_value):
    VALUE = {str(n): (n,) for n in range(1, 11)}
    VALUE.update({'J': (10,), 'Q': (10,), 'K': (10, king_value), 'A': (1, 11)})
    possible = [sum(comb) for comb in product(*(VALUE[card] for card in hand)) if sum(comb) <= 21]
    return max(possible) if possible else False​

答案2：

from itertools import product
def krazy_king_blackjack (hand, king_value):
    d = dict([(str(a), [a]) for a in range(2, 11)] + [('A', [1, 11]), ('J', [10]), ('Q', [10]), ('K', [10, king_value])])
    return max((s for s in (map(sum, product(*map(d.get, hand)))) if s < 22), default=False)​

答案3：

from collections import Counter
from itertools import product

CARDS = dict.fromkeys('10 J Q K'.split(), 10)
CARDS.update({c: i for i, c in enumerate('A23456789', 1)})

def evaluate_hand(hand_base_value, alt_values, alt_cards):
    alt_hand = hand_base_value + sum((alt_values[k] - CARDS[k]) * v for k, v in alt_cards.items())
    return alt_hand <= 21 and alt_hand

def krazy_king_blackjack(hand, king_value):
    deal, alt_values = Counter(hand), {'A': 11, 'K': king_value}
    min_hand_value, alt_cards = sum(v * CARDS[k] for k, v in deal.items()), sorted(alt_values)
    return max(evaluate_hand(min_hand_value, alt_values, dict(zip(alt_cards, p)))
               for p in product(*[range(deal.get(card, 0) + 1) for card in alt_cards]))​

答案4：

def krazy_king_blackjack (hand, king_value):
    def scoring(card):
        if card in "JQ": return (10,)
        elif card == "A": return (1, 11)
        elif card == "K": return (king_value, 10)
        else: return (int(card),)
        
    values = [0]
    for card in hand:
        values = [val + score for val in values for score in scoring(str(card)) if (val + score <= 21)]
    
    return max(values) if values else False​

答案5：

def krazy_king_blackjack (hand, king_value, score = 0):
    if not hand: return score if 0 < score < 22 else False
    
    vals = {str(k): [k] for k in range(2, 11)}
    vals.update({'A': [1, 11], 'K': [10, king_value], 'J': [10], 'Q': [10]})
    
    return max([krazy_king_blackjack(hand[1:], king_value, score + c) for c in vals[hand[0]]])​

答案6：

import itertools
def krazy_king_blackjack (hand, king_value):
    special=[]
    rest=[]
    cards={'J':10,'Q':10,'K': king_value or 10}
    sume=0
    for key, group in itertools.groupby(hand, key= lambda x : (x=='A' or x=='K')):
        for thing in group:
            if key:
                special.append(thing)
            else:
                rest.append(thing)
    for card in rest:
        sume += int(cards.get(card,card))
    ass =  list(map(sum,list(itertools.combinations_with_replacement([1,11], special.count('A')))))
    ks = list(map(sum,list(itertools.combinations_with_replacement([10,king_value], special.count('K')))))
    restsums=0
    for ace in ass:
        for k in ks:
            if sume+k+ace > restsums and  sume+k+ace < 22:
                restsums=sume+k+ace
    if restsums == 0:
        return False
    return(restsums)​

答案7：

def krazy_king_blackjack (hand, king_value):
    number_ace=hand.count('A')
    number_king=hand.count('K')
    print(number_king)
    extraking=10-king_value
    dict = {'A': 1, 'J': 10, 'Q': 10, 'K': king_value}
    def valuefind(i):
        try:
            return int(i)
        except:
            return dict.get(i)
    aim = 21 - sum(list(map(valuefind, hand))     ) 
    if  (aim <0):
        return( False)
    elif ((aim <extraking) | ((number_king + number_ace)==0)):
        return( 21-aim)
    else:
        options = []
        for i in range(number_king+1):
            for j in range(number_ace+1):
                 options.append(i*extraking + j*10)
        return 21-(aim-(max([x for x in options if x<=aim])))
                

​

答案8：

def krazy_king_blackjack (hand, king_value):

    VALUES = {'2':[2],'3':[3],'4':[4],'5':[5],'6':[6],'7':[7],'8':[8],'9':[9],'10':[10],
          'J':[10],'Q':[10],'K':[10],'A':[1,11]}
          
    if VALUES['K']!=king_value:
        VALUES['K'].append(king_value)
    score = [0]
    for card in hand:
        score = addCard(score, VALUES[card])
    score = list(filter(lambda x:x<=21, score))
    score = sorted(score, key=lambda x:x-21, reverse = True)
    return False if len(score)==0 else score[0]
    
def addCard(score, newCardVals):
    temp = []
    for s1 in score:
        for s2 in newCardVals:
            temp.append(s1+s2)                
    score = list(set(temp))
    return score
    ​

答案9：

from itertools import product

def krazy_king_blackjack(hand, king_value):
    AK = [card for card in hand if card in "AK"]
    nonAK = [card for card in hand if card not in "AK"]
    answer = base = sum(10 if card in ["10", "J", "Q"] else int(card) for card in nonAK)
    bust = base > 21
    if (not bust) and AK:
        bust = True
        choices = [[1, 11] if card == "A" else [king_value, 10] for card in AK]
        for combo in product(*choices):
            baseWithAK = base + sum(combo)
            if baseWithAK <= 21:
                bust = False
                answer = max(answer, baseWithAK)
    return answer if not bust else False​

答案10：

def krazy_king_blackjack (hand, king_value):
    
    possibleResults = []

    for i in range(len(hand)):
        if hand[i] == 'K':
            if not len(possibleResults):
                possibleResults = [10,king_value]
            else:
                possibleResults = [x+10 for x in possibleResults] + [x+king_value for x in possibleResults] 
        elif hand[i] == 'A':
            if not len(possibleResults):
                possibleResults = [1,11]
            else:
                possibleResults = [x+1 for x in possibleResults] + [x+11 for x in possibleResults] 
        elif hand[i].isnumeric():
            if not len(possibleResults):
                possibleResults = [int(hand[i])]
            else:
                possibleResults = [x+int(hand[i]) for x in possibleResults]
        else:
            if not len(possibleResults):
                possibleResults = [10]
            else:
                possibleResults = [x+10 for x in possibleResults] 
    
    result = 0
    for i in range(len(possibleResults)):
        if possibleResults[i]<=21 and possibleResults[i] > result:
            result = possibleResults[i]
    
    return result if result > 0 else False​