日麻折腾笔记-02-向听数的判断

2019-06-22

思考

向听数比较通俗易懂的解释是还差几张牌听牌，用程序能理解的话就是：

1 2	将手牌的n张牌替换成任意一张牌，能够满足听牌的n的最小值此时，手牌就是n向听

向听数可以由下面的公式快速算出：

1	向听数=8-2x(顺子数量+刻子数量)-对子数量-搭子数量

暂不考虑七对子与国士无双

所以只需要算出顺子、刻子、对子以及搭子的数量即可

但是要注意的是，很多牌形是有多种拆分方式的，诸如下面的示例

1234s

可以认为是123的顺子加上孤张4，也可以认为是1的孤张加上234的顺子，还可以认为是12和34两个搭子……

编码

我完善了上一章中的代码，将对子、刻子、顺子等概念抽象成类，每种拆分情况都由这四种组成，部分示例代码如下

package io.loli.mj.util.analyze;

import io.loli.mj.util.HandPai;

import java.util.ArrayList;
import java.util.List;

/**
 * 手牌分解的每种组合
 * 每种组合都由a个顺子、b个刻子、c个对子、d个搭子、e个孤张组合而成
 */
public class SplitCondition {
    private List<Duizi> duiziList = new ArrayList<>();
    private List<Shunzi> shunziList = new ArrayList<>();
    private List<Dazi> daziList = new ArrayList<>();
    private List<Kezi> keziList = new ArrayList<>();
    private List<HandPai> guzhangList = new ArrayList<>();

    public int xiangTing() {
        return 8 - 2 * (keziList.size() + shunziList.size()) - daziList.size() - duiziList.size();
    }


    public void addDuizi(Duizi duizi) {
        duiziList.add(duizi);
    }

    public void addShunzi(Shunzi shunzi) {
        shunziList.add(shunzi);
    }

    public void addDazi(Dazi dazi) {
        daziList.add(dazi);
    }

    public void addKezi(Kezi kezi) {
        keziList.add(kezi);
    }

    public void addGuzhang(HandPai guzhang) {
        guzhangList.add(guzhang);
    }


    public List<Duizi> getDuiziList() {
        return duiziList;
    }


    public List<Shunzi> getShunziList() {
        return shunziList;
    }


    public List<Dazi> getDaziList() {
        return daziList;
    }


    public List<Kezi> getKeziList() {
        return keziList;
    }


    public List<HandPai> getGuzhangList() {
        return guzhangList;
    }

    public void setGuzhangList(List<HandPai> guzhangList) {
        this.guzhangList = guzhangList;
    }


    public SplitCondition copy() {
        SplitCondition condition = new SplitCondition();
        condition.duiziList = new ArrayList<>(getDuiziList());
        condition.daziList = new ArrayList<>(getDaziList());
        condition.keziList = new ArrayList<>(getKeziList());
        condition.shunziList = new ArrayList<>(getShunziList());
        return condition;
    }


    @Override
    public String toString() {
        return "[" +
                duiziList +
                shunziList +
                daziList +
                keziList +
                guzhangList + "]";

    }
}

package io.loli.mj.util.analyze;

import io.loli.mj.util.HandAnalyze;
import io.loli.mj.util.HandPai;
import io.loli.mj.util.Pai;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class PaiSplitter {
    public static List<SplitCondition> split(String str) {
        List<HandPai> handPais = HandAnalyze.strToHandPai(str);
        List<SplitCondition> conditions = new ArrayList<>();
        return split(handPais, conditions, new SplitCondition(), 0);
    }

    private static List<SplitCondition> split(List<HandPai> handPais, List<SplitCondition> conditions, SplitCondition condition, int depth) {
        if (handPais.size() <= 1) {
            conditions.add(condition);
            return conditions;
        }
        HandPai current = null;
        HandPai next = null;
        HandPai nextNext = null;
        current = handPais.get(0);
        next = handPais.get(1);
        if (0 != handPais.size() - 2) {
            nextNext = handPais.get(2);
        }
        // 处理对子
        if (current.getPai() == next.getPai()) {
            handleDuizi(handPais, conditions, condition.copy(), current, next, depth + 1);
        }
        // 处理刻子
        if (nextNext != null) {
            if (current.getPai() == next.getPai() && next.getPai() == nextNext.getPai()) {
                handleKezi(handPais, conditions, condition.copy(), current, next, nextNext, depth + 1);
            }
        }
        Pai currentPlusOne = current.getPai().next(false);
        if (currentPlusOne != null) {
            List<HandPai> filtered = handPais.stream().filter(p -> p.getPai() == currentPlusOne).collect(Collectors.toList());
            if (filtered.size() > 0) {
                HandPai second = filtered.get(0);
                handleDazi(handPais, conditions, condition.copy(), current, second, depth + 1);
                Pai currentPlusTwo = currentPlusOne.next(false);
                filtered = handPais.stream().filter(p -> p.getPai() == currentPlusTwo).collect(Collectors.toList());
                if (filtered.size() > 0) {
                    HandPai third = filtered.get(0);
                    handleShunzi(handPais, conditions, condition.copy(), current, second, third, depth + 1);
                }
            }
        }
        handleGuzhang(handPais, conditions, condition.copy(), current, depth + 1);
        return conditions;
    }


    private static void handleGuzhang(List<HandPai> currentHandPai, List<SplitCondition> conditions, SplitCondition condition, HandPai first, int depth) {
        currentHandPai = new ArrayList<>(currentHandPai);
        condition.addGuzhang(first);
        currentHandPai.remove(first);
        split(currentHandPai, conditions, condition, depth);
    }

    private static void handleDazi(List<HandPai> currentHandPai, List<SplitCondition> conditions, SplitCondition condition, HandPai first, HandPai second, int depth) {
        currentHandPai = new ArrayList<>(currentHandPai);
        Dazi dazi = new Dazi(Arrays.asList(first, second));
        condition.addDazi(dazi);
        currentHandPai.remove(first);
        currentHandPai.remove(second);
        split(currentHandPai, conditions, condition, depth);
    }

    private static void handleDuizi(List<HandPai> currentHandPai, List<SplitCondition> conditions, SplitCondition condition, HandPai first, HandPai second, int depth) {
        currentHandPai = new ArrayList<>(currentHandPai);
        Duizi duizi = new Duizi(Arrays.asList(first, second));
        condition.addDuizi(duizi);
        currentHandPai.remove(first);
        currentHandPai.remove(second);
        split(currentHandPai, conditions, condition, depth);
    }

    private static void handleShunzi(List<HandPai> currentHandPai, List<SplitCondition> conditions, SplitCondition condition, HandPai first, HandPai second,
                                     HandPai third, int depth) {
        currentHandPai = new ArrayList<>(currentHandPai);
        Shunzi shunzi = new Shunzi(Arrays.asList(first, second, third));
        condition.addShunzi(shunzi);
        currentHandPai.remove(first);
        currentHandPai.remove(second);
        currentHandPai.remove(third);
        split(currentHandPai, conditions, condition, depth);
    }

    private static void handleKezi(List<HandPai> currentHandPai, List<SplitCondition> conditions, SplitCondition condition, HandPai first, HandPai second,
                                   HandPai third, int depth) {
        currentHandPai = new ArrayList<>(currentHandPai);
        Kezi kezi = new Kezi(Arrays.asList(first, second, third));
        condition.addKezi(kezi);
        currentHandPai.remove(first);
        currentHandPai.remove(second);
        currentHandPai.remove(third);
        split(currentHandPai, conditions, condition, depth);
    }

}

示例输出

@Test
public void splitDuizi() {
    List<SplitCondition> split = PaiSplitter.split("11223344556677s");
    Assert.assertTrue(split.stream().anyMatch(c -> c.getDuiziList().size() == 7));
}

@Test
public void testHe() {
    List<SplitCondition> split = PaiSplitter.split("11223344556677s");
    Assert.assertTrue(split.stream().mapToInt(SplitCondition::xiangTing)
            .min().getAsInt() < 1);
}


@Test
public void testKeziAndShunzi() {
    List<SplitCondition> split = PaiSplitter.split("11155s134m579p122z");
    Assert.assertEquals(3, split.stream().mapToInt(SplitCondition::xiangTing)
            .min().getAsInt());
}

我们现在已经能够知道一副手牌的向听数了，下一期将会讲牌效率相关的内容

相关代码会在整理后放到github上