Java程序实现爱因斯坦逻辑推理题

最新推荐文章于 2022-11-07 15:55:27 发布
最新推荐文章于 2022-11-07 15:55:27 发布 · 951 阅读 · 3
文章标签：

#Java #算法 #J#

我最近是有点闲的,感觉越来越模糊,看不清前方的路,何处何从... ...
无聊...于是做起同事发过来的一道爱因斯坦逻辑推理题.
题目如下:  
    有五个具有五种不同颜色的房间；  
    每个房间里分别住着一个不同国籍的人；  
    每个人都在喝一种特定品牌的饮料，抽一特定品牌的香烟，养一特定的宠物；  
    没有任意两个人在抽相同品牌的香烟，或喝相同品牌的饮料，或养相同的宠物。  
    爱因斯坦给出了如下线索：  
    1．英国人住在红色的房子里；  
    2．瑞典人养狗；  
    3．丹麦人喝茶；  
    4．绿房子紧挨着白房子，在白房子的左边；  
    5．绿房子的主人喝咖啡；    
    6．抽PallMall牌香烟的人养鸟；  
    7．黄色房子里的人抽Dunhill牌香烟；  
    8．住在中间那个房子里的人喝牛奶；  
    9．挪威人住在第一个房子里(最左边)；  
    10．抽Blends香烟的人和养描的人相邻；  
    11．养马的人和抽Dunhill牌香烟的人相邻；  
    12．抽BlueMaster牌香烟的人喝啤酒；  
    13．德国人抽Prince牌香烟；  
    14．挪威人和住蓝房子的人相邻；  
   15．抽Blends香烟的人和喝矿泉水的人相邻；
    问: 谁养鱼?
JAVA程序实现如下:
package einstein;
import java.util.ArrayList;
import java.util.Arrays;
public class Subject {
/**
  * @huanxisu
  */
String[] color;
String[] nationality;
String[] drink;
String[] pet;
String[] cigarette;
ArrayList colors;
ArrayList nationalities;
ArrayList drinks;
ArrayList pets;
ArrayList cigarettes;
boolean flag = false;
// 初始化，为方便将用数字12345分别对应
public Subject() {
  // color = new String[] { "Yellow", "Red", "Green", "White", "Blue" };
  color = new String[] { "1", "2", "3", "4", "5" };
  // nationality = new String[] { "NorWay", "English", "German",
  // "Sweden","Denmark" };
  nationality = new String[] { "1", "2", "3",
    "4","5" };
  // drink = new String[] { "Water", "Tea", "Beer", "Milk", "Coffee" };
  drink = new String[] { "1", "2", "3", "4", "5" };
  // pet = new String[] { "Dog", "Cat", "Bird", "Horse", "Fish" };
   pet = new String[] { "1", "2", "3", "4", "5" };
  // cigarette = new String[] { "PallMall", "DunHill",
  // "Blends","BlueMarster", "Prince" };
   cigarette = new String[] { "1", "2",
     "3","4", "5" };
}
public ArrayList getResult() {
  Arrange a=new Arrange();
  // 颜色，国籍，饮料，宠物，香烟取得各自的全排列。
  colors = (ArrayList) a.arrange(Arrays.asList(color),"",5);
  nationalities = (ArrayList) a.arrange(Arrays.asList(nationality),"",5);
  drinks = (ArrayList)a.arrange(Arrays.asList(drink),"",5);
  pets = (ArrayList) a.arrange(Arrays.asList(pet),"",5);
  cigarettes = (ArrayList)a.arrange(Arrays.asList(cigarette),"",5);
  // Result用来存放答案
  ArrayList Result = new ArrayList();
  // 对各自的全排列每次取一种排列
  String[] s1 = null;
  String[] s2 = null;
  String[] s3 = null;
  String[] s4 = null;
  String[] s5 = null;
  // 五个嵌套的for循环，涵盖所有可能的组合
  for (int i = 0; i < 120; i++) {
   s1 = (String[]) colors.get(i);
   if (!s1[1].equals("5"))// 挪威人住蓝色房子旁边
    continue;
   if (s1[0].equals("3") || s1[1].equals("3")
     || s1[4].equals("3"))// 绿色房子在白色房子的左面
    continue;
   for (int j = 0; j < 120; j++) {
    flag = false;
    s2 = (String[]) nationalities.get(j);
    if (!s2[0].equals("1"))// 挪威人住第一间房子
     continue;
    for (int d1 = 0; d1 < 5; d1++) {
     if (!(s1[d1].equals("2") && s2[d1].equals("2")))// 英国人住在红房子里
     {
      if (d1 == 4) {
       flag = true;
       break;
      }
      continue;
     } else
      break;
    }
    if (flag)
     continue;
    for (int k = 0; k < 120; k++) {
     flag = false;
     s3 = (String[]) drinks.get(k);
     if (s3[0].equals("5") || s3[1].equals("5")
       || s3[4].equals("5"))// 绿房子主人喝咖啡
      continue;
     if (!s3[2].equals("4"))// 住在中间那间房子的人喝牛奶
      continue;
     for (int d2 = 0; d2 < 5; d2++) {
      if (!(s2[d2].equals("5") && s3[d2].equals("2")))// 丹麦人喝茶
      {
       if (d2 == 4) {
        flag = true;
        break;
       }
       continue;
      } else
       break;
     }
     if (flag)
      continue;
     for (int l = 0; l < 120; l++) {
      flag = false;
      s4 = (String[]) pets.get(l);
      for (int d3 = 0; d3 < 5; d3++) {
       if (!(s2[d3].equals("4") && s4[d3]
         .equals("1")))// 瑞典人养了一条狗
       {
        if (d3 == 4) {
         flag = true;
         break;
        }
        continue;
       } else
        break;
      }
      if (flag)
       continue;
      for (int m = 0; m < 120; m++) {
       flag = false;
       s5 = (String[]) cigarettes.get(m);
       for (int d4 = 0; d4 < 5; d4++) {
        if (!(s5[d4].equals("1") && s4[d4]
          .equals("3")))// 抽PallMall烟的人养了一只鸟
        {
         if (d4 == 4) {
          flag = true;
          break;
         }
         continue;
        } else
         break;
       }
       if (flag)
        continue;
       for (int d5 = 0; d5 < 5; d5++) {
        if (!(s1[d5].equals("1") && s5[d5]
          .equals("2")))// 黄房子主人抽DunHill 烟
        {
         if (d5 == 4) {
          flag = true;
          break;
         }
         continue;
        } else
         break;
       }
       if (flag)
        continue;
       for (int d6 = 0; d6 < 5; d6++) {// 抽Blends的人住在养猫人的旁边
        flag = false;
        if (d6 == 0) {
         if (s5[0].equals("3")) {
          if (!s4[1].equals("2")) {
           flag = true;
           break;
          }
          break;
         }
         if (s4[0].equals("2")) {
          if (!s5[1].equals("3")) {
           flag = true;
           break;
          }
          break;
         }
         continue;
        }
        if (d6 > 0 && d6 < 4) {
         if (s5[d6].equals("3")) {
          if (!(s4[d6 - 1].equals("2") || s4[d6 + 1]
            .equals("2"))) {
           flag = true;
           break;
          } else
           break;
         }
         if (s4[d6].equals("2")) {
          if (!(s5[d6 - 1].equals("3") || s5[d6 + 1]
            .equals("3"))) {
           flag = true;
           break;
          } else
           break;
         }
         continue;
        }
        if (d6 == 4) {
         if (s5[4].equals("3")) {
          if (!s4[3].equals("2")) {
           flag = true;
           break;
          }
          break;
         }
         if (s4[4].equals("2")) {
          if (!s5[3].equals("3")) {
           flag = true;
           break;
          }
          break;
         }
         flag = true;
         break;
        }
       }
       System.out.println(flag);
       if (flag)
        continue;
       for (int d7 = 0; d7 < 5; d7++) {
        if (!(s5[d7].equals("4") && s3[d7]
          .equals("3")))// 抽BlueMarster烟的人喝啤酒
        {
         if (d7 == 4) {
          flag = true;
          break;
         }
         continue;
        } else
         break;
       }
       if (flag)
        continue;
       for (int d8 = 0; d8 < 5; d8++) {
        if (!(s2[d8].equals("3") && s5[d8]
          .equals("5")))// 德国人抽Prince烟
        {
         if (d8 == 4) {
          flag = true;
          break;
         }
         continue;
        } else
         break;
       }
       if (flag)
        continue;
       for (int d9 = 0; d9 < 5; d9++) {// 养马人住在DunHill烟的人旁边
        flag = false;
        if (d9 == 0) {
         if (s5[0].equals("2")) {
          if (!s4[1].equals("4")) {
           flag = true;
           break;
          }
          break;
         }
         if (s4[0].equals("4")) {
          if (!s5[1].equals("2")) {
           flag = true;
           break;
          }
          break;
         }
         continue;
        }
        if (d9 > 0 && d9 < 4) {
         if (s5[d9].equals("2")) {
          if (!s4[d9 - 1].equals("4")
            && !s4[d9 + 1].equals("4")) {
           flag = true;
           break;
          } else
           break;
         }
         if (s4[d9].equals("4")) {
          if (!s5[d9 - 1].equals("2")
            && !s5[d9 + 1]
              .equals("2")) {
           flag = true;
           break;
          } else
           break;
         }
         continue;
        }
        if (d9 == 4) {
         if (s5[4].equals("2")) {
          if (!s4[3].equals("4")) {
           flag = true;
           break;
          }
          break;
         }
         if (s4[4].equals("4")) {
          if (!s5[3].equals("2")) {
           flag = true;
           break;
          }
          break;
         }
         flag = true;
         break;
        }
       }
       if (flag)
        continue;
       for (int d10 = 0; d10 < 5; d10++) {// 抽Blends的人的邻居喝矿泉水
        flag = false;
        if (d10 == 0) {
         if (s5[0].equals("3")) {
          if (!s3[1].equals("1")) {
           flag = true;
           break;
          }
          break;
         }
         if (s3[0].equals("1")) {
          if (!s5[1].equals("3")) {
           flag = true;
           break;
          }
          break;
         }
         continue;
        }
        if (d10 > 0 && d10 < 4) {
         if (s5[d10].equals("3")) {
          if (!s3[d10 - 1].equals("1")
            && !s3[d10 + 1].equals("1")) {
           flag = true;
           break;
          } else
           break;
         }
         if (s3[d10].equals("1")) {
          if (!s5[d10 - 1].equals("3")
            && !s5[d10 + 1]
              .equals("3")) {
           flag = true;
           break;
          } else
           break;
         }
         continue;
        }
        if (d10 == 4) {
         if (s5[4].equals("3")) {
          if (!s3[3].equals("1")) {
           flag = true;
           break;
          }
          break;
         }
         if (s3[4].equals("1")) {
          if (!s5[3].equals("3")) {
           flag = true;
           break;
          }
          break;
         }
         flag = true;
         break;
        }
       }
       if (flag)
        continue;
       else {//能到达这里的就是符合所有条件的正确答案
        Result.add(s1);
        Result.add(s2);
        Result.add(s3);
        Result.add(s4);
        Result.add(s5);
        return Result;
       }
      }
     }
    }
   }
  }
  return Result;
}
}
采用递归实现全排列的类(Arrange):
package einstein;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class Arrange {
/**
  * @huanxisu
  */

List allList = new ArrayList();;
//递归实现全排列
public List arrange(List str, String prefix, int length) {
  if (prefix.length() == length) {
   String[] s = new String[] { prefix.substring(0, 1),
     prefix.substring(1, 2), prefix.substring(2, 3),
     prefix.substring(3, 4), prefix.substring(4) };
   allList.add(s);//得到一种排列就添加
  }
  for (int i = 0; i < str.size(); i++) {
   List temp = new LinkedList(str);
   arrange(temp, prefix + temp.remove(i), length);
  }
  return allList;
}
}
测试程序：
package einstein;
import java.util.ArrayList;
import java.util.Date;
public class Test {
/**
  * @huanxisu
  */
public static void main(String[] args) {
  Subject subject = new Subject();
  ArrayList arr = subject.getResult();
  System.out.println(arr.size());
  //将数字替换为之前对应的内容
  String[] s1=(String[])arr.get(0);
  String[] s2=(String[])arr.get(1);
  String[] s3=(String[])arr.get(2);
  String[] s4=(String[])arr.get(3);
  String[] s5=(String[])arr.get(4);
  System.out.print("{");
  for(int i=0;i<5;i++){
   String temp;
   if(s1[i].equals("1"))
    temp="Yellow";
   else if(s1[i].equals("2"))
    temp="Red";
   else if(s1[i].equals("3"))
    temp="Green";
   else if(s1[i].equals("4"))
    temp="White";
   else temp="Blue";
   System.out.print(temp+" ");
  }
  System.out.println("}");
  System.out.print("{");
  for(int i=0;i<5;i++){
   String temp;
   if(s2[i].equals("1"))
    temp="NorWay";
   else if(s2[i].equals("2"))
    temp="English";
   else if(s2[i].equals("3"))
    temp="German";
   else if(s2[i].equals("4"))
    temp="Sweden";
   else temp="Denmark";
   System.out.print(temp+" ");
  }
  System.out.println("}");
  System.out.print("{");
  for(int i=0;i<5;i++){
   String temp;
   if(s3[i].equals("1"))
    temp="Water";
   else if(s3[i].equals("2"))
    temp="Tea";
   else if(s3[i].equals("3"))
    temp="Beer";
   else if(s3[i].equals("4"))
    temp="Milk";
   else temp="Coffee";
   System.out.print(temp+" ");
  }
  System.out.println("}");
  System.out.print("{");
  for(int i=0;i<5;i++){
   String temp;
   if(s4[i].equals("1"))
    temp="Dog";
   else if(s4[i].equals("2"))
    temp="Cat";
   else if(s4[i].equals("3"))
    temp="Bird";
   else if(s4[i].equals("4"))
    temp="Horse";
   else temp="Fish";
   System.out.print(temp+" ");
  }
  System.out.println("}");
  System.out.print("{");
  for(int i=0;i<5;i++){
   String temp;
   if(s5[i].equals("1"))
    temp="PallMall";
   else if(s5[i].equals("2"))
    temp="DunHill";
   else if(s5[i].equals("3"))
    temp="Blends";
   else if(s5[i].equals("4"))
    temp="BlueMarster";
   else temp="Prince";
   System.out.print(temp+" ");
  }
  System.out.println("}");
  /**调试程序，以下输出的结果为数字代替
  for (Object o : arr) {
   System.out.print("{");
   for (String s : (String[]) o) {
    System.out.print(s + " ");
   }
   System.out.println("}");
  }
  */
}
}
运行Test测试程序，结果如下：
{Yellow Blue Red Green White }
{NorWay Denmark English German Sweden }
{Water Tea Milk Coffee Beer }
{Cat Horse Bird Fish Dog }
{DunHill Blends PallMall Prince BlueMarster }
当然，这不是性能最好的程序，希望发现不足的地方可以互相学习。

xinjiangxixi
关注
爱因斯坦的思考题Java语言求解
03-09 1184
题目是这样的，有五个不同颜色的房间排成一排，每个房间里分别住着一个不同国籍的人，每个人都喝一种特定品牌的饮料，抽一种特定品牌的烟，养一种宠物。没有任意两个人的任意属性值是相同的。问：是谁在养鱼？ 下面是给出的15条线索。 英国人住在红色的房子里； 瑞典人养狗作为宠物； 丹麦人喝茶； 绿房子紧挨着白房子，在白房子的左边； 绿房子的主人喝咖啡； 抽Pall Mall牌香烟的人养鸟； 黄色房子里的人抽Du
java逻辑面试题_java学习必备——java逻辑推理面试题
weixin_39611174的博客
02-15 2252
准备参加面试的java程序员，在搜集java面试题的时候，一定会看到java逻辑推理面试题的相关资料。对于java语言，除了要学习框架、数据库和开发工具等方面的技术，还要有一定的思维逻辑能力，因为有这样理性逻辑思想的人，会更加适合学java编程，学起来会更得心应手一些。所以这篇文章也总结了一些java逻辑推理面试题，大家可以自测学习一下自己的逻辑思维怎么样。1、对一批编号为1~100 全部开关朝上...
爱因斯坦谜题的java解答方法
MPU的专栏
06-17 2322
爱因斯坦的推理题：1．有5栋5种颜色的房子2．每一位房子的主人国籍都不同3．这五个人每人只喝一个牌子的饮料，只抽一个牌子的香烟，只养一种宠物4．没有人有相同的宠物，抽相同牌子的烟，喝相同牌子的饮料已知条件：1．英国人住在红房子里2．瑞典人养了一条狗3．丹麦人喝茶4．绿房子在白房子的左边5．绿房子主人喝咖啡6．抽pallmall烟的人养了一只鸟7．黄房子主人抽dunhill烟8．住在中间房子的人喝牛
java实现逻辑推断
南 墙
07-25 1万+
A、B、C、D、E、F、G、H、I、J 共10名学生有可能参加本次计算机竞赛，也可能不参加。因为某种原因，他们是否参赛受到下列条件的约束： 如果A参加，B也参加； 如果C不参加，D也不参加； A和C中只能有一个人参加； B和D中有且仅有一个人参加； D、E、F、G、H 中至少有2人参加； C和G或者都参加，或者都不参加； C、E、G、I中至多只能2人参加 如果E参加，那么F和G也都参加。 如果F...
爱因斯坦经典逻辑推理题
m0_51130623的博客
11-07 2720
爱因斯坦经典逻辑推理题
JAVA—— 运用ArrayList实现逻辑推理题（谁养鱼）
Atishoo_13的博客
10-18 988
运用ArrayList实现逻辑推理题（谁养鱼） 1.穷举法 穷举法的基本思想是根据题目的部分条件确定答案的大致范围，并在此范围内对所有可能的情况逐一验证，直到全部情况验证完毕。若某个情况验证符合题目的全部条件，则为本问题的一个解；若全部情况验证后都不符合题目的全部条件，则本题无解。 2.谁养鱼 穷举的速度比用笔还慢，《谁养鱼》是爱因斯坦在20世纪初出的谜语，他说世界上有百分之98的人答不出来。你...
爱因斯坦棋
07-16
"爱因斯坦棋"是一种基于策略的棋类游戏，它由阿尔伯特·爱因斯坦在20世纪初设计，旨在展示逻辑思考的重要性。在这个游戏中，两名玩家通过移除棋盘上的棋子来竞争，目标是使对手无法进行合法移动。尽管游戏规则简单，...
高级语言程序设计习题精选：挑战100题
1. **基本算法** - 如求最大数、数制转换、计算速度等，这些都是程序设计基础，涉及到数据处理和逻辑推理。 2. **数据结构** - 杨辉三角形涉及到二维数组的处理，出售金鱼或平分七筐鱼可能需要链表或集合的概念来...
爱因斯坦经典智力题解谜程序
爱因斯坦的智力题，又称“爱因斯坦的谜题”或“斑马谜题”，是一道经典的逻辑推理题，旨在通过一系列的逻辑推断来找出街道上不同房子的居住者、房子颜色、国籍、饮料偏好、香烟品牌以及宠物种类等信息。这个问题涉及...
Java实现斑马拼图解题指南
资源摘要信息:"zebra-puzzle" 斑马拼图，也被称为"斑马谜题"或"Einstein's Riddle"（爱因斯坦的谜题），是一个经典的...这个程序可能包含逻辑推理的算法，能够处理一系列的逻辑条件，最终以XML形式输出拼图的答案。
JAVA运用ArrayList实现逻辑推理题（谁养鱼）
10-18
使用JAVA语言中的ArrayList解决爱因斯坦在20世纪初出的逻辑推理题——《谁养鱼》，在一条街上有5座房子，喷了5种颜色。每个房子里住着不同国籍的人。每个人喝不同的饮料，抽不同品牌的香烟，养不同的宠物。问谁养的是鱼？ 所列举项应该满足如下要求：英国人住红色房子；瑞典人养狗；丹麦人喝茶；绿色房子在白色房子左边；绿色房子主人喝咖啡；抽PalMal香烟的人养鸟；黄色房子主人抽Dunhill香烟；住在中间房子的人喝牛奶；挪威人住第一间房；抽Blends香烟的人住在养猫的人隔壁；养马的人住抽Dunhill香烟的人隔壁；抽BlMt的人喝啤酒；德国人抽Prince香烟；挪威人住蓝色房子隔壁；抽Blends香烟的人有一个喝水的邻居。
爱因斯坦问题（推理题）
06-04
爱因斯坦问题是开发大脑的一个益智题，很有意思，感兴趣的朋友可以下来试着做一下，考推理的
50道经典Java逻辑题
03-23
Java笔试屡屡败在排序算法上面，多多练习多多进步。offer快来
经典面试宝典 包含各类题型java ＋逻辑推理
03-04
用于面试测试，适用于java开发程序员，对各类题型都有总结。
利用 Java 程序来推理『到底谁会来参加会议？』
z544912284的博客
03-20 395
各位小伙伴准备好了吗?那么开始我们今天的分享吧~上一次娜娜被一道入门级的逻辑推理题虐的死去活来，回去之后真的是气的不行不行的。看到了很多小伙伴的留言，表示和娜娜的情况是一样的。娜娜立志要带领小伙伴们学好 java ，怎能被这些题目打到，所以今天娜娜和大家一起来做一道逻辑推理题，锻炼一下思维如何？请看题:有人邀请 A,B,C,D,E,F 6个人参加一项会议，这6个人有些奇怪，因为他们有很多要求，已知...
java逻辑题_Java蓝桥杯——逻辑推理练习题
weixin_34008445的博客
02-12 817
逻辑推理题谁是贼？公安人员审问四名窃贼嫌疑犯。已知，这四人当中仅有一名是窃贼，还知道这四人中每人要么是诚实的，要么总是说谎。在回答公安人员的问题中：甲说：“乙没有偷，是丁偷的。”乙说：“我没有偷，是丙偷的。”丙说：“甲没有偷，是乙偷的。”丁说：“我没有偷”请根据这四人的谈话判断谁是盗窃者*问题分析假设A、B、C、D分别代表四个人1代表该人是窃贼；0代表不是贼甲 A乙 B丙 C丁 D甲 A01乙 B...
java 类型推理_Java中的类型推断和lambda表达式
weixin_33324007的博客
02-13 238
简介java是强类型的编程语言，每个java中使用到的变量都需要定义它的类型，否则会编译失败。强类型语言的好处就是可以尽可能的在编译期间就发现代码中可能出现的问题，从而减少在运行时出现问题的可能性。相对的，强类型语言的缺点就是不那么的灵活多变，写起来比较冗余。JDK8之前，java是不支持类型推断的，在JDK8中，引入了lambda表达式，从此类型推断产生了。本文将会讲解类型推断在lambda表达...
算法_数学问题_Question7_爱因斯坦的数学问题（爬梯子java实现）
叶清逸的博客
07-07 1040
这篇文章讲述的是算法初级部分的爱因斯坦的数学问题的java实现，参考的书籍为清华大学出版社出版，贾蓓等编著的《c语言趣味编程1000例》，如有错误或者不当之处，还望各位大神批评指正。 问题描述 爱因斯坦出了一道这样的数学题：有一条长阶梯，若每步垮2阶，最后剩1阶，若每步垮3阶，最后剩两阶，若每步垮5阶，则最后剩4阶，若每步垮6阶最后剩5阶。只有每次垮7阶时，最后才正好一阶不剩。请问在1~N内，...
逻辑训练-爱因斯坦的推理题
热门推荐
随便写写
12-05 1万+
写这个系列的目的是保持大脑思考，不要生锈！ 题目内容如下： 在一个小镇的街上，有五个具有五种不同颜色的房间。每个房间住着一个不同国籍的人；每个人都在喝一种特定的饮料；抽一种特定品牌的香烟；养一种特定的宠物；没有任意两个人在抽相同品牌的烟，或喝相同品牌的饮料、或养相同的宠物。爱因斯坦给出了如下线索： 英国人住在红房子里； 瑞典人养狗； 丹麦人喝茶； 绿房子紧挨着白房子，在白房子的左边； 绿房子主人喝咖啡 抽PM牌香烟的人养鸟； 黄房子里的人抽DH牌香烟； 住中间房子的人喝牛奶 挪威人住在
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值