爱因斯坦谜题:谁养鱼(C#版)续二

简介:

 
 
  1. //http://yfsoft.blog.51cto.com   
  2. #define FastCompute          
  3. using System;     
  4. using System.Collections.Generic;     
  5. using System.ComponentModel;     
  6. using System.Data;     
  7. using System.Drawing;     
  8. using System.Text;     
  9. using System.Windows.Forms;     
  10. using System.Diagnostics;         
  11.     
  12. namespace Einstein     
  13. {     
  14.     public partial class frmMain : Form     
  15.     {     
  16.         public frmMain()     
  17.         {     
  18.             InitializeComponent();     
  19.         }     
  20.     
  21.         private void btnRun_Click(object sender, EventArgs e)     
  22.         {                                                       
  23.             Arithmetic arithmetic = new Arithmetic();           
  24.             DateTime dt = DateTime.Now;     
  25.             string  result = arithmetic.DoResult();     
  26.             MessageBox.Show(result + "\r\n耗时:" + (DateTime.Now - dt).TotalSeconds.ToString() + "秒");     
  27.         }                
  28.     }     
  29.     
  30.     public class Arithmetic     
  31.     {     
  32.         string[] people   = new string[] { "英国""瑞典""丹麦""挪威""德国" };     
  33.         string[] house = new string[] { "红""绿""白""黄""蓝" };     
  34.         string[] drink = new string[] { "茶""咖啡""牛奶""啤酒""水" };     
  35.         string[] smoke = new string[] { "Pall Mall""Dunhill""Blends""Blue Master""Prince" };     
  36.         string[] pet = new string[] { "狗""鸟""猫""马""鱼" };     
  37.     
  38.         List<string[]> lstCombination = new List<string[]>();   //存放全部结果(预删减后的结果)     
  39.         List<string[]> lstCombination0 = new List<string[]>();     
  40.         List<string[]> lstCombination1 = new List<string[]>();     
  41.         List<string[]> lstCombination2 = new List<string[]>();     
  42.         List<string[]> lstCombination3 = new List<string[]>();     
  43.         List<string[]> lstCombination4 = new List<string[]>();     
  44.                                    
  45.         public string DoResult()     
  46.         {     
  47.             string[,] result = new string[5, 5];     
  48.     
  49.             //生成全部的组合     
  50.             MakeCombination();     
  51.             //预剔除不符合条件的组合     
  52.             EliminateCombination();     
  53.             //获得有可能的组合0     
  54.             EliminateCombination0();     
  55.             //获得有可能的组合1     
  56.             EliminateCombination1();     
  57.             //获得有可能的组合2     
  58.             EliminateCombination2();     
  59.             //获得有可能的组合3     
  60.             EliminateCombination3();     
  61.             //获得有可能的组合4     
  62.             EliminateCombination4();     
  63.     
  64.             string strInfo = "";     
  65.             int intNum = 0;     
  66.     
  67.             for (int i = 0; i < lstCombination0.Count; i++)         
  68.             {     
  69.                 ToCombination(result, 0, lstCombination0,i);     
  70.                 for (int j =0; j < lstCombination1.Count; j++)       
  71.                 {     
  72.                     ToCombination(result, 1, lstCombination1,j);     
  73.                     for (int k = 0; k < lstCombination2.Count; k++)      
  74.                     {     
  75.                         ToCombination(result,  2,lstCombination2, k);     
  76.                         for (int l =0; l < lstCombination3.Count; l++)       
  77.                         {     
  78.                             ToCombination(result,  3,lstCombination3, l);     
  79.                             for (int m =0; m < lstCombination4.Count; m++)      
  80.                             {     
  81.                                 ToCombination(result, 4,lstCombination4, m);     
  82.     
  83.                                 bool Flag=true;     
  84.                                 for (int e = 0; e < 5; e++)     
  85.                                 {     
  86.                                     if (result[0, e] == result[1, e] || result[0, e] == result[2, e] || result[0, e] == result[3, e] || result[0, e] == result[4, e] ||     
  87.                                         result[1, e] == result[2, e] || result[1, e] == result[3, e] || result[1, e] == result[4, e] ||     
  88.                                         result[2, e] == result[3, e] || result[2, e] == result[4, e] ||     
  89.                                         result[3, e] == result[4, e])     
  90.                                     {     
  91.                                         Flag = false;     
  92.                                         break;     
  93.                                     }     
  94.                                 }     
  95.        
  96.                                 //判断组合是否成立     
  97.                                 if (Flag && Judge(result))     
  98.                                 {     
  99.                                     strInfo += "---------------- " + (++intNum).ToString()+" ----------------\r\n";     
  100.                                     for (int ii = 0; ii < 5; ii++)     
  101.                                     {     
  102.                                         for (int jj = 0; jj < 5; jj++)     
  103.                                         {     
  104.                                             strInfo += result[ii, jj] + " ";     
  105.                                         }     
  106.                                         strInfo += "\r\n";     
  107.                                     }     
  108. #if FastCompute     
  109.                                     strInfo += "------------------------------------\r\n";     
  110.                                     return strInfo;     
  111. #endif     
  112.                                 }     
  113.                             }     
  114.                         }     
  115.                     }     
  116.                 }     
  117.             }     
  118.     
  119.             strInfo += "------------------------------------\r\n";     
  120.             return strInfo;                
  121.         }     
  122.     
  123.         private void ToCombination(string[,] result,int index, List<string[]>  lst,int num)     
  124.         {     
  125.             for (int i = 0; i < 5; i++)     
  126.             {     
  127.                 result[index, i] = lst[num][i];     
  128.             }     
  129.         }     
  130.     
  131.         //生成全部的组合     
  132.         private void MakeCombination()     
  133.         {     
  134.             string[] combination = new string[5];     
  135.     
  136.             //5*5*5*5*5=3125     
  137.             for (int i = 0; i < 5; i++) //国籍     
  138.             {     
  139.                 combination[0] = people[i];     
  140.                 for (int j = 0; j < 5; j++)  //房子     
  141.                 {     
  142.                     combination[1] = house[j];     
  143.                     for (int k = 0; k < 5; k++)  //饮料     
  144.                     {     
  145.                         combination[2] = drink[k];     
  146.                         for (int l = 0; l < 5; l++)  //香烟     
  147.                         {     
  148.                             combination[3] = smoke[l];     
  149.                             for (int m = 0; m < 5; m++)  //宠物     
  150.                             {     
  151.                                 combination[4] = pet[m];     
  152.                                 lstCombination.Add((string[])combination.Clone());     
  153.                             }     
  154.                         }     
  155.                     }     
  156.                 }     
  157.             }     
  158.         }     
  159.     
  160.         //剔除组合的判断条件     
  161.         private bool JudgeCombination(string[] combination)     
  162.         {     
  163.             //1、英国住红房子     
  164.             if (combination[0] == "英国" && combination[1] != "红"return false;     
  165.             //2、瑞典养狗     
  166.             if (combination[0] == "瑞典" && combination[4] != "狗"return false;     
  167.             //3、丹麦喝茶     
  168.             if (combination[0] == "丹麦" && combination[2] != "茶"return false;     
  169.             //5、绿房子主喝咖啡     
  170.             if (combination[1] == "绿" && combination[2] != "咖啡"return false;     
  171.             //6、抽Pall Mall香烟的养鸟     
  172.             if (combination[3] == "Pall Mall" && combination[4] != "鸟"return false;     
  173.             //7、黄房子主抽Dunhill香烟     
  174.             if (combination[1] == "黄" && combination[3] != "Dunhill"return false;     
  175.             //12、抽Blue Master的喝啤酒     
  176.             if (combination[3] == "Blue Master" && combination[2] != "啤酒"return false;     
  177.             //13、德国抽Prince香烟     
  178.             if (combination[0] == "德国" && combination[3] != "Prince"return false;     
  179.             return true;     
  180.         }     
  181.     
  182.         //预剔除不符合条件的组合     
  183.         private void EliminateCombination()     
  184.         {     
  185.             string[] combination=new string[5];     
  186.             int num=lstCombination.Count;     
  187.             int index = 0;     
  188.             while ((num--)>0)     
  189.             {     
  190.                 if (!JudgeCombination(lstCombination[index]))     
  191.                 {     
  192.                     lstCombination.RemoveAt(index);     
  193.                 }     
  194.                 else    
  195.                 {     
  196.                     index++;     
  197.                 }                     
  198.             }     
  199.         }     
  200.     
  201.         //创建组合0     
  202.         private void EliminateCombination0()     
  203.         {     
  204.             lstCombination0.Clear();      
  205.             foreach (string[] combination in lstCombination)     
  206.             {     
  207.                 //combination[1] != "红" && combination[1] != "蓝" && combination[1] != "白" && combination[1] != "绿"     
  208. #if FastCompute     
  209.                 if (combination[0] == "挪威" && combination[1] == "黄" && combination[2] != "牛奶" && combination[2] != "茶" && combination[3] != "Prince" && combination[4] != "狗")     
  210. #else     
  211.                 if (combination[0] == "挪威" && combination[1] != "红" && combination[1] != "蓝" && combination[1] != "白"  && combination[2] != "牛奶" && combination[2] != "茶" && combination[3] != "Prince" && combination[4] != "狗")     
  212. #endif     
  213.                 {               
  214.                     lstCombination0.Add(combination);     
  215.                 }                                                                            
  216.             }         
  217.         }     
  218.     
  219.         //创建组合1     
  220.         private void EliminateCombination1()     
  221.         {     
  222.             lstCombination1.Clear();     
  223.             foreach (string[] combination in lstCombination)     
  224.             {     
  225.                 if (combination[0] != "挪威" &&  combination[1] == "蓝" && combination[2] != "牛奶")     
  226.                 {     
  227.                     lstCombination1.Add(combination);     
  228.                 }     
  229.             }     
  230.         }     
  231.     
  232.         //创建组合2     
  233.         private void EliminateCombination2()     
  234.         {     
  235.             lstCombination2.Clear();     
  236.             foreach (string[] combination in lstCombination)     
  237.             {     
  238. #if FastCompute     
  239.                 if (combination[0] != "挪威" && combination[0] != "丹麦" && combination[1] != "蓝" && combination[1] != "黄" && combination[1] != "白" && combination[2] == "牛奶")     
  240. #else                    
  241.                 if (combination[0] != "挪威" && combination[0] != "丹麦" && combination[1] != "蓝"  && combination[2] == "牛奶")     
  242. #endif     
  243.                 {     
  244.                     lstCombination2.Add(combination);     
  245.                 }     
  246.             }     
  247.         }     
  248.     
  249.         //创建组合3     
  250.         private void EliminateCombination3()     
  251.         {     
  252.             lstCombination3.Clear();     
  253.             foreach (string[] combination in lstCombination)     
  254.             {     
  255. #if FastCompute     
  256.                 if (combination[0] != "挪威" && combination[1] != "黄" && combination[1] != "蓝" && combination[2] != "牛奶")     
  257. #else     
  258.                 if (combination[0] != "挪威" && combination[1] != "蓝" && combination[2] != "牛奶")     
  259. #endif     
  260.                 {     
  261.                     lstCombination3.Add(combination);     
  262.                 }     
  263.             }     
  264.         }     
  265.     
  266.         //创建组合4     
  267.         private void EliminateCombination4()     
  268.         {     
  269.             lstCombination4.Clear();     
  270.             foreach (string[] combination in lstCombination)     
  271.             {     
  272. #if FastCompute     
  273.                 if (combination[0] != "挪威" && combination[1] != "黄" && combination[1] != "蓝" && combination[1] != "绿" && combination[2] != "牛奶")     
  274. #else                    
  275.                 if (combination[0] != "挪威" && combination[1] != "蓝" && combination[1] != "绿" && combination[2] != "牛奶")     
  276. #endif     
  277.                 {     
  278.                     lstCombination4.Add(combination);     
  279.                 }     
  280.             }     
  281.         }     
  282.           
  283.         //判断     
  284.         private static bool Judge(string[,] combination)     
  285.         {                
  286.             for (int index = 0;index < 5; index++)     
  287.             {     
  288.                 //4、绿房子在白房子左面     
  289. #if FastCompute     
  290.                 if (index > 0 && combination[index, 1] == "白" && combination[index - 1, 1] != "绿"return false;     
  291. #else     
  292.                 if (combination[index, 1] == "白")     
  293.                 {     
  294.                     for (int i = index + 1; i < 5; i++)     
  295.                     {     
  296.                         if (combination[i, 1] == "绿")  //绿房子不可能出现在白房子的右边     
  297.                             return false;     
  298.                     }      
  299.                 }     
  300. #endif             
  301.                 //8、住在中间的喝牛奶     
  302.                 if (combination[2, 2] != "牛奶"return false;     
  303.                 //9、挪威住第一间房     
  304.                 if (combination[0, 0] != "挪威"return false;     
  305.                 //10、抽Blends香烟的住在养猫的隔壁     
  306.                 if (combination[index, 3] == "Blends")     
  307.                 {     
  308.                     if(!((index>0 && combination[index-1,4]=="猫") || (index<4 && combination[index+1,4]=="猫")))     
  309.                     {     
  310.                          return false;     
  311.                     }     
  312.                 }     
  313.                 //11、养马住在抽Dunhill香烟的隔壁     
  314.                 if (combination[index, 4] == "马")     
  315.                 {     
  316.                     if (!((index > 0 && combination[index - 1, 3] == "Dunhill") || (index < 4 && combination[index + 1, 3] == "Dunhill")))     
  317.                     {     
  318.                         return false;     
  319.                     }     
  320.                 }     
  321.                 //14、挪威住蓝房子隔壁     
  322.                 if (combination[index, 0] == "挪威")     
  323.                 {     
  324.                     if (!((index > 0 && combination[index - 1, 1] == "蓝") || (index < 4 && combination[index + 1, 1] == "蓝")))     
  325.                     {     
  326.                         return false;     
  327.                     }     
  328.                 }     
  329.                 //15、抽Blends香烟的人有一个喝水的邻居     
  330.                 if (combination[index, 3] == "Blends")     
  331.                 {     
  332.                     if (!((index > 0 && combination[index - 1, 2] == "水") || (index < 4 && combination[index + 1, 2] == "水")))     
  333.                     {     
  334.                         return false;     
  335.                     }     
  336.                 }     
  337.             }              
  338.     
  339.             return true;     
  340.         }     
  341.     
  342.     }     
  343. }     
  344.     

 












本文转自yefanqiu51CTO博客,原文链接:http://blog.51cto.com/yfsoft/323419,如需转载请自行联系原作者

相关文章
|
20天前
|
开发框架 前端开发 .NET
C#编程与Web开发
【4月更文挑战第21天】本文探讨了C#在Web开发中的应用,包括使用ASP.NET框架、MVC模式、Web API和Entity Framework。C#作为.NET框架的主要语言,结合这些工具,能创建动态、高效的Web应用。实际案例涉及企业级应用、电子商务和社交媒体平台。尽管面临竞争和挑战,但C#在Web开发领域的前景将持续拓展。
|
20天前
|
SQL 开发框架 安全
C#编程与多线程处理
【4月更文挑战第21天】探索C#多线程处理,提升程序性能与响应性。了解C#中的Thread、Task类及Async/Await关键字,掌握线程同步与安全,实践并发计算、网络服务及UI优化。跟随未来发展趋势,利用C#打造高效应用。
|
20天前
|
存储 安全 网络安全
C#编程的安全性与加密技术
【4月更文挑战第21天】C#在.NET框架支持下,以其面向对象和高级特性成为安全软件开发的利器。本文探讨C#在安全加密领域的应用,包括使用System.Security.Cryptography库实现加密算法,利用SSL/TLS保障网络传输安全,进行身份验证,并强调编写安全代码的重要性。实际案例涵盖在线支付、企业应用和文件加密,展示了C#在应对安全挑战的同时,不断拓展其在该领域的潜力和未来前景。
|
20天前
|
人工智能 C# 开发者
C#编程中的图形界面设计
【4月更文挑战第21天】本文探讨了C#在GUI设计中的应用,介绍了Windows Forms、WPF和UWP等常用框架,强调了简洁界面、响应式设计和数据绑定等最佳实践。通过实际案例,展示了C#在企业应用、游戏开发和移动应用中的GUI实现。随着技术发展,C#在GUI设计的未来将趋向于跨平台、更丰富的组件和AI集成,为开发者创造更多可能性。
|
20天前
|
存储 算法 C#
C#编程与数据结构的结合
【4月更文挑战第21天】本文探讨了C#如何结合数据结构以构建高效软件,强调数据结构在C#中的重要性。C#作为面向对象的编程语言,提供内置数据结构如List、Array和Dictionary,同时也支持自定义数据结构。文章列举了C#实现数组、链表、栈、队列等基础数据结构的示例,并讨论了它们在排序、图算法和数据库访问等场景的应用。掌握C#数据结构有助于编写高性能、可维护的代码。
|
20天前
|
开发框架 Linux C#
C#编程的跨平台应用
【4月更文挑战第21天】C#与.NET Core的结合使得跨平台应用开发变得高效便捷,提供统一编程模型和高性能。丰富的类库、活跃的社区支持及Visual Studio Code、Xamarin等工具强化了其优势。广泛应用在企业系统、云服务和游戏开发中,虽面临挑战,但随着技术进步,C#在跨平台开发领域的前景广阔。
|
20天前
|
人工智能 C# 云计算
C#编程的未来发展趋向
【4月更文挑战第21天】C#编程未来将深化跨平台支持,强化云计算与容器技术集成,如.NET Core、Docker。在AI和ML领域,C#将提供更丰富框架,与AI芯片集成。语言和工具将持续创新,优化异步编程,如Task、async和await,提升多核性能。开源生态的壮大将吸引更多开发者,共创更多机遇。
|
20天前
|
程序员 C#
C#编程中的面向对象编程思想
【4月更文挑战第21天】本文探讨了C#中的面向对象编程,包括类、对象、封装、继承和多态。类是对象的抽象,定义属性和行为;对象是类的实例。封装隐藏内部细节,只暴露必要接口。继承允许类复用和扩展属性与行为,而多态使不同类的对象能通过相同接口调用方法。C#通过访问修饰符实现封装,使用虚方法和抽象方法实现多态。理解并应用这些概念,能提升代码的清晰度和可扩展性,助你成为更好的C#程序员。