递归函数  

❓问题
f(n)=f(n-1)+f(n-2) f(0)=2 f(1)=3 ,⽤程序求得f(40）  

```c#
        static int F(int n)
        {
            if (n == 0)
            {
                return 2;
            }
            if (n == 1)
            {
                return 3;
            }

            int res = F(n - 1) + F(n - 2);
            return res;
        }  
        //主函数入口
        static void Main(string[] args)
        {
            Console.WriteLine(F(40)); 
        }
```  

:::tip{title="解决办法： "}
1、使⽤循环  
2、使⽤递归函数  

:::
 **调⽤⾃⾝的函数就是递归函数**
:::warning{title="注意"}
递归函数要有递归终⽌的条件
:::

 
  

✋编程题  
利⽤递归取得10!  即10的阶乘
```c#
        static int  F(int n)
        {
            if (n == 1)
            {
                return 1;
            }
            int result = n * F(n - 1);
            return result;
        }  
        //主函数入口
        static void Main(string[] args)
        {
            //10! = 10*9 ...   1

            int result = 1;
            for(int i = 1; i < 11; i++)
            {
                result = result * i;
            }
            Console.WriteLine(result);

            //10!
             f(n)=n*f(n-1)
            // 10! = 10*9!
            // f(1)=1 
            Console.WriteLine(F(10)); //调用
        }
```  


✋编程题
1+2!+3!+...+10!  
利⽤多个⽅法计算结果
```c#
   //   方法1：    1+2!+3!+...+10!
            int total = 0;
            for(int i = 1; i < 11; i++)
            {
               int temp = 1;
               for (int j = 1; j < i + 1; j ++)  // i 的阶乘
               {
                   temp = temp * j;
               }
               total = total + temp;
            }
            Console.WriteLine(total);
```  
```c#
   //   方法2：    1+2!+3!+...+10!
        static int  F1(int n)
        {
            if (n == 1)
            {
                return 1;
            }
            int result = n * F1(n - 1);
            return result;  //计算递归结果
        } 
        
        static int  F2(int n)
        {
            if (n == 1)
            {
                return 1;
            }
            return F2(n-1) + F1(n）;  //计算递归加法后的结果
        }
        //主函数入口
        static void Main(string[] args)
        {
            //f(n)=1+2!+3!+...+n!
            //f(n)=f(n-1) + n!
            //f1(n)=n!
            //f2(n)=f2(n-1) + n!
            Console.WriteLine(F2(10));
        }
```  

✋编程题
有关系式1\*1+2\*2+3\*3+...+k\*k<2000,编⼀个程序，求出满⾜此关系式的k的最⼤值
利⽤递归和循环解决这个问题  
```c#
            //f(n)=1 + 2 +..  n
            //f(n)= f(n-1)+n
            //f(1)=1
            // 循环方式
            int k = 1;
            int result = 0;
            while (true)
            {
               result += k * k;
               if (result >= 2000)
               {
                   break;
               }
               k++;
            }
            Console.WriteLine(k - 1);
```
```c#
// 递归方式
        static int F(int n)
        {
            if (n == 1)
            {
                return 1;
            }
            return F(n - 1) + n*n;
        } 
        //主函数入口
        static void Main(string[] args)
        {
            int i = 1;
            while (true)
            {
                if (F(i) >= 2000)
                {
                    break;
                }
                i++;
            }
            Console.WriteLine(i - 1);
        }
```

递归函数

函数的重载 - Overload  

为什么使⽤函数重载？  
假设我们有⼀个函数⽤来实现求得⼀个数组的最⼤值  
```c#
static int MaxValue(int[] intArray){
....
return;
}

```  


这个函数只能⽤于处理int数组，如果想处理double类型的话需要再定义⼀个函数  
```c#
static double MaxValue(double[] doubleArray){
...
return;
}

```  


**函数名相同，参数不同**，这个叫做**函数的重载**  
编译器通过不同的参数去识别应该调⽤哪⼀个函数 
```c#
        static int MaxValue(int[] array)
        {
            int max = array[0];
            for (int i = 1; i < array.Length; i++)
            {
                if (max < array[i])
                {
                    max = array[i];
                }
            }
            return max;
        }
        static double MaxValue(double[] array)
        {
            double max = array[0];
            for (int i = 1; i < array.Length; i++)
            {
                if (max < array[i])
                {
                    max = array[i];
                }
            }
            return max;
        }
        static void Main(string[] args)
        {
            Console.WriteLine(MaxValue(new int[] { 45, 12, 57, 34, 534, 534, 5323, 324 }));
            Console.WriteLine(MaxValue(new double[] { 45, 12, 57, 34, 534, 534, 5323, 324,23453.3 }));
        }
```



:::tip{title="提示"}
编译器会根据你传递过来的实参的类型去判定调⽤哪⼀个函数
:::

函数的重载

参数数组 和 函数  

❓问题   
定义一个函数，用来取得数字的和，但是数字的个数不确定。  


:::tip{title="解决方案："}
1、定义一个函数，参数传递过来一个数组；  
2、定义一个参数个数不确定的函数，这个时候我们就要使用参数数组。  
**除了参数数组，所有函数的参数都是固定的，那么调用的时候，参数是一定要传递的**
:::


**参数数组的定义**（使⽤的时候，当成数组使⽤即可，传递的时候参数任意个）

```c#
static int Add(params int[] array)
{ 

}  
```

:::note{title=""}
这里定义了一个int类型的参数数组，参数数组和数组参数（上面的）的不同，在于函数的调用，调用参数数组的函数的时候，我们可以传递过来任意多个参数，然后编译器会帮我们自动组拼成一个数组，参数如果是上面的数组参数，那么这个数组我们自己去手动创建  

参数数组就是帮我们 减少了一个创建数组的过程
:::

```c#
        static int Add1(int a,int b)  //不加params
        {
            return a + b;
        }
        static int Add2(int[] array)  //不加params
        {
            int sum = 0;
            foreach (int temp in array)
            {
                sum += temp;
            }
            return sum;
        }
        static int Add3(params int[] array)  //可以传递任意个个数的参数  //加params
        {
            int sum = 0;
            foreach (int temp in array)
            {
                sum += temp;
            }
            return sum;
        }

        static void Main(string[] args) //主函数入口
        {
            int sum1 = Add2(new int[] { 2, 4, 8 });  //调用1
            Console.WriteLine(sum1);

            int[] array2 = { 6, 8, 9 };
            int sum2 = Add2(array2);  //调用2
            Console.WriteLine(sum2);

            int sum3 = Add3(6, 8, 1);
            Console.WriteLine(sum3);   //调用3

            int sum4 = Add3( 1,3,5,7,9,2);  //调用3
            Console.WriteLine(sum4);
        }
```

参数数组

**函数（Function ⽅法Method）**  

 ⽅法Method **名称首字母大写**  
```c#
//方法的定义 ：   //VerifyUsername             
           //bool  需返回布尔类型值       //形参 形式参数
        static bool VerifyUsername(string username)//参数
        {
            Console.WriteLine("校验逻辑修改");
            Console.WriteLine("校验逻辑修改2");
            Console.WriteLine("校验用户名"+username);
            return true;
        }  
        //主函数-入口函数 --   主方法 入口方法 
        static void Main(string[] args)
        {
            //100-50
 //方法的调用：
            //某个字符串     实参，实际参数
            bool result = VerifyUsername("siki");
            Console.WriteLine(result);
        }
```
- 1、如果需要重复执⾏某段代码，那就需要写重复的代码  
- 2、重复的代码多了，不容易管理，不容易阅读和维护  

⽐如某段代码的功能是校验⽤户输⼊的⽤户名是否符合要求。  
```c#
        static bool VerifyUsername(string username)//参数
        {
            Console.WriteLine("校验逻辑修改");
            Console.WriteLine("校验逻辑修改2");
            Console.WriteLine("校验用户名"+username);
            return true;
        }  
        //主函数-入口函数 --   主方法 入口方法 
        static void Main(string[] args)
        {
            bool result = VerifyUsername("siki");
            Console.WriteLine(result); 
            ////Console.WriteLine("校验逻辑修改");
            ////Console.WriteLine("校验用户名");
            VerifyUsername("sikiedu");
            ////Console.WriteLine("校验逻辑修改");
            ////Console.WriteLine("校验用户名");
            VerifyUsername("micheal");
        }
```
如果程序中有多个地⽅需要做校验，就会有重复代码。  
```c#
 //  a + b
        static void Add1() {
            int result = 3 + 4;
        }
        static void Add2(int a,int b)
        {
            int result = a + b;
        }
        //static 静态-修饰符
        static int Add3(int a,int b)
        {
            int result = a + b;
            return result;//break; 方法返回了之后，表示这个方法结束了，后续代码就不执行了
            Console.WriteLine("123");
        } 
       //主函数-入口函数 --   主方法 入口方法 
        static void Main(string[] args)
        {   //方法的调用
            Add1();
            Add2(10, 12);
            int res = Add3(23, 23);
            Console.WriteLine(res);
        }
```

❓练习1 - 引⼊知识点  

区间内的真素数  
找出正整数 M 和 N 之间（N 不⼩于 M）的所有真素数。真素数的定义：如果⼀个正整数P 为素数，且其反序也为素数，那么 P 就为真素数。例如，11，13 均为真素数，因为11的反序还是为11，13 的反序为 31 也为素数。  

输⼊格式：输⼊两个数 M 和 N，空格间隔，1 <= M <= N <= 100000。输出格式：按从⼩到⼤输出 M 和 N 之间（包括 M 和 N ）的真素数，逗号间隔。如果之间没有真素数，则输出 No。  

输⼊样例：10 35  
输出样例：11,13,17,31  

```c#
            // m<=n
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int j = 0; j < strArray.Length; j++)
            {
                int number = Convert.ToInt32(strArray[j]);
                intArray[j] = number;
            }  //得到用户输入的一组数字  
            
            int m = intArray[0];
            int n = intArray[1];

            for(int i = m; i < n + 1; i++)
            {
                //判断i是否是素数
                bool isSu = true;  
                for(int j = 2; j < i; j++)   //2~i-1
                { 
                   if (i % j == 0) //被整除
                    { 
                       isSu = false;
                       break;
                    }
                }

                if (isSu)   //是素数
                {
                    //取得反序 i    
                    // 624  
                    int temp = i;
                    int number = 0;
                    while ( temp%10!=0 )   // 426    (6*10+2)*10+4
                    {
                        number = number * 10 + temp % 10;
                        temp = temp / 10;
                    }
                    
                bool isSuFan =  true;  
                for(int j = 2; j < number; j++)   
                    { 
                       if (number % j == 0) //被整除
                        { 
                           isSuFan = false;
                           break;
                        }
                    }
                    if (isSuFan == true)
                    {
                        Console.Write(i + " ");
                    }
                }
            }
```  

改良后
```c#
           // 定义方法
           static bool IsSu(int number)
           {
            bool isSu = true;
            for (int j = 2; j < number-1; j++)  //2~i-1
                {
                    if (number % j == 0)
                    {
                        isSu = false;
                        return isSu;
                    }
                }
            return isSu;
           } 
        // 调用
        static void Main(string[] args)   //主函数入口
        {
            // m<=n
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int j = 0; j < strArray.Length; j++)
            {
                int number = Convert.ToInt32(strArray[j]);
                intArray[j] = number;
            }   //得到用户输入的一组数字  
            
            int m = intArray[0];
            int n = intArray[1];

            for(int i = m; i < n + 1; i++)
            {
                //判断i是否是素数
                //取得反序
                //判断是否是素数
                bool isSu = IsSu(i); //调用函数
                if (isSu)  //是素数
                {
                    //取得反序 i
                    // 426    (6*10+2)*10+4
                    // 624  
                    int temp = i;
                    int number = 0;
                    while ( temp%10!=0 )
                    {
                        number = number * 10 + temp % 10;
                        temp = temp / 10;
                    }

                    bool isSuFan = IsSu(number);  //调用函数
                    if (isSuFan == true)
                    {
                        Console.Write(i + " ");
                    }
                }
            }
        }
``` 
```c#
函数的定义和使⽤
static void Verify()  //static 静态的  void 返回值（可以不需要） Verify()方法名（参数）
{   
//程序段
}
Verify();  //调用 

函数的参数(形参和实参)
static void Add(int a,int b){
}
Add(23,1); //(实际参数）  

函数的返回值
static int Add(int a,int b){
 return a+b;
}
```

:::info{title="相关信息"}
return⽤来结束当前函数，并把某个结果返回
  
如果是void的可以直接return; 
:::



❓练习2  
定义⼀个函数，⽤来取得⼀个数字的所有因⼦，把所有因⼦返回。  
```c#
//定义函数
        static int[] GetIn(int number)
        {
            int count = 0;
            for (int i = 1; i < number + 1; i++)
            {
                if (number % i == 0)  //计算有多少个因子
                {
                    count++;
                }
            }
            int[] array = new int[count];
            int index = 0; //位置索引
            for(int i = 1; i < number + 1; i++) 
            {
                if (number % i == 0)  //创建数组
                {
                    array[index] = i;
                    index++;
                }
            }
            return array;  //返回数组
        }

//主函数入口
        static void Main(string[] args)
        {
            int number = Convert.ToInt32(Console.ReadLine());
            int[] array = GetIn(number);  //调用函数
            foreach(int temp in array)
            {
                Console.Write(temp + " ");
            }
        }
```  

❓练习3   
定义⼀个函数，⽤来取得⼀个数组中的最⼤值。  
```c#
//定义函数
        static int Max(int[] array)
        {
            int max = array[0];
            for(int i = 1; i < array.Length; i++)
            {
                if (array[i] > max)
                {
                    max = array[i];
                }
            }
            return max;
        }
 //主函数入口
         static void Main(string[] args)
        {
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] intArray = new int[strArray.Length];
            for (int j = 0; j < strArray.Length; j++)
            {
               int number = Convert.ToInt32(strArray[j]);
               intArray[j] = number;
            }
            int n = Max(intArray); //调用
            Console.WriteLine(n);
        }
```

:::note{title="注"}
1、函数的⼏个要素  
  - 返回值、参数、函数名。  
  
2、函数的修饰（static）  
  - 其他的东⻄都是修饰 
:::

函数

张三的零花钱  

不知道你有没有零花钱？你是如何管理⾃⼰的零花钱的？  

张三总爱乱花钱。每个⽉的⽉初妈妈给张三300元钱 ，张三会预算这个⽉的花销，并且能做到实际的花销和预算相同。为了让张三学会对⾦钱的管理，妈妈提出，张三可以随时把整百的前存在她那⾥，到了12⽉31⽇，他会加上20%还给张三，也就是说，张三给妈妈的每⼀个100元，到年底都会变成120元！因此张三制定了⼀个存储计划：每个⽉的⽉初，在得到妈妈给的零花钱后，如果他预计到这个⽉的⽉末⼿中还会有多于100元或恰好100元，他就会把整百的钱存在妈妈那⾥，剩余的钱存在⾃⼰⼿⾥。⽐如11⽉初张三⼿中还有83元，妈妈留了张三300元。张三预计11⽉的花销是180元，那么他就会在妈妈那⾥存200元，⾃⼰留下183元。到了11⽉⽉末，张三⼿中会剩下3元钱。  

张三发现这个存储计划的主要⻛险是，存在妈妈那⾥的钱在年末之前不能取出。有可能在某个⽉的⽉初，张三⼿中的钱加上这个⽉妈妈给的钱，不够这个⽉的预算。如果出现这种情况，张三将不得不在这个⽉省吃简⽤，压缩预算。  

现在请你根据2019年1⽉到12⽉每个⽉张三的预算，判断会不会出现这种情况。如果储蓄计划实施过程中会出现某个⽉钱不够⽤的情况，输出-x,x表⽰出现这种情况的第⼀个⽉；如果不会，计算到2019年12⽉31⽇，妈妈将张三平时存的钱加上20%还给张三后，张三⼿⾥会有多少钱。  

样例输⼊  
240 280 200 300 120 350 80 50 270 260  
样例输出  
-7  


样例输⼊  
290 230 280 200 300 170 130 50 90 80 200 300  
样例输出  
1520  

```c#
            string str = Console.ReadLine();
            string[] strArray = str.Split(" ");
            int[] budget = new int[strArray.Length];
            for (int j = 0; j < strArray.Length; j++)
            {
                int n = Convert.ToInt32(strArray[j]);
                budget[j] = n;
            }  //获得一组数字  
            
            int self = 0;  //自己的
            int mom = 0;   //m妈妈给的
            int i = 0;   //哪一个月
            int tmp = 0;  //预算

            for (i = 0; i < 12; i++)  //0-11  i+1
            {
                //本月一共有多少300+self
                //预算budget[i]
                tmp = 300 + self - budget[i];  //剩余的钱  280/100 = 2*100 =200
                if (tmp < 0)
                {
                    //i+1
                    break;
                }
                //整百的
                mom += (tmp / 100)*100;
                self = tmp % 100;
            }
            if (tmp < 0)
            {
                Console.WriteLine("-" + (i + 1));
            }
            else
            {
                self = self + (int)(mom * 1.2);
                Console.WriteLine(self);
            }
```

模拟法

msvalidate.01

360-site-verification

sogou_site_verification

script

《千纸鹤》是一个关于个人成长、心灵探索和生活哲学的博客。通过结合纸鹤的象征意义，博客传递着希望、自由、勇气和梦想的理念，分享作者在人生旅途中所遇到的挑战与感悟。每一篇文章都如同一只飞翔的纸鹤，轻盈地载着思想与情感，带领读者在迷茫与困顿中找到属于自己的方向。