Question

c#编程题目 高手进

幼儿园大、中、小3个班的小朋友分西瓜时，大班3人1个，中班4人一个，小班5人一个，正好分掉10个西瓜；分苹果时，大班每人2个，中班每人3个，小班每人4个，正好分完100个苹果。请问：大、中、小班各有多少小朋友？
算法设计：
假设大班x人，中班y人，小班z人，则得方程组。

令x从0到30，y从0到40，分别计算z，然后判断是否满足条件。
评分标准：
运行结果，输出格式如下所示。
大、中、小班各有小朋友：
18人、8人、10人。
是C#语言！不要C语言 也不是C++

Answer 1

这不是小学题目么 就是让你把小穴的算法翻译成 c#而已。。。。 还tm算法。。。。我以为啥呢。 直接上代码。。。

class Program
    {
        static void Main(string[] args)
        {
            //传递分苹果数据
            Dictionary<int, double> appdata = new Dictionary<int, double>();
            appdata.Add(0, 2);
            appdata.Add(1, 3);
            appdata.Add(2, 4);
            Dictionary<int, double> wmdata = new Dictionary<int, double>();
            wmdata.Add(0, 1D/3D);
            wmdata.Add(1, 1D/4D);
            wmdata.Add(2, 1D/5D);
            SubDivApple myapple = new SubDivApple();
            myapple.SetAmount(appdata, 100);
            SubDivWaterMelon mywm = new SubDivWaterMelon();
            mywm.SetAmount(wmdata, 10);
            var result = SubDivFruits.GetPerGroupCount(new SubDivFruits[] { myapple, mywm });
            foreach (var item in result) {
                Console.WriteLine("{0}年级共有{1}人", item.Key, item.Value);
            }
            Console.ReadKey();
        }
    }
    public abstract class SubDivFruits {
        public virtual string NameMemo { get; protected set; }
        double _totalfruitcount;
        public Dictionary<int, double> GroupAndPerPersonCount;
        public virtual SubDivFruits SetAmount(Dictionary<int, double> groupandamountperperson , double totalfruitcount) {
            if (groupandamountperperson == null)
                throw new ArgumentNullException("groupandamountperperson");
            if (groupandamountperperson.Count < 2)
                throw new ArgumentOutOfRangeException("groupandamountperperson", "方法传递的分组数不能少于2个分组");
            GroupAndPerPersonCount = groupandamountperperson;
            _totalfruitcount = totalfruitcount;
            return this;
        }
        public static Dictionary<int, int> GetPerGroupCount(IEnumerable<SubDivFruits> groups) {
            //检查每个分水果的分配方法是不是都是同样的分组数量
            var percount = (int) groups.Average(s => s.GroupAndPerPersonCount.Count);
            if (groups.Count(s => s.GroupAndPerPersonCount.Count != percount) > 0) {
                throw new Exception("错误，水果的分组数量不一致");
            }
            //第一步找到最多的人数可能设定为上限，即分最少数量的水果 那么全体人员的数量也不会多于那个数字 
            int maxpeople = (int) groups.Max(s => s._totalfruitcount / s.GroupAndPerPersonCount.Min(t => t.Value));
            Dictionary<int, int> toout = new Dictionary<int, int>();
            //初始化准备输出的结果
            foreach (var citem in groups.First().GroupAndPerPersonCount) {
                toout.Add(citem.Key, -1);
            }
            var applemethod = groups.Single(s => s.NameMemo.Equals("分苹果")).GroupAndPerPersonCount;
            var watermelonmethod = groups.Single(s => s.NameMemo.Equals("分西瓜")).GroupAndPerPersonCount;
            //由于题目三元一次方程 无固定解，只有 正整数解，所以不能用高斯消列 只能排列组合穷举 ， 不然 更简单一点
            //将所有人数排列
            int[] peoples = new int[maxpeople];
            for (int i = 0; i < maxpeople; i++) {
                peoples[i] = i;
            }
            var resp = GetPermutation(peoples, 3);
            foreach (var cresp in resp) {
                if (applemethod[0] * cresp[0] + applemethod[1] * cresp[1] + applemethod[2] * cresp[2] == groups.Single(s => s.NameMemo.Equals("分苹果"))._totalfruitcount)
                {
                    if (watermelonmethod[0] * cresp[0] + watermelonmethod[1] * cresp[1] + watermelonmethod[2] * cresp[2] == groups.Single(s => s.NameMemo.Equals("分西瓜"))._totalfruitcount)
                    {
                        //找到了第一个解 return这组数据
                        toout[0] = cresp[0];
                        toout[1] = cresp[1];
                        toout[2] = cresp[2];
                        break; 
                         
                    }
                }
            }
            return toout;
        }
        static void Swap(ref int a, ref int b)
        {
            int temp = a;
            a = b;
            b = temp;
        }
        static List<int[]> GetCombination(int[] t, int n)
        {
            if (t.Length < n)
            {
                return null;
            }
            int[] temp = new int[n];
            List<int[]> list = new List<int[]>();
            GetCombination(ref list, t, t.Length, n, temp, n);
            return list;
        }
        static void GetCombination(ref List<int[]> list, int[] 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<int[]>();
                    }
                    int[] temp = new int[M];
                    for (int j = 0; j < b.Length; j++)
                    {
                        temp[j] = t[b[j]];
                    }
                    list.Add(temp);
                }
            }
        }
        static List<int[]> GetPermutation(int[] t, int n)
        {
            if (n > t.Length)
            {
                return null;
            }
            List<int[]> list = new List<int[]>();
            List<int[]> c = GetCombination(t, n);
            for (int i = 0; i < c.Count; i++)
            {
                List<int[]> l = new List<int[]>();
                GetPermutation(ref l, c[i], 0, n - 1);
                list.AddRange(l);
            }
            return list;
        }
        //求数组排列
        static void GetPermutation(ref List<int[]> list, int[] t, int startIndex, int endIndex)
        {
            if (startIndex == endIndex)
            {
                if (list == null)
                {
                    list = new List<int[]>();
                }
                int[] temp = new int[t.Length];
                t.CopyTo(temp, 0);
                list.Add(temp);
            }
            else
            {
                for (int i = startIndex; i <= endIndex; i++)
                {
                    Swap(ref t[startIndex], ref t[i]);
                    GetPermutation(ref list, t, startIndex + 1, endIndex);
                    Swap(ref t[startIndex], ref t[i]);
                }
            }
        }
    }
    public class SubDivApple:SubDivFruits {
        public SubDivApple() {
            NameMemo = "分苹果";
        }
    }
    public class SubDivWaterMelon : SubDivFruits
    {
        public SubDivWaterMelon()
        {
            NameMemo = "分西瓜";
        }
    }