19-3

def phazed_is_valid_play(play, player_id, table, turn_history, phase_status,
                         hand, discard):
    # Implement this function
    # 用字典定义每张牌的数值和对应的花色
    value_dict = {'A': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '0': 10, 'J': 11, 'Q': 12,
                  'K': 13}
    suit_dict = {'S': 'black', 'H': 'red', 'D': 'red', 'C': 'black'}
    phase_type = []
    result = []
    # 判断是否为第一个组合
    def is_one(length=3):
        if len(group) == length:
            # 将牌中的万能牌去掉后，如果牌面值只有一种，则符合第一中组合
            s1 = list(set(value_list) - set('A'))
            if len(s1) == 1:
                result.append(1)
    # 判断是否为第二个组合
    def is_two(length=7):
        if len(group) == length:
            # 从该组牌中去除万能牌
            for i in range(len(value_list) - 1, 0, -1):
                if value_list[i] == 'A':
                    suit_list.pop(i)
            # 去掉万能牌后，如果花色只有一种，则符合第二种组合
            s2 = set(suit_list)
            if len(s2) == 1:
                result.append(2)
    # 判断是否为第三个组合
    def is_three():
        if sum(int_value_list) == 34:
            result.append(3)
    # 判断该牌组是否排序
    def is_sorted():
        a_index = []  # 代表牌面为A所在的位置
        not_a = []  # 代表牌面不为A所在的位置
        for index, value in enumerate(int_value_list):
            if value != 1:
                not_a.append(index)
            else:
                a_index.append(index)
        # 找到第一个不是A牌的值，将A的值根据其位置进行转换为相应的牌
        for i in a_index:
            color_list[i] = color_list[not_a[0]]  # 将A牌的颜色换成一个不是A牌的颜色
            if i < not_a[0]:
                # 如果A牌在第一个不是A牌的前面，则进行减数处理
                a_value = int_value_list[not_a[0]] - (not_a[0] - i)
                # 如果该牌面值小于0，则直接退出
                if a_value > 0:
                    int_value_list[i] = a_value
                else:
                    return False
            else:
                # 如果A牌在第一个不是A牌的后面，则进行加数处理
                a_value = int_value_list[not_a[0]] + (i - not_a[0])
                # 如果该牌面值大于13，则直接退出
                if a_value < 13:
                    int_value_list[i] = a_value
                else:
                    return False
        # 判断替换A牌后的牌是否按照顺序排列
        for j in range(1, 4):
            if int_value_list[j] - int_value_list[j - 1] != 1:
                return False
        else:
            return True
    # 判断是否为第四个组合
    def is_four(length=4):
        if len(group) == length:
            # 将牌中的万能牌去掉后，如果牌面值只有一种，则符合第三种组合
            s3 = list(set(value_list) - set('A'))
            if len(s3) == 1:
                result.append(4)
    # 判断是否为第五个组合
    def is_five(length=8):
        if len(group) == length:
            if is_sorted():
                result.append(5)
    # 判断是否为第六个组合
    def is_six():
        red_sum = 0  # 记录红色牌的数值综合
        black_sum = 0  # 记录黑色牌的数值综合
        for i in range(len(group)):
            if color_list[i] == 'red':
                red_sum += int_value_list[i]
            else:
                black_sum += int_value_list[i]
        if red_sum == 34 or black_sum == 34:
            result.append(6)
    # 判断是否为第七个组合
    def is_seven(length=4):
        if len(group) == length:
            if is_sorted():
                if len(set(color_list)) == 1:
                    result.append(7)
    def get_phase_type():
        # 判断是否该组牌中有两个以上"natural" cards
        if value_list.count('A') <= len(value_list) - 2:
            is_one()
            is_two()
            is_four()
            is_five()
            is_seven()
        # 判断是否符合第六、七组合
        is_three()
        is_six()
        if result.count(1) >= 2:
            phase_type.append(1)
        if result.count(2) >= 1:
            phase_type.append(2)
        if result.count(3) >= 2:
            phase_type.append(3)
        if result.count(4) >= 2:
            phase_type.append(4)
        if result.count(5) >= 1:
            phase_type.append(5)
        if result.count(6) >= 2:
            phase_type.append(6)
        if result.count(7) >= 1 and result.count(4) >= 1:
            phase_type.append(7)
        return phase_type
    if play[0] == 3 and play[1][0] == phase_status[player_id] + 1:
        result = []
        for group in play[1][1]:
            # 获取每张牌的值，并转换成整数类型
            value_list = [_[0] for _ in group]
            int_value_list = [value_dict[i] for i in value_list]
            # 获取每张牌的花色，并转成红色或者黑色
            suit_list = [_[1] for _ in group]
            color_list = [suit_dict[i] for i in suit_list]
            get_phase_type()
        # print(phase_type)
        if play[1][0] in phase_type:
            return True
    elif play[0] == 4:
        group = table[play[1][1][0]][1][play[1][1][1]][:]
        group.insert(play[1][1][2], play[1][0])
        value_list = [_[0] for _ in group]
        int_value_list = [value_dict[i] for i in value_list]
        # 获取每张牌的花色，并转成红色或者黑色
        suit_list = [_[1] for _ in group]
        color_list = [suit_dict[i] for i in suit_list]
        print(table)
        print(group)
        is_num = table[play[1][1][0]][0]
        print(is_num)
        if is_num == 1:
            is_one(len(group))
        elif is_num == 2:
            is_two(len(group))
        elif is_num == 3:
            is_three()
        elif is_num == 4:
            is_four(len(group))
        elif is_num == 5:
            is_five(len(group))
        elif is_num == 6:
            is_six()
        elif is_num == 7:
            is_seven(len(group))
        if result:
            return True
        # pass
    elif play[0] == 5:
        if play[1] in hand:
            return True
    return False
if __name__ == '__main__':
    # Example calls to the function.
    print(phazed_is_valid_play((3, (1, [['2S', '2S', '2C'],
                                        ['AS', '5S', '5S']])), 0, [(None, []), (None, []),
                                                                   (None, []), (None, [])], [(0, [(2, 'JS')])],
                               [0, 0, 0, 0], ['AS', '2S', '2S', '2C', '5S', '5S',
                                              '7S', '8S', '9S', '0S', 'JS'], None))
    print(phazed_is_valid_play((4, ('KC', (1, 0, 0))),
                               1, [(None, []), (2, [['2S', '2S', 'AS', '5S',
                                                     '5S', '7S', 'JS']]), (None, []), (None, [])],
                               [(0, [(2, 'JS'), (5, 'JS')]), (1, [(1, 'XX'),
                                                                  (3, (
                                                                      2,
                                                                      [['2S', '2S', 'AS', '5S', '5S', '7S', 'JS']]))])],
                               [0, 2, 0, 0], ['5D', '0S', 'JS', 'KC'], '0H'))
    print(phazed_is_valid_play((5, 'JS'), 1, [(None, []),
                                              (1, [['2S', '2S', '2C'], ['AS', '5S', '5S']]),
                                              (None, []), (None, [])], [(0, [(2, 'JS'),
                                                                             (5, 'JS')]),
                                                                        (1, [(1, 'XX'), (3, (1, [['2S', '2S',
                                                                                                  '2C'], ['AS', '5S',
                                                                                                          '5S']]))])],
                               [0, 1, 0, 0],
                               ['AD', '8S', '9S', '0S', 'JS'], '3C'))