爱因斯坦谜题:谁养鱼(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,如需转载请自行联系原作者

相关文章
|
6月前
|
开发框架 前端开发 .NET
C#编程与Web开发
【4月更文挑战第21天】本文探讨了C#在Web开发中的应用,包括使用ASP.NET框架、MVC模式、Web API和Entity Framework。C#作为.NET框架的主要语言,结合这些工具,能创建动态、高效的Web应用。实际案例涉及企业级应用、电子商务和社交媒体平台。尽管面临竞争和挑战,但C#在Web开发领域的前景将持续拓展。
183 3
|
6月前
|
SQL 开发框架 安全
C#编程与多线程处理
【4月更文挑战第21天】探索C#多线程处理,提升程序性能与响应性。了解C#中的Thread、Task类及Async/Await关键字,掌握线程同步与安全,实践并发计算、网络服务及UI优化。跟随未来发展趋势,利用C#打造高效应用。
193 3
|
18天前
|
安全 C# 数据安全/隐私保护
实现C#编程文件夹加锁保护
【10月更文挑战第16天】本文介绍了两种用 C# 实现文件夹保护的方法:一是通过设置文件系统权限,阻止普通用户访问;二是使用加密技术,对文件夹中的文件进行加密,防止未授权访问。提供了示例代码和使用方法,适用于不同安全需求的场景。
|
2月前
|
API C#
C# 一分钟浅谈:文件系统编程
在软件开发中,文件系统操作至关重要。本文将带你快速掌握C#中文件系统编程的基础知识,涵盖基本概念、常见问题及解决方法。文章详细介绍了`System.IO`命名空间下的关键类库,并通过示例代码展示了路径处理、异常处理、并发访问等技巧,还提供了异步API和流压缩等高级技巧,帮助你写出更健壮的代码。
37 2
|
2月前
|
SQL 开发框架 安全
并发集合与任务并行库:C#中的高效编程实践
在现代软件开发中,多核处理器普及使多线程编程成为提升性能的关键。然而,传统同步模型在高并发下易引发死锁等问题。为此,.NET Framework引入了任务并行库(TPL)和并发集合,简化并发编程并增强代码可维护性。并发集合允许多线程安全访问,如`ConcurrentQueue&lt;T&gt;`和`ConcurrentDictionary&lt;TKey, TValue&gt;`,有效避免数据不一致。TPL则通过`Task`类实现异步操作,提高开发效率。正确使用这些工具可显著提升程序性能,但也需注意任务取消和异常处理等常见问题。
45 1
|
2月前
|
安全 程序员 编译器
C#一分钟浅谈:泛型编程基础
在现代软件开发中,泛型编程是一项关键技能,它使开发者能够编写类型安全且可重用的代码。C# 自 2.0 版本起支持泛型编程,本文将从基础概念入手,逐步深入探讨 C# 中的泛型,并通过具体实例帮助理解常见问题及其解决方法。泛型通过类型参数替代具体类型,提高了代码复用性和类型安全性,减少了运行时性能开销。文章详细介绍了如何定义泛型类和方法,并讨论了常见的易错点及解决方案,帮助读者更好地掌握这一技术。
61 11
|
2月前
|
安全 数据库连接 API
C#一分钟浅谈:多线程编程入门
在现代软件开发中,多线程编程对于提升程序响应性和执行效率至关重要。本文从基础概念入手,详细探讨了C#中的多线程技术,包括线程创建、管理及常见问题的解决策略,如线程安全、死锁和资源泄露等,并通过具体示例帮助读者理解和应用这些技巧,适合初学者快速掌握C#多线程编程。
74 0