none
问个算法的问题....... RRS feed

  • 问题

  • 我有5个5 就相当于 这样 string values = "5,5,5,5,5";

    用代码写出 它怎么算等于24

     

    输出答案为这样子

    (5-5/(5*5))*5

    (5*5*5-5)/5 不知道还有没有

     


    人生吧,0岁出场,10岁成长;20为情彷徨;30基本定向;40拼命打闯;50回头望望;60告老还乡;70搓搓麻将;80晒晒太阳; 90躺在床上;100挂在墙上...生的伟大,死得凄凉!能牵手的时候,请别只是肩并肩,能拥抱的时候,请别只是手牵手,能在一起的时候,请别轻易分开!
    2011年5月26日 16:07

答案

  • 你好,这个问题可以用LINQ表达式树来解决。 LINQ表达式树对于括号()的构造比较复杂,

    这儿有一个利用表达式树实现四则运算的计算器,关于括号里面介绍的很详细, 

    详细思路和实现,请参阅:

    利用System.Linq.Expressions实现四则运算计算器(一) 

    利用System.Linq.Expressions实现四则运算计算器(二)
    利用System.Linq.Expressions实现四则运算计算器(三)

     

    希望对你有帮助。


    Jackie Sun [MSFT]
    如果您对我们的论坛在线支持服务有任何的意见或建议,请通过邮件告诉我们。
    MSDN 论坛好帮手 立刻免费下载  MSDN 论坛好帮手

    2011年5月30日 6:31
    版主
  • 你好:)

    看上去你貌似做24点算法?呵呵

    请参考这个,或许有帮助—— 

    //-----------------------------------------------------------------------------

    //

    // 算法:排列组合类

    //

    // 版权所有(C) Snowdust

    // 个人博客    [url]http://blog.csdn.net/snowdust[/url] & [url]http://snowdust.cnblogs.com[/url]

    // MSN & Email [email]snowdust77@sina.com[/email]

    //

    // 此源代码可免费用于各类软件(含商业软件)

    // 允许对此代码的进一步修改与开发

    // 但必须完整保留此版权信息

    //

    // 调用方法如下:

    //

    // 1.GetPermutation(T[], startIndex, endIndex)

    // 对startIndex到endIndex进行排列,其余元素不变

    //

    // 2.GetPermutation(T[])

    // 返回数组所有元素的全排列

    //

    // 3.GetPermutation(T[], n)

    // 返回数组中n个元素的排列

    //

    // 4.GetCombination(T[], n)

    // 返回数组中n个元素的组合

    //

    // 版本历史:

    // V0.1 2010-01-20 摘要:首次创建 

    //

    //-----------------------------------------------------------------------------

     

    using System;

    using System.Collections.Generic;

     

    namespace Arithmetic

    {

        public class PermutationAndCombination<T>

        {

            #region 内部方法

            /// <summary>

            /// 递归算法求数组的组合(私有成员)

            /// </summary>

            /// <param name="list">返回的范型</param>

            /// <param name="t">所求数组</param>

            /// <param name="n">辅助变量</param>

            /// <param name="m">辅助变量</param>

            /// <param name="b">辅助数组</param>

            /// <param name="M">辅助变量M</param>

            private static void GetCombination(ref List<T[]> list, T[] t, int n, int m, int[] b, int M)

            {

                for (int i = n; i >= m; i--)

                {

                    b[m - 1] = i - 1;

                    if (m > 1)

                    {

                        GetCombination(ref list, t, i - 1, m - 1, b, M);

                    }

                    else

                    {

                        if (list == null)

                        {

                            list = new List<T[]>();

                        }

                        T[] temp = new T[M];

                        for (int j = 0; j < b.Length; j++)

                        {

                            temp[j] = t[b[j]];

                        }

                        list.Add(temp);

                    }

                }

            }

     

            /// <summary>

            /// 递归算法求排列(私有成员)

            /// </summary>

            /// <param name="list">返回的列表</param>

            /// <param name="t">所求数组</param>

            /// <param name="startIndex">起始标号</param>

            /// <param name="endIndex">结束标号</param>

            private static void GetPermutation(ref List<T[]> list, T[] t, int startIndex, int endIndex)

            {

                if (startIndex == endIndex)

                {

                    if (list == null)

                    {

                        list = new List<T[]>();

                    }

                    T[] temp = new T[t.Length];

                    t.CopyTo(temp, 0);

                    list.Add(temp);

                }

                else

                {

                    for (int i = startIndex; i <= endIndex; i++)

                    {

                        Swap(ref t[startIndex], ref t);

                        GetPermutation(ref list, t, startIndex + 1, endIndex);

                        Swap(ref t[startIndex], ref t);

                    }

                }

            }

            #endregion

     

            #region 公共方法

            /// <summary>

            /// 交换两个变量

            /// </summary>

            /// <param name="a">变量1</param>

            /// <param name="b">变量2</param>

            public static void Swap(ref T a, ref T b)

            {

                T temp = a;

                a = b;

                b = temp;

            }

     

            /// <summary>

            /// 求从起始标号到结束标号的排列,其余元素不变

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <param name="startIndex">起始标号</param>

            /// <param name="endIndex">结束标号</param>

            /// <returns>从起始标号到结束标号排列的范型</returns>

            public static List<T[]> GetPermutation(T[] t, int startIndex, int endIndex)

            {

                if (startIndex < 0 || endIndex > t.Length - 1)

                {

                    return null;

                }

                List<T[]> list = new List<T[]>();

                GetPermutation(ref list, t, startIndex, endIndex);

                return list;

            }

     

            /// <summary>

            /// 返回数组所有元素的全排列

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <returns>全排列的范型</returns>

            public static List<T[]> GetPermutation(T[] t)

            {

                return GetPermutation(t, 0, t.Length - 1);

            }

     

            /// <summary>

            /// 求数组中n个元素的排列

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <param name="n">元素个数</param>

            /// <returns>数组中n个元素的排列</returns>

            public static List<T[]> GetPermutation(T[] t, int n)

            {

                if (n > t.Length)

                {

                    return null;

                }

                List<T[]> list = new List<T[]>();

                List<T[]> c = GetCombination(t, n);

                for (int i = 0; i < c.Count; i++)

                {

                    List<T[]> l = new List<T[]>();

                    GetPermutation(ref l, c, 0, n - 1);

                    list.AddRange(l);

                }

                return list;

            }

     

     

            /// <summary>

            /// 求数组中n个元素的组合

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <param name="n">元素个数</param>

            /// <returns>数组中n个元素的组合的范型</returns>

            public static List<T[]> GetCombination(T[] t, int n)

            {

                if (t.Length < n)

                {

                    return null;

                }

                int[] temp = new int[n];

                List<T[]> list = new List<T[]>();

                GetCombination(ref list, t, t.Length, n, temp, n);

                return list;

            }

            #endregion

        }

    }

    来源:http://www.pin5i.com/showtopic-26582.html,可以参考然后进一步修改成5个数字的。


    如果你有其它意见或私下交流,请发送邮件到:maledong@qq.com;或者请QQ我
    下载MSDN桌面工具(Vista,Win7)
    下载Technet桌面小工具(Vista,Win7)
    慈善点击,点击此处
    2011年6月1日 2:48

全部回复

  • 没人会?
    人生吧,0岁出场,10岁成长;20为情彷徨;30基本定向;40拼命打闯;50回头望望;60告老还乡;70搓搓麻将;80晒晒太阳; 90躺在床上;100挂在墙上...生的伟大,死得凄凉!能牵手的时候,请别只是肩并肩,能拥抱的时候,请别只是手牵手,能在一起的时候,请别轻易分开!
    2011年5月27日 18:26
  • 你好,这个问题可以用LINQ表达式树来解决。 LINQ表达式树对于括号()的构造比较复杂,

    这儿有一个利用表达式树实现四则运算的计算器,关于括号里面介绍的很详细, 

    详细思路和实现,请参阅:

    利用System.Linq.Expressions实现四则运算计算器(一) 

    利用System.Linq.Expressions实现四则运算计算器(二)
    利用System.Linq.Expressions实现四则运算计算器(三)

     

    希望对你有帮助。


    Jackie Sun [MSFT]
    如果您对我们的论坛在线支持服务有任何的意见或建议,请通过邮件告诉我们。
    MSDN 论坛好帮手 立刻免费下载  MSDN 论坛好帮手

    2011年5月30日 6:31
    版主
  • 你好:)

    看上去你貌似做24点算法?呵呵

    请参考这个,或许有帮助—— 

    //-----------------------------------------------------------------------------

    //

    // 算法:排列组合类

    //

    // 版权所有(C) Snowdust

    // 个人博客    [url]http://blog.csdn.net/snowdust[/url] & [url]http://snowdust.cnblogs.com[/url]

    // MSN & Email [email]snowdust77@sina.com[/email]

    //

    // 此源代码可免费用于各类软件(含商业软件)

    // 允许对此代码的进一步修改与开发

    // 但必须完整保留此版权信息

    //

    // 调用方法如下:

    //

    // 1.GetPermutation(T[], startIndex, endIndex)

    // 对startIndex到endIndex进行排列,其余元素不变

    //

    // 2.GetPermutation(T[])

    // 返回数组所有元素的全排列

    //

    // 3.GetPermutation(T[], n)

    // 返回数组中n个元素的排列

    //

    // 4.GetCombination(T[], n)

    // 返回数组中n个元素的组合

    //

    // 版本历史:

    // V0.1 2010-01-20 摘要:首次创建 

    //

    //-----------------------------------------------------------------------------

     

    using System;

    using System.Collections.Generic;

     

    namespace Arithmetic

    {

        public class PermutationAndCombination<T>

        {

            #region 内部方法

            /// <summary>

            /// 递归算法求数组的组合(私有成员)

            /// </summary>

            /// <param name="list">返回的范型</param>

            /// <param name="t">所求数组</param>

            /// <param name="n">辅助变量</param>

            /// <param name="m">辅助变量</param>

            /// <param name="b">辅助数组</param>

            /// <param name="M">辅助变量M</param>

            private static void GetCombination(ref List<T[]> list, T[] t, int n, int m, int[] b, int M)

            {

                for (int i = n; i >= m; i--)

                {

                    b[m - 1] = i - 1;

                    if (m > 1)

                    {

                        GetCombination(ref list, t, i - 1, m - 1, b, M);

                    }

                    else

                    {

                        if (list == null)

                        {

                            list = new List<T[]>();

                        }

                        T[] temp = new T[M];

                        for (int j = 0; j < b.Length; j++)

                        {

                            temp[j] = t[b[j]];

                        }

                        list.Add(temp);

                    }

                }

            }

     

            /// <summary>

            /// 递归算法求排列(私有成员)

            /// </summary>

            /// <param name="list">返回的列表</param>

            /// <param name="t">所求数组</param>

            /// <param name="startIndex">起始标号</param>

            /// <param name="endIndex">结束标号</param>

            private static void GetPermutation(ref List<T[]> list, T[] t, int startIndex, int endIndex)

            {

                if (startIndex == endIndex)

                {

                    if (list == null)

                    {

                        list = new List<T[]>();

                    }

                    T[] temp = new T[t.Length];

                    t.CopyTo(temp, 0);

                    list.Add(temp);

                }

                else

                {

                    for (int i = startIndex; i <= endIndex; i++)

                    {

                        Swap(ref t[startIndex], ref t);

                        GetPermutation(ref list, t, startIndex + 1, endIndex);

                        Swap(ref t[startIndex], ref t);

                    }

                }

            }

            #endregion

     

            #region 公共方法

            /// <summary>

            /// 交换两个变量

            /// </summary>

            /// <param name="a">变量1</param>

            /// <param name="b">变量2</param>

            public static void Swap(ref T a, ref T b)

            {

                T temp = a;

                a = b;

                b = temp;

            }

     

            /// <summary>

            /// 求从起始标号到结束标号的排列,其余元素不变

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <param name="startIndex">起始标号</param>

            /// <param name="endIndex">结束标号</param>

            /// <returns>从起始标号到结束标号排列的范型</returns>

            public static List<T[]> GetPermutation(T[] t, int startIndex, int endIndex)

            {

                if (startIndex < 0 || endIndex > t.Length - 1)

                {

                    return null;

                }

                List<T[]> list = new List<T[]>();

                GetPermutation(ref list, t, startIndex, endIndex);

                return list;

            }

     

            /// <summary>

            /// 返回数组所有元素的全排列

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <returns>全排列的范型</returns>

            public static List<T[]> GetPermutation(T[] t)

            {

                return GetPermutation(t, 0, t.Length - 1);

            }

     

            /// <summary>

            /// 求数组中n个元素的排列

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <param name="n">元素个数</param>

            /// <returns>数组中n个元素的排列</returns>

            public static List<T[]> GetPermutation(T[] t, int n)

            {

                if (n > t.Length)

                {

                    return null;

                }

                List<T[]> list = new List<T[]>();

                List<T[]> c = GetCombination(t, n);

                for (int i = 0; i < c.Count; i++)

                {

                    List<T[]> l = new List<T[]>();

                    GetPermutation(ref l, c, 0, n - 1);

                    list.AddRange(l);

                }

                return list;

            }

     

     

            /// <summary>

            /// 求数组中n个元素的组合

            /// </summary>

            /// <param name="t">所求数组</param>

            /// <param name="n">元素个数</param>

            /// <returns>数组中n个元素的组合的范型</returns>

            public static List<T[]> GetCombination(T[] t, int n)

            {

                if (t.Length < n)

                {

                    return null;

                }

                int[] temp = new int[n];

                List<T[]> list = new List<T[]>();

                GetCombination(ref list, t, t.Length, n, temp, n);

                return list;

            }

            #endregion

        }

    }

    来源:http://www.pin5i.com/showtopic-26582.html,可以参考然后进一步修改成5个数字的。


    如果你有其它意见或私下交流,请发送邮件到:maledong@qq.com;或者请QQ我
    下载MSDN桌面工具(Vista,Win7)
    下载Technet桌面小工具(Vista,Win7)
    慈善点击,点击此处
    2011年6月1日 2:48