1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    7. namespace _41_方法的综合练习
    8. {
    9.     class Program
    10.     {
    11.         static void Main(string[] args)
    12.         {
    13.             //提示用户输入两个数字，计算这两个数字之间(包括这两个数)所有整数的和
    14.             //1.用户只能输入数字
    15.             //2.计算两个数字之和
    16.             //3.要求第一个数字必须比第二个数字小，否则重新输入
    18.             Console.WriteLine("请输入第一个数字:");
    19.             string strNumberOne = Console.ReadLine();
    20.             int numberOne = GetNumber(strNumberOne);
    22.             Console.WriteLine("请输入第二个数字：");
    23.             string strNumberTwo = Console.ReadLine();
    24.             int numberTwo = GetNumber(strNumberTwo);
    26.             //判断第一个数字是否小于第二个数字
    27.             JudgeNumber(ref numberOne, ref numberTwo);
    29.             //求和
    30.             int sum = GetSum(numberOne, numberTwo);
    31.             Console.WriteLine(sum);
    33.             Console.ReadKey();
    34.         }
    36.         /// <summary>
    37.         /// 判断输入是否为int类型
    38.         /// </summary>
    39.         /// <param name="s">输入的内容</param>
    40.         /// <returns>int类型的值</returns>
    41.         public static int GetNumber(string s)
    42.         {
    43.             while (true)
    44.             {
    45.                 try
    46.                 {
    47.                     int number = Convert.ToInt32(s);
    48.                     return number;
    49.                 }
    50.                 catch
    51.                 {
    52.                     Console.WriteLine("输入错误，请重新输入：");
    53.                     s = Console.ReadLine();
    54.                 }
    55.             }
    56.         }
    58.         /// <summary>
    59.         /// 判断第一个数是否比第二个数小
    60.         /// </summary>
    61.         /// <param name="n1">用户输入的第一个数</param>
    62.         /// <param name="n2">用户输入的第二个数</param>
    63.         public static void JudgeNumber(ref int n1, ref int n2)
    64.         {
    65.             while (true)
    66.             {
    67.                 if (n1 < n2)
    68.                 {
    69.                     //符合题意
    70.                     return;
    71.                 }
    72.                 else
    73.                 {
    74.                     Console.WriteLine("第一个数字不能大于或等于第二个数字，请重新输入第一个数字：");
    75.                     string s1 = Console.ReadLine();
    76.                     n1 = GetNumber(s1);
    77.                     Console.WriteLine("请重新输入第二个数字：");
    78.                     string s2 = Console.ReadLine();
    79.                     n2 = GetNumber(s2);
    80.                 }
    81.             }
    82.         }
    84.         /// <summary>
    85.         /// 计算两个数字之间所有整数的和
    86.         /// </summary>
    87.         /// <param name="n1">头</param>
    88.         /// <param name="n2">尾</param>
    89.         /// <returns>返回的总和值</returns>
    90.         public static int GetSum(int n1, int n2)
    91.         {
    92.             int sum = 0;
    93.             for (int i = n1; i <= n2; i++)
    94.             {
    95.                 sum += i;
    96.             }
    97.             return sum;
    98.         }
    99.     }
    100. }
    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Threading.Tasks;
    7. namespace _42_方法的最后练习
    8. {
    9.     class Program
    10.     {
    12.         static void Main(string[] args)
    13.         {
    14.             #region 1.有一个字符串数组，用一个方法来实现，输出最长的字符串
    16.             ////1.有一个字符串数组，用一个方法来实现，输出最长的字符串
    17.             //string[] names = { "花泽香菜", "水濑祈", "纮糖", "一之赖美琴", "白" };
    18.             ////string s = "123456";
    19.             ////Console.WriteLine(s.Length);
    20.             ////Console.WriteLine(names.Length);
    21.             //string longest = Getlongest(names);
    22.             //Console.WriteLine(longest);
    24.             #endregion
    26.             #region 2.用方法来实现，请计算出一个整型数组的平均值,保留两位小数
    27.             ////2.用方法来实现，请计算出一个整型数组的平均值,保留两位小数
    28.             //int[] a = new int[10];
    29.             //for (int i = 0; i < 10; i++)
    30.             //{
    31.             //    a[i] = Convert.ToInt32(Console.ReadLine());
    32.             //}
    33.             //double avg = GetAvg(a);
    35.             ////Console.WriteLine("{0:0.00}", avg);//仅在输出是改变，并未改变其本质
    36.             ////保留两位小数   (下面两种方法都是四舍五入）
    37.             //string s = avg.ToString("0.00");
    38.             //avg = Convert.ToDouble(s);
    39.             //Console.WriteLine(avg);
    41.             ////Console.WriteLine(avg.ToString("0.00"));
    43.             #endregion
    45.             #region 3.写一个方法，用来判断用户输入的数字是否为质数
    46.             //3.写一个方法，用来判断用户输入的数字是否为质数
    47.             //再写一个方法，要求用户只能输入数字，输入有误就让用户一直输入
    48.             //直到输入质数，程序才会结束
    49.             while (true)
    50.             {
    51.                 Console.WriteLine("请输入一个数字，将会判断它是否为质数");
    52.                 string strNumber = Console.ReadLine();
    54.                 int number = GetNumber(strNumber);
    55.                 bool b = IsPrime(number);
    56.                 Console.WriteLine(b);
    57.                 if (b == true)
    58.                 { break; };
    59.             }
    60.             #endregion
    62.             Console.ReadKey();
    63.         }
    66.         /// <summary>
    67.         /// 求最长的字符串
    68.         /// </summary>
    69.         /// <param name="s">输入的字符串数组</param>
    70.         /// <returns>返回最长的字符串</returns>
    71.         public static string Getlongest(string[] s)
    72.         {
    73.             string max = s[0];
    74.             for (int i = 0; i < s.Length; i++)
    75.             {
    76.                 if (s[i].Length > max.Length)
    77.                 {
    78.                     max = s[i];
    79.                 }
    80.             }
    81.             return max;
    82.         }
    85.         /// <summary>
    86.         /// 计算一个整型数组的平均值,保留两位小数
    87.         /// </summary>
    88.         /// <param name="nums">整型数组</param>
    89.         /// <returns>返回数组的平均值</returns>
    90.         public static double GetAvg(int[] nums)
    91.         {
    92.             double sum = 0;
    93.             for (int i = 0; i < nums.Length; i++)
    94.             {
    95.                 sum += nums[i];
    96.             }
    97.             return sum / nums.Length;
    98.         }
    101.         /// <summary>
    102.         /// 判断用户输入的是否为整数
    103.         /// </summary>
    104.         /// <param name="strNumber">用户输入的数据</param>
    105.         /// <returns>返回整数</returns>
    106.         public static int GetNumber(string strNumber)
    107.         {
    108.             while (true)
    109.             {
    110.                 try
    111.                 {
    112.                     int number = Convert.ToInt32(strNumber);
    113.                     return number;
    114.                 }
    115.                 catch
    116.                 {
    117.                     Console.WriteLine("输入数据不是整数，请重新输入：");
    118.                     strNumber = Console.ReadLine();
    119.                 }
    120.             }
    121.         }
    123.         /// <summary>
    124.         /// 判断一个属是否为质数
    125.         /// </summary>
    126.         /// <param name="number">用户输入的数</param>
    127.         /// <returns>返回是否为整数bool类型</returns>
    128.         public static bool IsPrime(int number)
    129.         {
    130.             if (number < 2)
    131.             {
    132.                 return false;
    133.             }
    134.             else
    135.             {
    136.                 //让这个数字从2开始除 除到自身的前一位
    137.                 for (int i = 2; i < number; i++)
    138.                 {
    139.                     if (number % i == 0)
    140.                     {
    141.                         //给非质数准备的
    142.                         return false;
    143.                     }
    144.                 }
    145.                 //给质数准备的
    146.                 return true;
    147.             }
    148.             //return true; //放在这里也行
    149.         }
    150.     }
    151. }
    1. using System;
    3. namespace _043_方法的最后练习2
    4. {
    5.     class Program
    6.     {
    7.         static void Main(string[] args)
    8.         {
    9.             #region 1.接受输入后判断其等级并显示出来
    10.             ////1.接受输入后判断其等级并显示出来
    11.             //Console.WriteLine("请输入考试成绩：");
    12.             //int score = Convert.ToInt32(Console.ReadLine());
    13.             //string level = getLevel(score);
    14.             //Console.WriteLine(level);
    15.             #endregion
    17.             #region 2.将字符串数组{"中国","美国","巴西","澳大利亚","加拿大"}中的内容反转
    18.             ////2.将字符串数组{"中国","美国","巴西","澳大利亚","加拿大"}中的内容反转
    19.             //string[] names = { "中国", "美国", "巴西", "澳大利亚", "加拿大" };
    20.             //Reverse(names);
    21.             //for (int i = 0; i < names.Length; i++)
    22.             //{
    23.             //    Console.WriteLine(names[i]);
    24.             //}
    25.             #endregion
    27.             #region 3.计算圆的周长和面积
    28.             ////3.计算圆的周长和面积
    29.             //Console.WriteLine("请输入圆的半径：");
    30.             //double r = Convert.ToDouble(Console.ReadLine());
    31.             //double perimeter;
    32.             //double area;
    33.             //GetPerimeterArea(r,out perimeter,out area);
    34.             //Console.WriteLine("圆的周长：{0:0.00},面积{1:0.00}", perimeter, area);
    35.             #endregion
    37.             Console.ReadKey();
    38.         }
    40.         /// <summary>
    41.         /// 判断学生等级
    42.         /// </summary>
    43.         /// <param name="score">输入学生的分数</param>
    44.         /// <returns>返回学生的等级</returns>
    45.         public static string getLevel(int score)
    46.         {
    47.             string level = "";
    48.             switch (score / 10)
    49.             {
    50.                 case 10: level = "A+"; break;
    51.                 case 9: level = "A"; break;
    52.                 case 8: level = "A-"; break;
    53.                 case 7: level = "B+"; break;
    54.                 case 6: level = "B"; break;
    55.                 default:
    56.                     level = "C";
    57.                     break;
    58.             }
    59.             return level;
    60.         }
    62.         /// <summary>
    63.         /// 将数组元素反转
    64.         /// </summary>
    65.         /// <param name="names">要被反转的数组</param>
    66.         public static void Reverse(string[] names)
    67.         {
    68.             for (int i = 0; i < names.Length/2; i++)
    69.             {
    70.                 string temp = names[i];
    71.                 names[i] = names[names.Length - 1 - i];
    72.                 names[names.Length - 1 - i] = temp;
    73.             }
    74.         }
    76.         /// <summary>
    77.         /// 计算圆的周长和面积
    78.         /// </summary>
    79.         /// <param name="r">圆的半径</param>
    80.         /// <param name="perimeter">额外返回圆的周长</param>
    81.         /// <param name="area">额外返回圆的面积</param>
    82.         public static void GetPerimeterArea(double r,out double perimeter,out double area)
    83.         {
    84.             perimeter = 2 * 3.14 * r;
    85.             area = 3.14 * r * r;
    86.         }
    87.     }
    88. }
    1. using System;
    3. namespace _044_方法的最后练习3
    4. {
    5.     class Program
    6.     {
    7.         static void Main(string[] args)
    8.         {
    9.             #region 1.计算任意多个数的和(params)
    10.             ////1.计算任意多个数的和
    11.             //int sum = GetSum(1, 2, 3, 4, 5, 6, 7, 8);
    12.             //Console.WriteLine(sum);
    13.             #endregion
    15.             #region 2.通过冒泡排序算法对数组实现升序排序
    16.             ////2.通过冒泡排序算法对数组{3,2,56,43,8,76,23,1,87}实现升序排序
    17.             //int[] nums = { 3, 2, 56, 43, 8, 76, 23, 1, 87 };
    18.             //Sort(nums);
    19.             //for (int i = 0; i < nums.Length; i++)
    20.             //{
    21.             //    Console.WriteLine(nums[i]);
    22.             //}
    23.             #endregion
    25.             #region 3.将一个字符串数组输出为|分割的形式
    26.             ////3.将一个字符串数组输出为|分割的形式
    27.             //string[] names = { "蕾姆", "是", "我的", "老婆" };
    28.             //string str = ProcessString(names);
    29.             //Console.WriteLine(str);
    30.             #endregion
    32.             Console.ReadKey();
    33.         }
    35.         /// <summary>
    36.         /// 计算多个数的和
    37.         /// </summary>
    38.         /// <param name="nums">输入的数</param>
    39.         /// <returns>返回的总和</returns>
    40.         public static int GetSum(params int[] nums)
    41.         {
    42.             int sum = 0;
    43.             for (int i = 0; i < nums.Length; i++)
    44.             {
    45.                 sum += nums[i];
    46.             }
    47.             return sum;
    48.         }
    50.         /// <summary>
    51.         /// 冒泡排序
    52.         /// </summary>
    53.         /// <param name="nums">需要排序的数组</param>
    54.         public static void Sort(int[] nums)
    55.         {
    56.             for (int i = 0; i < nums.Length-1; i++)
    57.             {
    58.                 for (int j = 0; j < nums.Length-1-i; j++)
    59.                 {
    60.                     if (nums[j] > nums[j + 1])
    61.                     {
    62.                         int temp = nums[j];
    63.                         nums[j] = nums[j + 1];
    64.                         nums[j + 1] = temp;
    65.                     }
    66.                 }
    67.             }
    68.         }
    70.         /// <summary>
    71.         /// 将一个字符串数组输出为|分割的形式
    72.         /// </summary>
    73.         /// <param name="names">输入的数组</param>
    74.         /// <returns>返回为|分割的形式</returns>
    75.         public static string ProcessString(string[] names)
    76.         {
    77.             string str = null;
    78.             for (int i = 0; i < names.Length-1; i++)
    79.             {
    80.                 str += names[i] + '|';
    81.             }
    82.             return str + names[names.Length - 1];
    83.         }
    84.     }
    85. }