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

最新推荐文章于 2018-11-15 17:44:16 发布
最新推荐文章于 2018-11-15 17:44:16 发布
阅读量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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
头脑风暴题目及答案精练.doc
10-26
头脑风暴题目及答案精练.doc
逻辑训练-爱因斯坦的推理题
随便写写
12-05 1万+
写这个系列的目的是保持大脑思考，不要生锈！ 题目内容如下： 在一个小镇的街上，有五个具有五种不同颜色的房间。每个房间住着一个不同国籍的人；每个人都在喝一种特定的饮料；抽一种特定品牌的香烟；养一种特定的宠物；没有任意两个人在抽相同品牌的烟，或喝相同品牌的饮料、或养相同的宠物。爱因斯坦给出了如下线索： 英国人住在红房子里； 瑞典人养狗； 丹麦人喝茶； 绿房子紧挨着白房子，在白房子的左边； 绿房子主人喝咖啡 抽PM牌香烟的人养鸟； 黄房子里的人抽DH牌香烟； 住中间房子的人喝牛奶 挪威人住在
爱因斯坦题目 完全解
arenascat的博客
08-16 8525
题目： 据说有五个不同颜色的房间排成一排，每个房间里分别住着一个不同国籍的人，每个人都喝一种特定品牌的饮料，抽一种特定品牌的烟，养一种宠物，没有任意两个人抽相同品牌的香烟，或喝相同品牌的饮料，或养相同的宠物。 问题是谁在养鱼作为宠物？为了寻找答案，爱因斯坦给出了以下15条线索。 1. 英国人住在红色的房子里； 2. 瑞典人养狗作为宠物； 3. 丹麦人喝茶； 4. 绿房子紧挨着白房子，在...
爱因斯坦谜题的java解答方法
MPU的专栏
06-17 2187
爱因斯坦的推理题：1．有5栋5种颜色的房子2．每一位房子的主人国籍都不同3．这五个人每人只喝一个牌子的饮料，只抽一个牌子的香烟，只养一种宠物4．没有人有相同的宠物，抽相同牌子的烟，喝相同牌子的饮料已知条件：1．英国人住在红房子里2．瑞典人养了一条狗3．丹麦人喝茶4．绿房子在白房子的左边5．绿房子主人喝咖啡6．抽pallmall烟的人养了一只鸟7．黄房子主人抽dunhill烟8．住在中间房子的人喝牛
史上最全的笔面智力题
码农印象
06-03 1万+
一、最基本题型 （说明：此类题型比较简单） 1.烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢？ 答：点两个绳子，一个点一头，一个点两头，当点两头的绳子烧完时将另一个绳子的另一头也点着。直到点完。这样就有45分钟了，找个新绳子从两头点着直到点完（30分钟），这样公共是1小时15分钟了 2.你有一桶果冻，...
易语言解决爱因斯坦的难题
07-15
《易语言解决爱因斯坦的难题》是一组利用易语言编程解决逻辑推理问题的源代码。易语言，作为中国本土开发的一种编程语言，以其简洁明了的语法特性，深受初学者和业余爱好者的喜爱。本项目针对的是一个著名的逻辑谜题...
易语言源码易语言解决爱因斯坦的难题源码.rar
02-21
易语言源码易语言解决爱因斯坦的难题源码.rar 易语言源码易语言解决爱因斯坦的难题源码.rar 易语言源码易语言解决爱因斯坦的难题源码.rar 易语言源码易语言解决爱因斯坦的难题源码.rar 易语言源码易语言解决...
光电效应同步测试题.doc
08-19
【光电效应方程】光电效应中的一个重要关系式是爱因斯坦的光电效应方程：E_k = hf - W，其中E_k是光电子的最大初动能，h是普朗克常数，f是入射光的频率，W是材料的逸出功。该方程表明，只有当入射光的频率大于材料的...
086 爱因斯坦的数学题 C语言源代码文件
06-02
标题中的“086 爱因斯坦的数学题”暗示了这是一个与数学问题相关的编程挑战，而描述中再次...解码这个“爱因斯坦的数学题”需要理解并运用C语言的这些核心概念，同时也可能需要对数学逻辑和问题解决策略有深刻的理解。
易语言解决爱因斯坦的难题源码
06-07
资源介绍：。　问题：。　在一条街上，有5座房子，喷了5种颜色，每个颜色里的房子里住着不同国籍的人，每个人喝不同的饮料，抽不同的香烟，养不同的宠物，请问谁养鱼？（左图为打乱的排列）。　提示：。...
丹麦人总结的代码优化资料
11-04
一个丹麦人总结的代码优化资料，共5册，包括C++程序的优化，以及内联汇编，intrinsic函数，还有微软处理器架构知识和指令集。是代码优化的好资料。
贴个经典逻辑题
MengBoy的专栏
11-09 1481
1 有五栋五种颜色的房子 　　2 每一位房子的主人国籍都不同 　　3 这五个人每人只喝一种饮料，只抽一种牌子的香烟，只养一种宠物 　　4 没有人有相同的宠物，抽相同牌子的香烟，喝相同的饮料提示：　　1 、英国人住在红房子里　　2 、瑞典人养了一条狗　　3 、丹麦人喝茶　　4 、绿房子在白房子左边　　5 、绿房子主人喝咖啡　　6 、抽PALL MALL烟的人养了一只鸟　　7 、黄房子主人抽DUN
DFS解两道逻辑推理题
陌生人的专栏
11-15 1141
  1 有五栋五种颜色的房子  2 每一位房子的主人国籍都不同  3 这五个人每人只喝一种饮料，只抽一种牌子的香烟，只养一种宠物  4 没有人有相同的宠物，抽相同牌子的香烟，喝相同的饮料  提示：  １　 英国人住在红房子里  ２　 瑞典人养了一条狗  ３　 丹麦人喝茶  ４　 绿房子在白房子左边  ５　 绿房子主人喝咖啡  ６　 抽ＰＡＬＬ　ＭＡＬＬ烟的人养了一只鸟  ７　 黄房子主人抽ＤＵＮ...
头脑风暴(一) 三道面试题
GJ_FB_dabai的专栏
03-24 2792
序言: 昨天在酷壳看到三道面试题,发现对趣味性的题热情依然不减啊,突然想起既然有博客了,何不建立一个由面试,趣味,脑筋急转弯类题组成的专题呢~ 头脑风暴,给聪明人看的专题. 每篇文章题目均来自互联网,会标明出处但解题思路绝不照搬.所以标均原创标签了~ 第一季 三道面试题: 在酷壳上看到的三道面试题,发现有两道以前好像做过~最后一道还挺难,顿时来了兴趣了 嗯~ 酷壳:
面试常见逻辑题小整理
热门推荐
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）一个小时十五分钟：先取两根绳子，一根从...
浅谈“头脑风暴法”在软件测试中的运用
taozi11Abcd的博客
07-12 1661
文/谭清红 罗章坤   一、 背景 本文立足当前银行业互联网金融软件测试的现状，分析“头脑风暴法”在互联网金融行业软件测试工作中的意义以及软件测试人员可能面临的挑战，指出在软件测试工作中，测试人员如何充分利用自身条件，发挥其积极性、主观能动性和创造性，借助于团队力量，“取人之长补已之短”，使“头脑风暴法”成为大家共同参与、共同学习、共同成长的有效方式，提高软件测试的质量。 二、 “头脑风暴...
关于测试的头脑风暴
weixin_33834075的博客
12-03 144
加强测试。 示例数据的批量初始化。 账户数据的批量初始化。 关联数据的批量初始化。 增加单元测试。 增加功能测试。 降低测试对于前端的依赖，将一些数据的操作写成代码，用代码替代前端的点击。 代码维护之后，可以用测试来检验重构是否正确，是否影响原来的逻辑。 用代码以及脚本来创建模拟数据，创建测试专用数据库，然后加入模拟数...
爱因斯坦阶梯编程题c语言
最新发布
11-18
爱因斯坦阶梯编程题是一个经典的编程问题，涉及到C语言的使用。现在，我将用300字来回答这个问题。 在爱因斯坦阶梯编程题中，我们需要根据一些条件来确定背包中不同物体的重量，以及物体之间的关系。根据题目给出的信息，我们可以得出以下结论： 1. 有5个人，他们分别是：爱因斯坦、亚里士多德、阿基米德、笛卡尔、牛顿。他们的职业分别是：物理学家、哲学家、数学家、哲学家、物理学家。 2. 到达顶端之前，只有两个人可以站在阶梯上，并且总是站在爱因斯坦的前面。 3. 笛卡尔的重量比爱因斯坦的轻，但是比数学家的重量要重。 4. 物理学家的重量最重，他的身高比其他所有人都高。 根据以上信息，我们可以得出以下答案： 1. 爱因斯坦是物理学家，且他站在阶梯中间，所以他是第三个上到顶端的人。 2. 由于爱因斯坦的前面只有两个人，所以在他前面的人只能是亚里士多德和阿基米德。 3. 笛卡尔的重量比爱因斯坦轻，但是比数学家重，所以他不能是第一个上到顶端的人。 4. 物理学家的重量最重，所以他不能是最轻的人。 综上所述，根据题目给出的条件，正确的答案是：亚里士多德、阿基米德、爱因斯坦、笛卡尔、牛顿。他们的职业分别是：哲学家、数学家、物理学家、哲学家、物理学家。 以上就是爱因斯坦阶梯编程题的回答。在实际编程中，我们可以使用C语言来实现相关逻辑，通过判断和比较来得到最终的结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值