题目描述 

本题要求实现一个计算m~n（m< 

n）之间所有整数的和的简单函数。 

函数接口定义： 

int sum( int m, int n );

判测试程序样例：

#include <stdio.h>

int sum(int m, int n);

int main()
{    
    int m, n;

    scanf("%d %d", &m, &n);
    printf("sum = %d\n", sum(m, n));

    return 0;
}

/* 你的代码将被嵌在这里 */

样例输入 

1 5 

样例输出 

15

分析 

主函数题目中都已经给出了，那这题还需要做什么(╯‵□′)╯︵┻━┻

#include <stdio.h>
int sum(int n,int m);

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    printf("%d\n",sum(n,m));
    return 0;
}

int sum(int n,int m)                //累加求和
{
    int i,sum=0;
    for(i = n;i <= m;i++)
    {
        sum += i;
    }
    return sum;
}

M函数文件:

函数文件的第一行必须包含关键字“function”，表示m文件是函数文件，其基本格式如下：

function [输出参数形式] = 函数名 （函数形参表）

注释说明语句段

程序语句段

其中：

输出形参表：用方括号括起来的输出形参表是函数经过运算后所得到的结果变量列表

函数名：是要定义的函数名字，一般由字母，数字和下划线组成，其命名规则和变量名命名规则相同

输入形参表：是函数输入参数列表，列表中参数与参数之间用逗号来分割，是函数从外界接受数据的接口

运用示例：

编写一个求n！的阶乘函数

分析：阶乘n！的数学定义为：

n！= n*(n-1)*(n-2)*...*2*1;且规定0！= 1；

程序：

function p = fac(n)

%fac函数用于计算n！
%对应于参数n的实参应该是非负整数

if n == 0
     p = 1;
else 
     p = 1;
     i = 1;
     while i<= n 
           p = p*i;
           i = i+1;
     end
end 

函数的调用：

编写好函数文件后，就可以调用该函数来进行计算了，其方法与调用系统标准函数库文件没有本质区别

调用格式为：

[输出实参列表]=[输入实参列表]

要注意的是，在函数调用时会将输出实参依次传递给函数的形参，因此，输入实参必须与函数定义的形参中各个参数出现的次序必须完全一致，否则会出错。

比如，现在调用上面编好的函数：

>>fac(7)
  ans = 
      5040

当然，对于已编好的阶乘函数，也可以像系统提供的标准函数库一样，在其他的计算文件中调用。

如：求1！+2！+3！+...+7!

sum = 0;
for i = 1 : 7;
      sum = sum + fac(i);
end
sum

运用M函数文件示例：

采用递归法求 n！

分析：由阶乘的概念可以写出其递归定义：

0！= 1

n! = n*(n-1)

程序：

function p = factorial(n)

%factorial函数用于计算n！
%对应于参数n的实参应该是非负整数

if n == 0
     p = 1;
else 
     p = n*factorial(n-1)
end 

输出示例：

>>factorial(7)
  ans = 
      5040

 

 

 

 

#include <stdio.h>

int fun(int m,int n)

{

int i,t=0;

for(i=m;i<=n;i++)

t+=i;

return t;

}

int main()

{

int m,n;

printf(“输入m,n的值:”);

scanf("%d%d",&m,&n);

printf("%d~%d之间所有整数的和为%d\n",m,n,fun(m,n));

}

给定能随机生成整数 1 到 n 的函数,写出能随机生成整数 1 到 m 的函数（m > n）。
设 n = 5， m = 7

关键是让生成的 1 到 7 的数出现概率相同。调用 n 次给定函数,生成 n 个 1 到 5

之间的随机数,选取最大数所在位置,直到剩下最后一个。如:

初始的 7 个数 [1, 2, 3, 4, 5, 6, 7]。

(1)7 个 1 到 5 的随机数,如 [5, 3, 1, 4, 2, 5, 5];

(2)最大的数(此时为 5)出现的位置为 1,6,7.因此选择[1,6,7](后续步骤是要在这三个

数中选择,直至剩下一个数);

(3)3 个 1 到 5 的随机数,如[2,4,1];

(4)最大的数(此时为 4)出现的位置为 2,因此选择[6]

此时 6 就是产生的 1-7 之间的随机数。

代码如下：
int getRandM(int m)
{
    int rands[m + 1], index[m + 1], result[m + 1];
    int i, count;
    for (i = 1; i <= m; i++)
        rands[i] = getRandN();

    count = m;
    count = indexOfMaxNumber(rands, index, count);
    for (i = 1; i <= count; i++)
        result[i] = index[i];

    do {
        for (i = 1; i <= count; i++) 
            rands[i] = getRandN();
        count = indexOfMaxNumber(rands, index, count);
        for (i = 1; i <= count; i++)
            result[i] = result[index[i]];
    } while(count > 1);
    return result[1];
} 


其中产生1到N的随机函数如下：
int getRandN()
{
//  srand((unsigned)time(NULL)); /*随机种子*/  
    return rand() % N + 1;
}


找出随机数序列中最大数位置的函数如下：
int indexOfMaxNumber(int rands[], int index[], int count)
{
    int i, max, countMax;
    for (max = rands[1], i = 2; i <= count; i++)
        if (rands[i] > max)
            max = rands[i];
    for (countMax = 0, i = 1; i <= count; i++)
        if (max == rands[i])
            index[++countMax] = i;
    return countMax;
}


测试代码如下：
#include <stdio.h>                                                                             
#include <stdlib.h>
#include <time.h>

#define N 5

int getRandN();
int indexOfMaxNumber(int rands[], int index[], int count);
int getRandM(int m);
int main(void) 
{
    srand((unsigned)time(NULL)); /*随机种子*/
    // n = rand() % (Y - X + 1) + X; /*n为X~Y之间的随机数*/
    int i;
    for (i = 0; i < 10; i++)
        printf("%d ", getRandM(7));
    printf("\n");
    return 0;
}


输出：






下面是Java代码的实现：
import java.util.Random;                                                                      
public class RandMfromRandN {
    private static Random rand = new Random();
    private final int n;
    public RandMfromRandN(int n) {
        this.n = n;
    }
    public int getRandN() {
        return rand.nextInt(n) + 1;
    }

    public int indexOfMaxNumber(int[] rands, int[] index, int count) {
        int max, countMax;

        max = rands[1];
        for (int i = 2; i <= count; i++)
            if (rands[i] > max)
                max = rands[i];

        countMax = 0;
        for (int i = 1; i <= count; i++)
            if (rands[i] == max)
                index[++countMax] = i;
        return countMax;
                
    }
    public int getRandM(int m) {
        int[] rands = new int[m + 1];
        int[] index = new int[m + 1];
        int[] result = new int[m + 1];
        int count;

        for (int i = 1; i <= m; i++) 
            rands[i] = getRandN();
        
        count = m;
        count = indexOfMaxNumber(rands, index, count);
        for (int i = 1; i <= count; i++)
            result[i] = index[i];

        do {
            for (int i = 1; i <= count; i++) 
                rands[i] = getRandN();
            count = indexOfMaxNumber(rands, index, count);
            for (int i = 1; i <= count; i++)
                result[i] = result[index[i]];
        } while(count > 1);
        return result[1];
    }

    public static void main(String[] args) {
        RandMfromRandN nm = new RandMfromRandN(5);
        for (int i = 1; i <= 10; i++)
            System.out.print(nm.getRandM(7) + " ");
        System.out.println();
    }
} 


输出：