递归函数  

❓问题
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

baidu-site-verification

95f521bf6bd97279d4c7d479ce66ad91_1745636273

shenma-site-verification

script

link

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