Example #1
0
def to_34_array(obj=None, man=None, pin=None, sou=None, honors=None):
    if obj == None:
        return TilesConverter.string_to_34_array(man=man,
                                                 pin=pin,
                                                 sou=sou,
                                                 honors=honors)
    else:
        return TilesConverter.string_to_34_array(man=obj["man"],
                                                 pin=obj["pin"],
                                                 sou=obj["sou"])
Example #2
0
def CountShanten(haishi):
    '''
    牌姿データからシャンテン数を数える
    '''

    man = ''
    pin = ''
    sou = ''
    honors = ''

    for x in haishi.split(','):
        if table.pai2[int(x)][1] == 'm':
            man += table.pai2[int(x)][0]
        if table.pai2[int(x)][1] == 'p':
            pin += table.pai2[int(x)][0]
        if table.pai2[int(x)][1] == 's':
            sou += table.pai2[int(x)][0]
        if table.pai2[int(x)][1] == 'z':
            honors += table.pai2[int(x)][0]

    shanten = Shanten()
    tiles = TilesConverter.string_to_34_array(
        man=man,
        pin=pin,
        sou=sou,
        honors=honors,
    )

    c = shanten.calculate_shanten(tiles)
    return (c if c > 0 else 0)
Example #3
0
    def syanten(self, tehais):
        _, m, p, s, h = mahjong.remove_mpsh(mahjong.henkan(tehais))
        tiles = TilesConverter.string_to_34_array(man=m,
                                                  pin=p,
                                                  sou=s,
                                                  honors=h)
        result, _, _ = shanten.calculate_shanten(tiles)

        return result
Example #4
0
    def shanten(self):
        tile_strs = [""] * 4

        for hai in self.hais:
            tile_strs[hai.kind] += str(hai.num)

        if self.tsumo_hai is not None:
            tile_strs[self.tsumo_hai.kind] += str(self.tsumo_hai.num)

        tiles = TilesConverter.string_to_34_array(tile_strs[0], tile_strs[1], tile_strs[2], tile_strs[3])

        return self.calculator.calculate_shanten(tiles)
Example #5
0
def tenpai(tiles, sute):
    shanten = Shanten()
    if len(tiles) == 34:
        # [3,1,1,...,3,0,...,0]
        tiles_34 = tiles
    else:
        # man='1112345678999', pin='', sou='', honors=''
        tiles_34 = TilesConverter.string_to_34_array(tiles)

    result = [0] * 34
    for i in range(34):
        if tiles_34[i] < 4 and not sute[i]:
            tiles_34[i] += 1
            if shanten.calculate_shanten(tiles_34) == -1:
                result[i] = 1
            tiles_34[i] -= 1
    return result
Example #6
0
melds = [
    Meld(meld_type=Meld.PON,
         tiles=TilesConverter.string_to_136_array(man='444'))
]

result = calculator.estimate_hand_value(
    tiles, win_tile, melds=melds, config=HandConfig(has_open_tanyao=True))
print_hand_result(result)

####################################################################
# Shanten calculation                                              #
####################################################################

shanten = Shanten()
tiles = TilesConverter.string_to_34_array(man='13569', pin='123459', sou='443')
result = shanten.calculate_shanten(tiles)

print(result)

####################################################################
# Kazoe as a sanbaiman                                             #
####################################################################

tiles = TilesConverter.string_to_136_array(man='22244466677788')
win_tile = TilesConverter.string_to_136_array(man='7')[0]
melds = [Meld(Meld.KAN, TilesConverter.string_to_136_array(man='2222'), False)]

dora_indicators = [
    TilesConverter.string_to_136_array(man='1')[0],
    TilesConverter.string_to_136_array(man='1')[0],
def index(request):
    # return HttpResponse("Hello, world. You're at the polls index.")

    if request.method == 'GET':
        return JsonResponse({})

    # JSON文字列
    datas = json.loads(request.body)

    #全37種
    syurui = {'1m':0,'2m':1,'3m':2,'4m':3,'5m':4,'6m':5,'7m':6,'8m':7,'9m':8,'1s':9,'2s':10,'3s':11,'4s':12,'5s':13,'6s':14,'7s':15,'8s':16,'9s':17,'1p':18,'2p':19,'3p':20,'4p':21,'5p':22,'6p':23,'7p':24,'8p':25,'9p':26,'a':27,'b':28,'c':29,'d':30,'e':31,'f':32,'g':33, 'a5m':34, 'a5s':35, 'a5p':36}
    #風4種
    field = {'a':0,'b':1,'c':2,'d':3}
    #萬子
    dic_man = {'1m':1, '2m':2, '3m':3, '4m':4, '5m':5, '6m':6, '7m':7, '8m':8, '9m':9, 'a5m':5}
    #索子
    dic_sou = {'1s':1, '2s':2, '3s':3, '4s':4, '5s':5, '6s':6, '7s':7, '8s':8, '9s':9, 'a5s':5}
    #筒子
    dic_pin = {'1p':1, '2p':2, '3p':3, '4p':4, '5p':5, '6p':6, '7p':7, '8p':8, '9p':9, 'a5p':5}
    #字牌
    dic_honors = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6, 'g':7}

    dora = datas["dora"]["name"]
    ground = datas["ground"]["name"]
    own = datas["own"]["name"]

    #配牌リスト
    pai_list = [0 for i in range(37)]
    for i in datas["haipai"]:
        pai_list[syurui[i["hai"]]] += i["amount"]

    input_list = pai_list

    #シャンテン数
    man = ''
    sou = ''
    pin = ''
    honors = ''
    for i in datas["haipai"]:
        if 'm' in i["hai"]:
            for j in range(i["amount"]):
                man += str(dic_man[i["hai"]])
        elif 's' in i["hai"]:
            for j in range(i["amount"]):
                sou += str(dic_sou[i["hai"]])
        elif 'p' in i["hai"]:
            for j in range(i["amount"]):
                pin += str(dic_pin[i["hai"]])
        else:
            for j in range(i["amount"]):
                honors += str(dic_honors[i["hai"]])
    shanten = Shanten()
    tiles = TilesConverter.string_to_34_array(man=man, pin=pin, sou=sou, honors=honors)
    ss = shanten.calculate_shanten(tiles)

    ##萬子,索子,筒子,字牌,中張牌,么九牌,ドラのカウント
    dd = 0
    m = 0
    s = 0
    p = 0
    h = 0
    tyu = 0
    yao = 0
    for i in datas["haipai"]:
        #ドラ枚数
        if i["hai"] == dora or i["hai"] == 'a5m' or i["hai"] == 'a5s' or i["hai"] == 'a5p':
            dd += i["amount"]
        #萬子枚数
        if 'm' in i["hai"]:
            m += i["amount"]
        #索子枚数
        elif 's' in i["hai"]:
            s += i["amount"]
        #筒子枚数
        elif 'p' in i["hai"]:
            p += i["amount"]
        #字牌枚数
        else:
            h += i["amount"]
        #么九牌
        if '1' in i["hai"] or '9' in i["hai"] or 'a' in i["hai"] or 'b' in i["hai"] or 'c' in i["hai"] or 'd' in i["hai"] or 'e' in i["hai"] or 'f' in i["hai"] or 'g' in i["hai"]:
            yao += i["amount"]
        else:
            tyu += i["amount"]

    input_list.append(dd)
    input_list.append(ss)
    input_list.append(m)
    input_list.append(s)
    input_list.append(p)
    input_list.append(h)
    input_list.append(tyu)
    input_list.append(yao)

    #ドラリスト化
    dora_list = [0 for i in range(34)]
    dora_list[syurui[dora]] += 1

    input_list[len(input_list):len(input_list)] = dora_list

    #場風リスト化
    field1_list = [0 for i in range(4)]
    field1_list[field[ground]] += 1

    input_list[len(input_list):len(input_list)] = field1_list

    #自風リスト化
    field2_list = [0 for i in range(4)]
    field2_list[field[own]] += 1

    input_list[len(input_list):len(input_list)] = field2_list

    input_data = []
    input_data.append(input_list)
    input_data = np.array(input_data)
    input_data = input_data.astype('float32')

    ##訓練済みネットワークを用いた推論
    #保存したネットワークの読み込み
    #訓練済みのネットワークと同様のクラスのインスタンス生成
    loaded_net = Net(n_hidden=200)

    #訓練済みネットワークのパラメータを読み込ませる
    chainer.serializers.load_npz('./genapp/ml_models/m_data.net', loaded_net)

    # テストデータで予測値を計算
    with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):
        y = loaded_net(input_data)

    resignation = np.argmax(y[0,:].array)

    point = random.randint(1,5)

    result = {
        'res':str(resignation),
        'point':str(point)
    }

    response = JsonResponse(
        result
    )
    return response
Example #8
0
 def _string_to_34_array(self, sou="", pin="", man="", honors=""):
     return TilesConverter.string_to_34_array(sou=sou, pin=pin, man=man, honors=honors)
Example #9
0
    def test_is_strictly_isolated_tile(self):
        hand_34 = TilesConverter.string_to_34_array(sou='1399',
                                                    pin='1567',
                                                    man='25',
                                                    honors='1224')

        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='1')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='2')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='3')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='4')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='5')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='6')), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='7')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='8')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou='9')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='1')), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='2')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='3')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='4')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='5')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='6')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='7')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='8')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin='9')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='1')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='2')), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='3')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='4')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='5')), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='6')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='7')), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='8')), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man='9')), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='1')),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='2')),
            False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='3')),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='4')),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='5')),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='6')),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors='7')),
            True)
Example #10
0
    def test_find_isolated_tiles(self):
        hand_34 = TilesConverter.string_to_34_array(sou='1369',
                                                    pin='15678',
                                                    man='25',
                                                    honors='124')
        isolated_tiles = find_isolated_tile_indices(hand_34)

        self.assertEqual(
            self._string_to_34_tile(sou='1') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='2') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='3') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='4') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='5') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='6') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='7') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='8') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou='9') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='1') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='2') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='3') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(pin='4') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='5') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='6') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='7') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='8') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin='9') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='1') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='2') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='3') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='4') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='5') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='6') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man='7') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(man='8') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(man='9') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors='1') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(honors='2') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(honors='3') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors='4') in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(honors='5') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors='6') in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors='7') in isolated_tiles, True)
Example #11
0
                                            hidden_34, depth - 1, shanten - 1)

            # return tile to hand
            closed_tiles_34[tile] += 1
            tiles_34[tile] += 1

        # return tile from closed hand to hidden
        hidden_34[i] += 1
        closed_tiles_34[i] -= 1
        tiles_34[i] -= 1

    return outs


closed_tiles_34 = TilesConverter.string_to_34_array(sou='347',
                                                    pin='469',
                                                    man='459',
                                                    honors='2567')
tiles_34 = TilesConverter.string_to_34_array(sou='347',
                                             pin='469',
                                             man='459',
                                             honors='2567')
table_34 = [0] * 34
shanten = 5

# closed_tiles_34 = TilesConverter.to_34_array(self.player.closed_hand)
# table_34 = copy.deepcopy(self.table.revealed_tiles)
# tiles_34 = TilesConverter.to_34_array(self.player.tiles)
# table_34[discard_34] += 1
# closed_tiles_34[discard_34] -= 1
# tiles_34[discard_34] -= 1
Example #12
0
            for hid in discards:
                result += '<img src="data/%s.png" width="50" height="80" onclick="exchange(%d, %d)">' % (
                    HAI_NAMES[hid], i, hid)
            result += '</th>'
            result += '<th>%d</th>' % best_jinzhang_num
            result += "<tr/>"
        result += "</table>"
        return result

    num_jinzhang = 0
    for r in all_jinzhang:
        num_jinzhang += 4 - used_tiles[r[0]] - tiles[r[0]]
    result = "<h2>%d向听</h2>" % SHANTEN.calculate_shanten(tiles)
    result += "<h2>%d进张</h2>" % num_jinzhang
    result += generate_table(all_jinzhang)
    result += "<h2>改良</h2>"
    result += generate_table(all_gailiang)
    return result


if __name__ == '__main__':
    tiles = TilesConverter.string_to_34_array(man='',
                                              pin='234445789',
                                              sou='1568')
    used_tiles = [0] * NUM_HAIS
    all_jinzhang, all_gailiang = compute_hand(tiles, used_tiles)
    for (i, best_jinzhang_num, discards) in all_jinzhang:
        print "%s: %d -> %s" % (TO_GRAPH_LIST[i], best_jinzhang_num, ",".join(
            [TO_GRAPH_LIST[d] for d in discards]))
    print generate_hand_html((all_jinzhang, all_gailiang))
Example #13
0
    def test_is_strictly_isolated_tile(self):
        hand_34 = TilesConverter.string_to_34_array(sou="1399",
                                                    pin="1567",
                                                    man="25",
                                                    honors="1224")

        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="1")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="2")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="3")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="4")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="5")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="6")), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="7")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="8")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(sou="9")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="1")), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="2")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="3")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="4")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="5")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="6")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="7")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="8")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(pin="9")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="1")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="2")), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="3")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="4")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="5")), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="6")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="7")), False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="8")), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(man="9")), True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="1")),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="2")),
            False)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="3")),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="4")),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="5")),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="6")),
            True)
        self.assertEqual(
            is_tile_strictly_isolated(hand_34,
                                      self._string_to_34_tile(honors="7")),
            True)
Example #14
0
    def test_find_isolated_tiles(self):
        hand_34 = TilesConverter.string_to_34_array(sou="1369",
                                                    pin="15678",
                                                    man="25",
                                                    honors="124")
        isolated_tiles = find_isolated_tile_indices(hand_34)

        self.assertEqual(
            self._string_to_34_tile(sou="1") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="2") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="3") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="4") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="5") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="6") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="7") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="8") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(sou="9") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="1") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="2") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="3") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(pin="4") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="5") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="6") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="7") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="8") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(pin="9") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="1") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="2") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="3") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="4") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="5") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="6") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(man="7") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(man="8") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(man="9") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors="1") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(honors="2") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(honors="3") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors="4") in isolated_tiles, False)
        self.assertEqual(
            self._string_to_34_tile(honors="5") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors="6") in isolated_tiles, True)
        self.assertEqual(
            self._string_to_34_tile(honors="7") in isolated_tiles, True)