C# 24点游戏求解算法

经常跟儿子玩24点，有时候比较难算的，算一会儿，两人算不出来，就收了，当作没法算。

以我的数学能力，一般来说，算不出来的，大概率确实是算不出来的。

但是遇到比较变态的，当作算不出来是可能的，所以一直想找一个直接能解24点的程序。

可是网上找了一圈，一直没找到。

想着自己写一个，可是这里面的逻辑一直理不清楚，不知道这个算法应该怎么写。

下午坐在电脑前面想的时候，不知道为啥，像是突然开窍了。写着写着居然写出来了。

贴出来供有兴趣的朋友参考，有问题请指正。

using System;
using System.Collections.Generic;
using System.Diagnostics;
 
namespace Calc24Point
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var items = CalcHelper.CalcResult(3, 3, 8, 8);
            foreach (var item in items)
            {
                Console.WriteLine(item);
            }
 
            Console.ReadKey();
        }
    }
 
    public class CalcHelper
    {
        public static List<string> CalcResult(double a, double b, double c, double d)
        {
            List<string> myList = new List<string>();
            List<CalcInfo> items = MakeCalcs(a, b, c, d);
            foreach (var item in items)
            {
                var result = item.GetResult();
                if (double.IsNaN(result) == false && IsEqual(result, 24))
                {
                    var text = item.GetString();
                    if (myList.Contains(text) == false)
                    {
                        myList.Add(text);
                    }
                }
            }
 
            return myList;
        }
 
        private static bool IsEqual(double a, double b)
        {
            return Math.Abs(a - b) < 0.000001;
        }
 
        private static List<CalcInfo> MakeCalcs(double a, double b, double c, double d)
        {
            var items = new List<CalcInfo>();
            items.AddRange(MakeCalcs(a, (b, c, d)));
            items.AddRange(MakeCalcs(b, (a, c, d)));
            items.AddRange(MakeCalcs(c, (b, a, d)));
            items.AddRange(MakeCalcs(d, (b, c, a)));
 
            return items;
        }
 
        private static IEnumerable<CalcInfo> MakeCalcs(double item1, (double b, double c, double d) p)
        {
            foreach (CalcInfo item2 in MakeCalcs(p.b, (p.c, p.d)))
            {
                yield return new CalcInfo(item1, item2, EMode.加);
                yield return new CalcInfo(item1, item2, EMode.减);
                yield return new CalcInfo(item2, item1, EMode.减);
                yield return new CalcInfo(item1, item2, EMode.乘);
                yield return new CalcInfo(item1, item2, EMode.除);
                yield return new CalcInfo(item2, item1, EMode.除);
            }
 
            foreach (CalcInfo item2 in MakeCalcs(p.c, (p.b, p.d)))
            {
                yield return new CalcInfo(item1, item2, EMode.加);
                yield return new CalcInfo(item1, item2, EMode.减);
                yield return new CalcInfo(item2, item1, EMode.减);
                yield return new CalcInfo(item1, item2, EMode.乘);
                yield return new CalcInfo(item1, item2, EMode.除);
                yield return new CalcInfo(item2, item1, EMode.除);
            }
 
            foreach (CalcInfo item2 in MakeCalcs(p.d, (p.b, p.c)))
            {
                yield return new CalcInfo(item1, item2, EMode.加);
                yield return new CalcInfo(item1, item2, EMode.减);
                yield return new CalcInfo(item2, item1, EMode.减);
                yield return new CalcInfo(item1, item2, EMode.乘);
                yield return new CalcInfo(item1, item2, EMode.除);
                yield return new CalcInfo(item2, item1, EMode.除);
            }
        }
 
        private static IEnumerable<CalcInfo> MakeCalcs(double item1, (double c, double d) p)
        {
            foreach (CalcInfo item2 in MakeCalcs(p.c, p.d))
            {
                yield return new CalcInfo(item1, item2, EMode.加);
                yield return new CalcInfo(item1, item2, EMode.减);
                yield return new CalcInfo(item2, item1, EMode.减);
                yield return new CalcInfo(item1, item2, EMode.乘);
                yield return new CalcInfo(item1, item2, EMode.除);
                yield return new CalcInfo(item2, item1, EMode.除);
            }
        }
 
        private static IEnumerable<CalcInfo> MakeCalcs(double item1, double item2)
        {
            yield return new CalcInfo(item1, item2, EMode.加);
            yield return new CalcInfo(item1, item2, EMode.减);
            yield return new CalcInfo(item2, item1, EMode.减);
            yield return new CalcInfo(item1, item2, EMode.乘);
            yield return new CalcInfo(item1, item2, EMode.除);
            yield return new CalcInfo(item2, item1, EMode.除);
        }
    }
 
    public class CalcInfo
    {
        public CalcInfo Items1 { get; set; }
        public CalcInfo Items2 { get; set; }
        public EMode? Mode { get; set; }
        public double Result { get; set; }
 
        public CalcInfo(double value)
        {
            Result = value;
        }
 
        public CalcInfo(double value1, double value2, EMode mode) : this(new CalcInfo(value1), new CalcInfo(value2), mode)
        {
        }
 
        public CalcInfo(double value1, CalcInfo value2, EMode mode) : this(new CalcInfo(value1), value2, mode)
        {
        }
 
        public CalcInfo(CalcInfo value1, double value2, EMode mode) : this(value1, new CalcInfo(value2), mode)
        {
        }
 
        public CalcInfo(CalcInfo value1, CalcInfo value2, EMode mode)
        {
            Items1 = value1;
            Items2 = value2;
            Mode = mode;
        }
 
        public double GetResult()
        {
            if (Mode == null)
            {
                return Result;
            }
 
            var item1 = Items1.GetResult();
            var item2 = Items2.GetResult();
            if (double.IsNaN(item1) || double.IsNaN(item1))
            {
                return double.NaN;
            }
 
            switch (Mode.Value)
            {
                case EMode.加:
                    return item1 + item2;
                case EMode.减:
                    return item1 - item2;
                case EMode.乘:
                    return item1 * item2;
                case EMode.除:
                    if (item2 == 0)
                    {
                        return double.NaN;
                    }
 
                    return item1 / item2;
                default:
                    Debug.Assert(false);
                    break;
            }
 
            return double.NaN;
        }
 
        public string GetString()
        {
            if (Mode == null)
            {
                return Result.ToString();
            }
 
            switch (Mode.Value)
            {
                case EMode.加:
                    return $"({Items1.GetString()} + {Items2.GetString()})";
                case EMode.减:
                    return $"({Items1.GetString()} - {Items2.GetString()})";
                case EMode.乘:
                    return $"({Items1.GetString()} * {Items2.GetString()})";
                case EMode.除:
                    return $"({Items1.GetString()} / {Items2.GetString()})";
                default:
                    Debug.Assert(false);
                    break;
            }
 
            return null;
        }
    }
 
    public enum EMode
    {
        加,
        减,
        乘,
        除,
    }
}