算法

1. 输入一个数字n，求第一个大于该数字的回文数字

输入	输出
808	818
2133	2222

2. 输入两个人的苹果个数的和与差，确定他们的苹果个数。 输入：苹果的数量和，苹果的数量差，输出： 两人各自苹果的个数。（请用计算机方法，而不是数学公式计算）

输入	输出
10，2	6，4
20，6	13，7
30，9	无

设有 n 个正整数a1，a2，a3，a4……an ，将它们联接成一排，相邻数字首尾相接，组成一个最大的整数。

输入格式

第一行有一个整数，表示数字个数 n。

第二行有 n个整数，表示给出的 n个整数值。

输出格式

一个正整数，表示最大的整数

输入	输出
3 13 312 343	34331213
4 7 13 4 246	7424613

完整代码

using System;
using System.Collections.Generic;

namespace HuiwenNumber
{
    /// <summary>
    /// 
    /// </summary>
    class Program
    {
        /// <summary>
        /// 控制台主方法
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Console.WriteLine("获取回数：1；获取和差值：2；获取正整数：3");

            string result = Console.ReadLine();

            switch (result)
            {
                case "1":
                    Gethuishu();
                    break;
                case "2":
                    GetHeCha();
                    break;
                case "3":
                    GetInt();
                    break;
                default:
                    Console.WriteLine("请输入提示的值！");
                    break;
            }
        }

        /// <summary>
        /// 获取回数
        /// </summary>
        public static void Gethuishu()
        {
            Console.WriteLine("请输入初始数字：");

            string num = Console.ReadLine();

            GetHuiShu.DiGui(num);

            Console.ReadLine();
        }

        /// <summary>
        /// 获取和差数
        /// </summary>
        public static void GetHeCha()
        {
            Console.WriteLine("请输入和：");

            string heNum = Console.ReadLine();

            Console.WriteLine("请输入差：");

            string chaNum = Console.ReadLine();

            int heNum_ = Convert.ToInt32(heNum);

            int chaNum_ = Convert.ToInt32(chaNum);

            int MaxNum = (heNum_ + chaNum_) / 2;

            int MinNum = (heNum_ - chaNum_) / 2;

            Console.WriteLine("A有苹果" + MaxNum + "个,B有苹果" + MinNum + "个");
        }

        /// <summary>
        /// 获取正整数,通过输入的整数，相连接组成最大的整数
        /// </summary>
        public static void GetInt()
        {
            Console.WriteLine("请输入整数个数：");

            string numlength = Console.ReadLine();

            List<int> listYuan = new List<int>();

            for (int i = 0; i < Convert.ToInt32(numlength); i++)
            {
                Console.WriteLine("请输入第" + i + "个数字:");

                string numarr = Console.ReadLine();

                listYuan.Add(Convert.ToInt32(numarr));
            }

            List<IntList> listEntity = new List<IntList>();

            for (int i = 0; i < listYuan.Count; i++)
            {
                listEntity.Add(new IntList { 
                    IntIndex = i, 
                    IntYuan = listYuan[i], 
                    IntSub = Convert.ToInt32(listYuan[i].ToString().Substring(0, 1)) 
                });
            }

            maopao(listEntity);

            string ZDZZS = "";

            for (int i = listEntity.Count - 1; i >= 0; i--)
            {
                ZDZZS += listEntity[i].IntYuan;
            }

            Console.WriteLine("最大正整数" + ZDZZS);
        }

        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="intLists"></param>
        /// <returns></returns>
        public static List<IntList> maopao(List<IntList> intLists)
        {
            for (int i = 0; i < intLists.Count - 1; i++)
            {
                for (int j = 0; j < intLists.Count - 1 - i; j++)
                {
                    if (intLists[j].IntSub > intLists[j + 1].IntSub)
                    {
                        IntList temp = intLists[j];
                        intLists[j] = intLists[j + 1];
                        intLists[j + 1] = temp;
                    }
                }
            }

            return intLists;
        }
    }

    public class GetHuiShu
    {
        /// <summary>
        /// 递归
        /// </summary>
        /// <param name="number"></param>
        public static void DiGui(string number)
        {
            if (IsHuiWenNum(number))
            {
                Console.WriteLine(number + "是回文数字！");
            }
            else
            {
                int newn = Convert.ToInt32(number);

                newn += 1;

                DiGui(newn.ToString());
            }
        }

        /// <summary>
        /// 判断是否为回文数字
        /// </summary>
        /// <param name="Num"></param>
        /// <returns></returns>
        public static bool IsHuiWenNum(string Num)
        {
            //先判断数字长度
            int mo = Num.Length % 2;
            string hou;
            string qian;
            //长度是奇数
            if (mo > 0)
            {
                int chang = (Num.Length - 1) / 2;

                qian = Num.Substring(0, chang);

                hou = Num.Substring((Num.Length - chang - 1), chang);
            }
            else
            {
                qian = Num.Substring(0, Num.Length / 2);

                hou = Num.Substring(Num.Length / 2, Num.Length / 2);
            }

            if (qian == ReverseStr(hou))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 字符串反转
        /// </summary>
        /// <param name="original"></param>
        /// <returns></returns>
        public static string ReverseStr(string original)
        {
            char[] arr = original.ToCharArray();
            Array.Reverse(arr);
            return new string(arr);
        }
    }

    public class IntList
    {
        public int IntYuan { get; set; }

        public int IntIndex { get; set; }

        public int IntSub { get; set; }
    }
}

运行截图

第一题

第二题

第三题