关于猜数字问题的探讨

 前些天无意中看到一个判断数字的题目，很有意思。

主持人从印有数字2-9的卡片中挑出两张，然后把数字的和告诉甲，数字的积告诉乙，让他们猜测主持人选中的数字，有以下的对话：

甲：我猜不出来两个数字是多少

乙：我也猜不出来

甲：我现在能猜出来了

乙：我现在也能猜出来了

请问这两个数字是多少？

分析起来感觉有点吃力，不能一下子抓住关键的所在，于是就想用编程的方式引导以下自己的思维。

以下是全部程序

 

import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.Map.Entry; 
 
 
public class Iknow { 
 
    /** 
     * 用来抽象主持人所选择的数对的组合 
     */ 
    public class Pair 
    { 
        int a, b; 
        Pair(int a, int b) 
        { 
            this.a=a; 
            this.b=b; 
        } 
         
        public String toString() 
        { 
            return "("+a+","+b+")"; 
        } 
    } 
     
    /** 
     * 用来抽象甲,乙二人得到结果的方法,一种是和,一种是积  
     */ 
    public enum Operation  
    { 
        SUM{ 
            @Override 
            public int apply(int a, int b) { 
                return a + b; 
            } 
        },  
        PRODUCT{ 
            @Override 
            public int apply(int a, int b) { 
                return a * b; 
            } 
        }; 
         
        abstract int apply(int a, int b); 
    } 
     
    /** 
     * 每个和数所对应的可能的组合 
     */ 
    private Map<Integer, List<Pair>> hms = new HashMap<Integer, List<Pair>>(); 
    /** 
     * 每个积数所对应的可能的组合 
     */ 
    private Map<Integer, List<Pair>> hmm = new HashMap<Integer, List<Pair>>(); 
     
     
    /** 
     * 主程序 
     */ 
    public static void main(String[] args)  
    { 
        int min = 2; 
        int max = 9; 
 
        String str ; 
        if ((str = System.getProperty("min") ) != null) 
        { 
            try 
            { 
                min = Integer.parseInt(str); 
            } 
            catch(NumberFormatException nfe) 
            {    
            } 
        } 
        if ((str = System.getProperty("max") ) != null) 
        { 
            try 
            { 
                max = Integer.parseInt(str); 
            } 
            catch(NumberFormatException nfe) 
            {    
            } 
        } 
         
        Iknow iknow = new Iknow(); 
 
        iknow.init(min, max); 
         
        iknow.kickSingleAnswer(); 
         
        iknow.pickupKnows(); 
         
    } 
 
    /** 
     * 初始化所有组合  
     * @param min 
     * @param max 
     */ 
    public void init(int min, int max) 
    { 
        for (int i=min ; i<max; i++) 
        { 
            for(int j = i+1; j<=max;j++) 
            { 
                Pair pair = new Pair(i,j); 
                addValue(Operation.SUM.apply(i, j), pair, hms); 
                addValue(Operation.PRODUCT.apply(i, j), pair, hmm); 
            } 
        } 
    } 
 
    private static <A,B> void addValue(A key, B value, Map<A, List<B>> hm) 
    { 
        List<B> p = hm.get(key); 
        if (p == null) 
        { 
            p = new ArrayList<B>(); 
            hm.put(key, p); 
        } 
        p.add(value); 
    } 
 
    /** 
     * 剔除能立即得出答案的组合 
     */ 
    public void kickSingleAnswer() 
    { 
        kickSingleAnswer(hms); 
        kickSingleAnswer(hmm); 
    } 
     
    private static <A,B> void kickSingleAnswer(Map<A, List<B>> hm) 
    { 
        List<A> la = new ArrayList<A>(); 
        for (Entry<A, List<B>> entrys: hm.entrySet()) 
        { 
            if (entrys.getValue().size() == 1) 
            { 
                la.add(entrys.getKey()); 
            } 
        } 
        for (A a: la) 
        { 
            hm.remove(a); 
        } 
        System.out.println("剔除 " + la +", 我们剩下 "  + hm); 
    } 
     
    /** 
     * 找出能得到答案的组合 
     */ 
    public void pickupKnows() 
    { 
        pickupKnows(hms, hmm, Operation.PRODUCT); 
        pickupKnows(hmm, hms, Operation.SUM); 
    } 
     
     
    private static void pickupKnows(Map<Integer, List<Pair>> hm1, Map<Integer, List<Pair>>hm2, Operation p) 
    { 
        List<Integer> removeKeys = new ArrayList<Integer>(); 
        for (Entry<Integer, List<Pair>> entrys: hm1.entrySet()) 
        { 
            List<Pair> values = entrys.getValue(); 
            Pair onlyPosible = null; 
            for (Pair pair: values) 
            { 
                boolean contains = hm2.containsKey(p.apply(pair.a, pair.b)); 
                if (onlyPosible == null && contains) 
                { 
                    onlyPosible = pair; 
                } 
                else if (onlyPosible != null && contains) 
                { 
                    onlyPosible = null; 
                    break; 
                } 
            } 
            if (onlyPosible == null) 
            { 
                removeKeys.add(entrys.getKey()); 
            } 
            else 
            { 
                values.clear(); 
                values.add(onlyPosible); 
            } 
        } 
        for (Integer a: removeKeys) 
        { 
            hm1.remove(a); 
        } 
 
        System.out.println(removeKeys + " 这些有多个答案是不合理的.\n最后我们有 "  + hm1); 
         
    } 
     
     
 
} 

程序中，用enum型模拟了和与积的操作，用Map模拟了甲、乙两个人得到的结果所对应的多种可能。通过程序的执行，把不合理的结果一步步剔除掉，最终得出可能的结果。

实际执行的第一步，把所有可能填充到Map中，作为基础数据。

根据对话的前两句，甲乙都不能独立猜出答案，所以去除Map中仅有唯一数对的组合。根据程序执行的结果我们发现，甲只是把最大最小两头的和数排除了4个，而乙却真是排除了大部分的乘积，只有三个乘积12，18，24是可能的。

根据第三句，我们把甲的每个可能的和数所对应的数对组合都要梳理一下。因为甲已经可能猜出数对，所以，每个和所对应的数对只有一个是合理的，其他的都要能排除掉。这样，就要把每个数对根据乙现在剩下的合理的乘积进行判断，也就是说数对乘积要是12，18，24的一种。于是我们又排除了5个和数的可能，只有7，8，9，10是可能的和数，而他们每个和数仅对应一个合理的数对，因为甲现在根据和数能猜出数对来。

根据第四句，也就是乙的最后一句，在剩下的乘积的Map中，每个乘积也只能有一个合理的数对。这时我们发现，12不幸的对应(2,6)和(3,4)两个数对。也就是说，如果乙拿着的乘积是12，他没办法猜出数对的组合是哪个来。

最后幸存的数对是（3，6）（4，6），也就是说，最初是这两个数字的话，甲和乙最后都能猜出原来的数对是什么。所以答案不是唯一的。

 

---

也许有人注意了我把2和9参数化了，也就是说我们可以在更大的范围上来找出可能的答案。比如，最初是从2到99，一共98张卡片的话，会是怎么样。我们只需要用一下命令实行

cmd> java -Dmax=99 Iknow

最后得到的数对是 {24=[(4,6)], 6624=[(69,96)], 7200=[(80,90)]}。

值得注意的是（3，6）淡出了我们的视线，揪其原因，是第三步甲再判断的时候，如果他的和是9，他有（3，6）和（4，5）两种可能，而在前面最大卡片数是9的情况下，（4，5）并不是一个合理的数对；而在最大数字是99的情况下，（4，5）合理了,因为（2，10）也可以得到20，保证了它不会在第二步被排除掉。