解决爱因斯坦出的头脑风暴测试题

最新推荐文章于 2022-02-25 07:13:30 发布
最新推荐文章于 2022-02-25 07:13:30 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： T 文章标签： 测试 string c import class list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/redvalley/article/details/1646005
版权

        经常遇见这样的问题，却往往没人回答，于是发贴者洋洋自得？猜的，哈哈。
或许在那个年代，要做出这样的问题非常难，我感到奇怪的是爱因斯坦为什么出这样的题目，考察人的什么思维？又是怎么出的?难道考察天才的某一特性：解决问题时拥有超强的暂时记忆，能容忍很大的不确定性？
现在还拿出来吼吼，当我们程序员不存在，郁闷之余，逐写代码解决。

 解题思路：
1.1~15个已知条件写成c1~15个条件方法；
2.预先求1..5的所有排列；
3.对每个属性进行排列；
4.对6个属性的排列进行组合；
5.上面的排列组合有24.8832亿种，每种组合在合适的位置过滤1~15个条件(合适位置的选择：条件关联的属性已被赋值，且最浅循环。)；
6.执行结果有7种排列组合，其中可能养鱼的分别有：德国、挪威、丹麦。

package  com.game;

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

 /**
 * 
<pre>
    爱因斯坦出的测试题,据说世界98%的人答不出！来看看这道爱因斯坦出的测试题, 他说世界上有98%的人回答不出, 
    看看你是否属于另外的2%:
    1. 有5栋5种颜色的房子 
    2. 每一位房子的主人国籍都不同 
    3. 这5个人每人只喝一个牌子的饮料, 只抽一个牌子的香烟, 只养一 
    种宠物 
    4. 没有人有相同的宠物, 抽相同牌子的香烟, 喝相同的饮料 
    已知条件: 
    1. 英国人住在红房子里 
    2. 瑞典人养了一条狗 
    3. 丹麦人喝茶 
    4. 绿房子在白房子左边 
    5. 绿房子主人喝咖啡 
    6. 抽PALL MALL烟的人养了一只鸟 
    7. 黄房子主人抽DUNHILL烟 
    8. 住在中间那间房子的人喝牛奶 
    9. 挪威人住在第一间房子 
    10. 抽混合烟的人住在养猫人的旁边 
    11. 养马人住在DUNHILL烟的人旁边 
    12. 抽BLUE MASTER烟的人喝啤酒 
    13. 德国人抽PRINCE烟 
    14. 挪威人住在蓝房子旁边 
    15. 抽混合烟的人的邻居喝矿泉水
    问题是:谁养鱼？
</pre>
 * @author zfzheng
 * {@value 不好意思，偶便是2%中较笨的一个 :)}
 *
 */
public   class  EinsteinProblem  {
    private final static int[] NO={1,2,3,4,5};
    private final static String[] COLOR={"红","白","绿","蓝","黄"};
    private final static String[] NATIONALITY={"英国","瑞典","丹麦","挪威","德国"};
    private final static String[] DRINK={"茶","咖啡","牛奶","啤酒","矿泉水"};
    private final static String[] SMOKE={"PALL MALL","DUNHILL","BLUE MASTER","PRINCE","混合烟"};
    private final static String[] PET={"狗","鸟","猫","鱼","马"};
    //排列列表,{[1,2,3,4,5],[1,2,3,5,4],......}
    private List<int[]> pList=new ArrayList<int[]>();
    
    static class Combine{
        int no;//房间编号
        String color;//房子颜色
        String nationality;//国籍
        String drink;//饮料
        String smoke;//香烟
        String pet;//宠物        
        
        public String toString(){
            return no+" "+color+" "+nationality+" "+drink+" "+smoke+" "+pet;
        }
    }
    
    // 1. 英国人住在红房子里 
    private boolean c1(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.nationality.equals("英国")){
                return item.color.equals("红");
            }
        }
        return false;
    }
    
    //2. 瑞典人养了一条狗 
    private boolean c2(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.nationality.equals("瑞典")){
                return item.pet.equals("狗");
            }
        }
        return false;
    }    
    
    //3. 丹麦人喝茶 
    private boolean c3(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.nationality.equals("丹麦")){
                return item.drink.equals("茶");
            }
        }
        return false;
    }    
    
    //4. 绿房子在白房子左边 
    private boolean c4(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.color.equals("绿")){
                for(int j=i+1;j<n;j++){
                    if(items[j].color.equals("白")){
                        return true;
                    }
                }
                return false;
            }
        }
        return false;
    }    
    
    // 5. 绿房子主人喝咖啡  
    private boolean c5(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.color.equals("绿")){
                return item.drink.equals("咖啡");
            }
        }
        return false;
    }    

    //6. 抽PALL MALL烟的人养了一只鸟 
    private boolean c6(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("PALL MALL")){
                return item.pet.equals("鸟");
            }
        }
        return false;
    }    
    
    //7. 黄房子主人抽DUNHILL烟 
    private boolean c7(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("DUNHILL")){
                return item.color.equals("黄");
            }
        }
        return false;
    }
    
    //8. 住在中间那间房子的人喝牛奶 
    private boolean c8(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.no==3){
                return item.drink.equals("牛奶");
            }
        }
        return false;
    }
    
    //9. 挪威人住在第一间房子
    private boolean c9(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.no==1){
                return item.nationality.equals("挪威");
            }
        }
        return false;
    }
    //10. 抽混合烟的人住在养猫人的旁边 
    private boolean c10(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("混合烟")){
                return (i>0&&items[i-1].pet.equals("猫"))||(i<n-1&&items[i+1].pet.equals("猫"));
            }
        }
        return false;
    }    
    
    //11. 养马人住在DUNHILL烟的人旁边 
    private boolean c11(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("DUNHILL")){
                return (i>0&&items[i-1].pet.equals("马"))||(i<n-1&&items[i+1].pet.equals("马"));
            }
        }
        return false;
    }
    
    //12. 抽BLUE MASTER烟的人喝啤酒 
    private boolean c12(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("BLUE MASTER")){
                return item.drink.equals("啤酒");
            }
        }
        return false;
    }    
    
    //13. 德国人抽PRINCE烟 
    private boolean c13(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("PRINCE")){
                return item.nationality.equals("德国");
            }
        }
        return false;
    }    
    
    // 14. 挪威人住在蓝房子旁边 
    private boolean c14(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.nationality.equals("挪威")){
                return (i>0&&items[i-1].color.equals("蓝"))||(i<n-1&&items[i+1].color.equals("蓝"));
            }
        }
        return false;
    }    
    
    // 15. 抽混合烟的人的邻居喝矿泉水  
    private boolean c15(Combine[] items){
        Combine item;
        for(int i=0,n=items.length;i<n;i++){
            item=items[i];
            if(item.smoke.equals("混合烟")){
                return (i>0&&items[i-1].drink.equals("矿泉水"))||(i<n-1&&items[i+1].drink.equals("矿泉水"));
            }
        }
        return false;
    }    
    
    private void assignCombine(Combine[] items){
        int matchedCount=0;
        int n=pList.size();
        for(int i_color=0;i_color<n;i_color++){
            assignColor(items,pList.get(i_color));
            if(!c4(items))continue;// 4. 绿房子在白房子左边 
            for(int i_nationality=0;i_nationality<n;i_nationality++){
                assignNationality(items,pList.get(i_nationality));
                if(!c1(items))continue;//1. 英国人住在红房子里 
                if(!c9(items))continue;//9. 挪威人住在第一间房子
                if(!c14(items))continue;//14. 挪威人住在蓝房子旁边
                for(int i_drink=0;i_drink<n;i_drink++){
                    assignDrink(items,pList.get(i_drink));
                    if(!c3(items))continue;//3. 丹麦人喝茶 
                    if(!c5(items))continue;// 5. 绿房子主人喝咖啡 
                    if(!c8(items))continue;//8. 住在中间那间房子的人喝牛奶 
                    for(int i_smoke=0;i_smoke<n;i_smoke++){
                        assignSmoke(items,pList.get(i_smoke));
                        if(!c7(items))continue;// 7. 黄房子主人抽DUNHILL烟
                        if(!c12(items))continue;//12. 抽BLUE MASTER烟的人喝啤酒 
                        if(!c13(items))continue;//13. 德国人抽PRINCE烟
                        if(!c15(items))continue;//15. 抽混合烟的人的邻居喝矿泉水
                        for(int i_pet=0;i_pet<n;i_pet++){
                            assignPet(items,pList.get(i_pet));
                            if(!c2(items))continue;//2. 瑞典人养了一条狗 
                            if(!c6(items))continue;//6. 抽PALL MALL烟的人养了一只鸟
                            if(!c10(items))continue;//10. 抽混合烟的人住在养猫人的旁边 
                            if(!c11(items))continue;// 11. 养马人住在DUNHILL烟的人旁边
                            matchedCount++;
                            dumpCombine(items);
                        }
                    }
                }                
            }
        }        
        System.out.println("Matched count="+matchedCount);
    }    
    
    private void assignColor(Combine[] items,int[] order){
        for(int i=0,n=items.length;i<n;i++){
            items[i].color=COLOR[order[i]-1];
        }
    }
    private void assignNationality(Combine[] items,int[] order){
        for(int i=0,n=items.length;i<n;i++){
            items[i].nationality=NATIONALITY[order[i]-1];
        }
    }
    
    
    private void assignDrink(Combine[] items,int[] order){
        for(int i=0,n=items.length;i<n;i++){
            items[i].drink=DRINK[order[i]-1];
        }
    }
    private void assignSmoke(Combine[] items,int[] order){
        for(int i=0,n=items.length;i<n;i++){
            items[i].smoke=SMOKE[order[i]-1];
        }
    }
    private void assignPet(Combine[] items,int[] order){
        for(int i=0,n=items.length;i<n;i++){
            items[i].pet=PET[order[i]-1];
        }
    }    
    
    
    private void dumpCombine(Combine[] items){
        StringBuffer s=new StringBuffer();
        for(int i=0;i<items.length;i++){
            s.append(items[i]).append(" ");
        }
        System.out.println(s+" ");
    }
    
    //排列
    private void readyPermutation(int n){
        pList.clear();
        boolean[] selected=new boolean[n];
        Arrays.fill(selected, false);
        int[] v=new int[n];
        Arrays.fill(v, -1);
        doPermutation(selected,v,n,0);
    }
    
    /**
     * 递归、回溯求排列
     */
    private void doPermutation(boolean[] selected, int[] v, int n, int filledCount){
        for(int i=filledCount;i<n;i++){
            for(int j=0;j<n;j++){
                if(!selected[j]){
                    selected[j]=true;
                    v[i]=j+1;
                    if(i==n-1){
                        gatherPermutationResult(v);
                    }
                    doPermutation(selected,v,n,i+1);    
                    //回溯
                    selected[j]=false;
                    v[i]=-1;
                }
            }            
                        
        }
    }
    
    private void gatherPermutationResult(int[] v){
        for(int i=0;i<v.length;i++){
            if(v[i]==-1){
                return;
            }
        }
        pList.add(v.clone());
    }
    
    private void doMatch(){
        //初始化
        Combine[] items=new Combine[5];
        for(int i=0;i<items.length;i++){
            items[i]=new Combine();
            items[i].no=NO[i];
        }
        //准备排列组合
        readyPermutation(5);
        //匹配
        assignCombine(items);    
    }
    
    
    public static void main(String[] args) {
        new EinsteinProblem().doMatch();
    }    
}

 

执行输出

1 绿 挪威 咖啡 PALL MALL 鸟
2 蓝 德国 矿泉水 PRINCE 猫
3 红 英国 牛奶 混合烟 马
4 黄 丹麦 茶 DUNHILL 鱼
5 白 瑞典 啤酒 BLUE MASTER 狗


1 绿 挪威 咖啡 PALL MALL 鸟
2 蓝 德国 矿泉水 PRINCE 鱼
3 红 英国 牛奶 混合烟 马
4 黄 丹麦 茶 DUNHILL 猫
5 白 瑞典 啤酒 BLUE MASTER 狗


1 绿 挪威 咖啡 PALL MALL 鸟
2 蓝 德国 矿泉水 PRINCE 猫
3 白 瑞典 牛奶 混合烟 狗
4 红 英国 啤酒 BLUE MASTER 马
5 黄 丹麦 茶 DUNHILL 鱼


1 绿 挪威 咖啡 PALL MALL 鸟
2 蓝 德国 矿泉水 PRINCE 猫
3 白 瑞典 牛奶 混合烟 狗
4 黄 丹麦 茶 DUNHILL 鱼
5 红 英国 啤酒 BLUE MASTER 马


1 绿 挪威 咖啡 PALL MALL 鸟
2 蓝 德国 矿泉水 PRINCE 鱼
3 白 瑞典 牛奶 混合烟 狗
4 黄 丹麦 茶 DUNHILL 猫
5 红 英国 啤酒 BLUE MASTER 马


1 绿 挪威 咖啡 混合烟 鱼
2 蓝 德国 矿泉水 PRINCE 猫
3 黄 瑞典 牛奶 DUNHILL 狗
4 红 英国 啤酒 BLUE MASTER 马
5 白 丹麦 茶 PALL MALL 鸟


1 黄 挪威 矿泉水 DUNHILL 猫
2 蓝 丹麦 茶 混合烟 马
3 红 英国 牛奶 PALL MALL 鸟
4 绿 德国 咖啡 PRINCE 鱼
5 白 瑞典 啤酒 BLUE MASTER 狗


Matched count=7

 

 

redvalley
关注
专栏目录
数学拓展阅读系列之 著名的雨题和数学推理能力的重要性，数学不是寻找正确答案的艺术，而是理解答案为什么正确的艺术
iCloudEnd的博客
08-16 24
在开始学习数学之前，雨对我来说是一种重要的自然现象。雨一停，我就会跑到街上，把父亲为我做的纸船放在我们街道积水的地方。大学期间，我最喜欢的消遣是在雨中骑自行车。当鸟儿们喝着祖母为它们准备的水桶里的雨水时，我学会了爱它们。在我的生活中，淋雨从来都不是问题。不过，我会时不时地把书藏在夹克里，以免它们被淋湿。很长一段时间里，雨对我来说只是一个快乐的理由。然而，在我上大学的第一年，我的数学教授问了我一个关于雨的问题。在那之后，雨对我来说就成了一个数学方程。问题很简单：在雨中行走的人和在雨中奔跑的人谁会更湿？
人生哲理枕边书——你应该知道的165个人生哲理
ytffhew的博客
11-14 2万+
人生哲理枕边书——你应该知道的165个人生哲理
头脑风暴(一) 三道面试题
GJ_FB_dabai的专栏
03-24 2828
序言: 昨天在酷壳看到三道面试题,发现对趣味性的题热情依然不减啊,突然想起既然有博客了,何不建立一个由面试,趣味,脑筋急转弯类题组成的专题呢~ 头脑风暴,给聪明人看的专题. 每篇文章题目均来自互联网,会标明出处但解题思路绝不照搬.所以标均原创标签了~ 第一季 三道面试题: 在酷壳上看到的三道面试题,发现有两道以前好像做过~最后一道还挺难,顿时来了兴趣了 嗯~ 酷壳:
头脑风暴的练习
weixin_34216036的博客
10-02 1968
头脑风暴法是一种普遍应用的思考工具和方法，正确地使用头脑风暴法可以为我们带来很大的收益。头脑风暴法分为个人头脑风暴法与团队头脑风暴法。团队头脑风暴法是一种利用集体智慧思考和解决问题的团队创新思维方法。下面我们重点讨论个人头脑风暴法的步骤和注意事项，同时对团队头脑风暴法和电子头脑风暴法作出简单介绍。 在理想情况下，头脑风暴法的步骤分为两个独立阶段：第一个阶段是提出想法（...
关于测试的头脑风暴
weixin_33834075的博客
12-03 158
加强测试。 示例数据的批量初始化。 账户数据的批量初始化。 关联数据的批量初始化。 增加单元测试。 增加功能测试。 降低测试对于前端的依赖，将一些数据的操作写成代码，用代码替代前端的点击。 代码维护之后，可以用测试来检验重构是否正确，是否影响原来的逻辑。 用代码以及脚本来创建模拟数据，创建测试专用数据库，然后加入模拟数...
头脑风暴题目及答案精练.doc
10-26
头脑风暴题目及答案精练.doc
头脑风暴－数字逻辑题目
wsk_228的专栏
07-09 5760
1.5，5， 14，38，87，（ ）A.167 B. 168 C.169 D. 170 解题思路：两两之差为0，9，24，49，80即为1的平方-1，3的平方，5的平方-1，7的平方，9的平方-1 所以为87+80=167 2.2/3，1/2，3/7，7/18，（ ）A.5/9 B.4/11 C.3/13 D.2/5 解题思路：4/6，5/10，6/14，7/18，8
单词风暴
03-16
　『单词风暴』正是要建立这种神经反射，在测试中锻炼使用者的快速反应能力，采用一题紧接着一题的学习方式，操作最简化，让使用者专注于背单词本身，积极思维，正真进入头脑风暴状态。从生物学角度，这种反射式的的...
[渝粤教育] 重庆城市管理职业学院 脑洞大开背后的创新思维 参考 资料
渝粤题库
02-25 778
教育 -脑洞大开背后的创新思维-章节资料考试资料-重庆城市管理职业学院【】 第一章·章节测试 1、【单选题】 依照赫曼全脑模型划分，沙和尚属于（ ） A、逻辑型 B、空想型 C、表现型 D、纪律型 参考资料【 】 2、【单选题】以下哪一项不是创新型人才的特点？ A、具有创新精神和创新能力 B、个性灵活、开放 C、力求稳妥，拒绝冒险 D、精力充沛、坚持不懈 参考资料【 】 3、【单选题】创造是指人们首创或改进某种思想、理论、方法、技术和产品的活动。我们可以将人类的创造分为第一创造性和第二创造性
《创新思维与创新能力》在线考试.pdf
12-26
在判断题中，正确的观点包括：逆向思维是创新的重要形式，创新是人类进步的源泉，组合技法是创造新产品的方式，思维特征包括概括性、间接性、逻辑性、深刻性和批判性，而错误的观点包括：头脑风暴小组会议应设主持人...
丹麦人总结的代码优化资料
11-04
一个丹麦人总结的代码优化资料，共5册，包括C++程序的优化，以及内联汇编，intrinsic函数，还有微软处理器架构知识和指令集。是代码优化的好资料。
爱因斯坦谜题的java解答方法
MPU的专栏
06-17 2201
爱因斯坦的推理题：1．有5栋5种颜色的房子2．每一位房子的主人国籍都不同3．这五个人每人只喝一个牌子的饮料，只抽一个牌子的香烟，只养一种宠物4．没有人有相同的宠物，抽相同牌子的烟，喝相同牌子的饮料已知条件：1．英国人住在红房子里2．瑞典人养了一条狗3．丹麦人喝茶4．绿房子在白房子的左边5．绿房子主人喝咖啡6．抽pallmall烟的人养了一只鸟7．黄房子主人抽dunhill烟8．住在中间房子的人喝牛
爱因斯坦题目 完全解
arenascat的博客
08-16 8632
题目： 据说有五个不同颜色的房间排成一排，每个房间里分别住着一个不同国籍的人，每个人都喝一种特定品牌的饮料，抽一种特定品牌的烟，养一种宠物，没有任意两个人抽相同品牌的香烟，或喝相同品牌的饮料，或养相同的宠物。 问题是谁在养鱼作为宠物？为了寻找答案，爱因斯坦给出了以下15条线索。 1. 英国人住在红色的房子里； 2. 瑞典人养狗作为宠物； 3. 丹麦人喝茶； 4. 绿房子紧挨着白房子，在...
浅谈“头脑风暴法”在软件测试中的运用
taozi11Abcd的博客
07-12 1706
文/谭清红 罗章坤   一、 背景 本文立足当前银行业互联网金融软件测试的现状，分析“头脑风暴法”在互联网金融行业软件测试工作中的意义以及软件测试人员可能面临的挑战，指出在软件测试工作中，测试人员如何充分利用自身条件，发挥其积极性、主观能动性和创造性，借助于团队力量，“取人之长补已之短”，使“头脑风暴法”成为大家共同参与、共同学习、共同成长的有效方式，提高软件测试的质量。 二、 “头脑风暴...
C#解决类似爱因斯坦测试题的问题V3.0——10ms级解决方案
我的专栏
10-28 1347
就当是闲得蛋疼吧，此次改进
逻辑训练-爱因斯坦的推理题
随便写写
12-05 1万+
写这个系列的目的是保持大脑思考，不要生锈！ 题目内容如下： 在一个小镇的街上，有五个具有五种不同颜色的房间。每个房间住着一个不同国籍的人；每个人都在喝一种特定的饮料；抽一种特定品牌的香烟；养一种特定的宠物；没有任意两个人在抽相同品牌的烟，或喝相同品牌的饮料、或养相同的宠物。爱因斯坦给出了如下线索： 英国人住在红房子里； 瑞典人养狗； 丹麦人喝茶； 绿房子紧挨着白房子，在白房子的左边； 绿房子主人喝咖啡 抽PM牌香烟的人养鸟； 黄房子里的人抽DH牌香烟； 住中间房子的人喝牛奶 挪威人住在
史上最全的笔面智力题
码农印象
06-03 1万+
一、最基本题型 （说明：此类题型比较简单） 1.烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢？ 答：点两个绳子，一个点一头，一个点两头，当点两头的绳子烧完时将另一个绳子的另一头也点着。直到点完。这样就有45分钟了，找个新绳子从两头点着直到点完（30分钟），这样公共是1小时15分钟了 2.你有一桶果冻，...
面试常见逻辑题小整理
热门推荐
zhusongziye的博客
11-04 7万+
题一、 1 1 1 2 1 1 2 1 1 1 1 1 2 2 1 下一行是什么？ 答案： 312211 题二、 （1）烧一根不均匀的绳要用一个小时，如何用它来判断半个小时？ （2）烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢?  答案：  （1）半小时：两头一起烧 （2）一个小时十五分钟：先取两根绳子，一根从...
谁养鱼（一）：人工解法
weixin_33873846的博客
11-21 468
题目：据说有五个不同颜色的房间排成一排，每个房间里分别住着一个不同国籍的人，每个人都喝 一种特定品牌的饮料，抽一种特定品牌的烟，养一种宠物，没有任意两个人抽相同品牌的香烟，或喝相同品牌的饮料，或养相同的宠物，问题是谁在养鱼作为宠物？ 为了寻找答案，给出了十五条线索： 英国人住在红色的房子里；瑞典人养狗作为宠物；丹麦人喝茶；绿房子紧挨着白房子，在白房子的左边；绿房子的主人喝咖啡；抽Pall...
使用Prolog解决爱因斯坦斑马谜题
实验内容涉及使用Prolog解决著名的“斑马迷题”，这是一个逻辑推理问题，需要根据一系列线索找出特定人物的属性，如他们居住的房子颜色、养的宠物、喜欢的饮品等。实验要求学生下载并运行Prolog软件，进行在线编程，...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值