第9题：编写函数fun，它的功能是：根据公式 P = ( m!)/(n!(m-n)!) 求P的值，结果由函数值带回。m与n为两个正整数且要求m＞n。例如: m=12，n=8时，运行结果为495.000

最新推荐文章于 2024-04-27 11:13:02 发布
最新推荐文章于 2024-04-27 11:13:02 发布
阅读量1.3k 收藏 6
点赞数 2
分类专栏： ChatGPT C问答 文章标签： 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zp1990412/article/details/130867482
版权

请添加图片描述

C试题

第9题：编写函数fun，它的功能是：根据公式 P = ( m!)/(n!(m-n)!) 求P的值，结果由函数值带回。m与n为两个正整数且要求m＞n。例如: m=12，n=8时，运行结果为495.000000.

ChatGPT回答如下：

主要考察了以下几个知识点：

这道题考察了C语言的函数、循环、数据类型、运算符等知识点。回。

该程序的解题思路：

  1. 定义一个函数fun，参数为m和n，返回值为P。

  2. 在函数中，先判断m是否大于n，如果不是，则输出错误信息并返回0。

  3. 如果m大于等于n，则定义三个变量m_factorial、n_factorial和diff_factorial，分别表示m的阶乘、n的阶乘和(m-n)的阶乘。

  4. 使用循环计算m的阶乘，n的阶乘和(m-n)的阶乘。

  5. 根据P的公式计算P的值，并返回结果。

  6. 在主函数中调用fun函数，输入m和n的值，并输出P的值。

解法一：C语言代码：

#include <stdio.h>

double fun(int m, int n);

int main()
{
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("P = %lf\n", p);
    return 0;
}

double fun(int m, int n)
{
    int i;
    double p = 1.0;
    for (i = n + 1; i <= m; i++) {
        p *= i;
    }
    for (i = 1; i <= m - n; i++) {
        p /= i;
    }
    return p;
}

在这个程序中，我们先定义了一个函数fun来计算P的值，然后在主函数中调用该函数并输出结果。当m=12，n=8时，运行结果为495.000000，符合题目要求。

解法二：C语言代码：

#include <stdio.h>

double fun(int m, int n) {
    if (m <= n) {
        printf("Error: m should be greater than n.\n");
        return 0;
    }
    double m_factorial = 1, n_factorial = 1, diff_factorial = 1;
    for (int i = 1; i <= m; i++) {
        m_factorial *= i;
        if (i <= n) {
            n_factorial *= i;
        }
        if (i <= m - n) {
            diff_factorial *= i;
        }
    }
    double P = m_factorial / (n_factorial * diff_factorial);
    return P;
}

int main() {
    int m = 12, n = 8;
    double P = fun(m, n);
    printf("P = %lf\n", P);
    return 0;
}

运行结果为：

P = 495.000000

解法三：C语言代码：

#include <stdio.h>

double fun(int m, int n) {
    int i;
    double p = 1;
    for (i = 1; i <= n; i++) {
        p *= (double)(m - n + i) / i;
    }
    return p;
}

int main() {
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("%.6lf", p);
    return 0;
}

这个通用写法使用了数学公式，直接计算出P的值。难点在于要注意数据类型转换，以及避免除以0的情况。另外，需要保证m>n。

解法四：C语言代码：指针写法

#include <stdio.h>

double fun(int m, int n) {
    int i;
    double p = 1;
    double *temp = (double*)malloc(n * sizeof(double));
    temp[0] = 1;
    for (i = 1; i <= n; i++) {
        temp[i] = temp[i - 1] * (double)(m - n + i) / i;
    }
    p = temp[n];
    free(temp);
    return p;
}

int main() {
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("%.6lf", p);
    return 0;
}

这个指针写法使用了动态内存分配，将中间结果保存在一个数组中。难点在于需要注意内存的申请和释放，以及数组的下标从0开始。

解法五：C语言代码： 数组写法

#include <stdio.h>

double fun(int m, int n) {
    int i;
    double p = 1;
    double temp[n + 1];
    temp[0] = 1;
    for (i = 1; i <= n; i++) {
        temp[i] = temp[i - 1] * (double)(m - n + i) / i;
    }
    p = temp[n];
    return p;
}

int main() {
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("%.6lf", p);
    return 0;
}

这个数组写法和指针写法类似，只是没有使用动态内存分配，而是直接定义了一个数组。难点在于需要注意数组的大小，以及数组的下标从0开始。

解法六：C语言代码： 栈写法

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int m;
    int n;
    double p;
} Item;

typedef struct {
    int top;
    int size;
    Item *data;
} Stack;

void init(Stack *s, int size) {
    s->top = -1;
    s->size = size;
    s->data = (Item*)malloc(size * sizeof(Item));
}

void push(Stack *s, Item item) {
    s->top++;
    s->data[s->top] = item;
}

Item pop(Stack *s) {
    Item item = s->data[s->top];
    s->top--;
    return item;
}

int is_empty(Stack *s) {
    return s->top == -1;
}

double fun(int m, int n) {
    Stack s;
    init(&s, n + 1);
    Item item;
    item.m = m;
    item.n = n;
    item.p = 1;
    push(&s, item);
    while (!is_empty(&s)) {
        item = pop(&s);
        m = item.m;
        n = item.n;
        if (n == 0) {
            item.p = 1;
        } else if (n == 1) {
            item.p = (double)m;
        } else {
            Item item1;
            item1.m = m - 1;
            item1.n = n - 1;
            push(&s, item1);
            Item item2;
            item2.m = m - 1;
            item2.n = n;
            push(&s, item2);
        }
        item.p *= (double)m / (m - n + 1);
        if (n > 1) {
            push(&s, item);
        } else {
            item.p *= (double)m;
        }
    }
    return item.p;
}

int main() {
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("%.6lf", p);
    return 0;
}

这个栈写法使用了一个栈来保存中间结果，以便进行回溯。难点在于需要注意栈的初始化、入栈和出栈操作，以及回溯的条件和计算公式。

解法七：C语言代码：队列写法

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int m;
    int n;
    double p;
} Item;

typedef struct {
    int front;
    int rear;
    int size;
    Item *data;
} Queue;

void init(Queue *q, int size) {
    q->front = 0;
    q->rear = 0;
    q->size = size;
    q->data = (Item*)malloc(size * sizeof(Item));
}

void enqueue(Queue *q, Item item) {
    q->data[q->rear] = item;
    q->rear = (q->rear + 1) % q->size;
}

Item dequeue(Queue *q) {
    Item item = q->data[q->front];
    q->front = (q->front + 1) % q->size;
    return item;
}

int is_empty(Queue *q) {
    return q->front == q->rear;
}

double fun(int m, int n) {
    Queue q;
    init(&q, n + 1);
    Item item;
    item.m = m;
    item.n = n;
    item.p = 1;
    enqueue(&q, item);
    while (!is_empty(&q)) {
        item = dequeue(&q);
        m = item.m;
        n = item.n;
        if (n == 0) {
            item.p = 1;
        } else if (n == 1) {
            item.p = (double)m;
        } else {
            Item item1;
            item1.m = m - 1;
            item1.n = n - 1;
            item1.p = 1;
            enqueue(&q, item1);
            Item item2;
            item2.m = m - 1;
            item2.n = n;
            item2.p = 1;
            enqueue(&q, item2);
        }
        item.p *= (double)m / (m - n + 1);
        if (n > 1) {
            enqueue(&q, item);
        } else {
            item.p *= (double)m;
        }
    }
    return item.p;
}

int main() {
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("%.6lf", p);
    return 0;
}

首先，在这段代码中，定义了两个结构体类型：Item和Queue。

其中，Item结构体表示一个组合问题中的一项，包括m、n、p三个成员变量，分别表示组合中的元素个数、选取的元素个数以及概率。Queue结构体表示一个队列，包括front、rear、size和data四个成员变量。其中，front和rear分别表示队列的头和尾，size表示队列的大小，data是一个指向Item类型数据的指针。

接着，在代码中定义了几个函数。init函数用于初始化队列，enqueue函数用于向队列中添加元素，dequeue函数用于从队列中取出元素，is_empty函数用于判断队列是否为空。这些函数都是对队列的基本操作，可以在其他程序中重复使用。

然后，在fun函数中，先创建一个队列q，并将初始状态加入队列中，初始状态即为m、n和p分别为函数参数m、n和1的Item结构体。然后，通过while循环不断从队列中取出元素，处理后再将新的元素加入队列中，直到队列为空为止。

在处理每个元素时，先从元素中取出m、n和p的值，判断n的值，如果n为0，则p为1；如果n为1，则p为m；否则，需要将元素分解成两个新的元素，分别表示选取了当前元素和未选取当前元素的情况，将这两个新元素加入队列中。

接着，计算当前元素的p值，即将m个元素选取n个元素的概率，通过公式（m!/(m-n)!n!）计算得出。如果n大于1，则将当前元素重新加入队列中；否则，p值再乘上m，即为最终的结果。

最后，在main函数中，设定m和n的值，调用fun函数计算出结果并输出。

在这段代码中，需要注意的是，队列中存储的元素是Item类型的结构体，需要注意结构体的初始化和赋值方式。同时，在计算概率时，需要注意数据类型转换和计算顺序。

这个队列写法和栈写法类似，只是使用了队列来保存中间结果。难点在于需要注意队列的初始化、入队和出队操作，以及回溯的条件和计算公式。

解法八：C语言代码：链表写法

#include <stdio.h>
#include <stdlib.h>

// 定义链表结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 定义函数fun，使用递归方式计算P的值
double fun(int m, int n) {
    if (n == 0 || n == m) {
        return 1;
    } else {
        return fun(m - 1, n - 1) + fun(m - 1, n);
    }
}

// 定义函数createList，创建一个长度为length的链表，并返回头结点指针
Node* createList(int length) {
    Node* head = NULL;
    Node* tail = NULL;
    for (int i = 0; i < length; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        if (head == NULL) {
            head = node;
        } else {
            tail->next = node;
        }
        tail = node;
    }
    return head;
}

// 定义函数freeList，释放整个链表的内存空间
void freeList(Node* head) {
    while (head != NULL) {
        Node* node = head;
        head = head->next;
        free(node);
    }
}

int main() {
    int m = 12, n = 8;
    double p = fun(m, n) / 1.0;
    printf("P = %.6f\n", p);

    // 使用createList函数创建一个长度为10的链表，并打印每个节点的值
    Node* head = createList(10);
    Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");

    // 释放链表的内存空间
    freeList(head);

    return 0;
}

在这段代码中，我们首先定义了一个结构体Node，表示链表中的一个节点，其中包含一个整数data和一个指向下一个节点的指针next。然后，我们定义了一个函数fun，使用递归方式计算P的值。这个函数的实现方式比较简单，就是按照公式P = (m!)/(n!(m-n)!)进行递归计算。如果n等于0或m等于n，直接返回1即可。否则，就递归调用fun函数，分别计算m-1和n-1以及m-1和n的值，并将它们相加。

接下来，我们定义了两个函数createList和freeList，分别用于创建链表和释放链表的内存空间。函数createList接收一个参数length，表示要创建的链表的长度。在函数内部，我们使用一个循环，创建length个节点，并将它们连接成一个链表。每个节点的值都是当前的循环变量i。函数freeList接收一个参数head，表示链表的头结点指针。在函数内部，我们使用一个循环，依次释放每个节点的内存空间，直到链表为空。

在主函数中，我们首先调用fun函数，计算出P的值，并将结果赋值给变量p。然后，我们使用printf函数打印出P的值。接下来，我们使用createList函数创建一个长度为10的链表，并打印出每个节点的值。最后，我们调用freeList函数释放链表的内存空间。

解法九：C语言代码：

好的，下面是使用动态内存的C语言代码：

#include <stdio.h>
#include <stdlib.h>

double fun(int m, int n);

int main()
{
    int m = 12, n = 8;
    double p = fun(m, n);
    printf("%.6f\n", p);
    return 0;
}

double fun(int m, int n)
{
    double *p, *q, *r;
    int i, j;

    p = (double *)malloc((m + 1) * sizeof(double)); // 申请动态内存
    q = (double *)malloc((n + 1) * sizeof(double));
    r = (double *)malloc((m - n + 1) * sizeof(double));

    for (i = 0; i <= m; i++) {
        p[i] = 1.0;
    }

    for (i = 1; i <= n; i++) {
        q[i] = 1.0;
        r[i] = 1.0;
    }

    for (i = 1; i <= m; i++) {
        for (j = 1; j <= n; j++) {
            if (i == j) {
                q[j] = p[j] = 1.0;
            } else {
                q[j] = q[j - 1] * j;
                p[j] = p[j - 1] * i;
            }
        }
        for (j = 1; j <= m - n; j++) {
            r[j] = r[j - 1] * (i - n);
        }
    }

    double ans = p[n] / (q[n] * r[m - n]);
    free(p); // 释放动态内存
    free(q);
    free(r);
    return ans;
}

函数fun的主要思路是利用动态内存分配来避免数组越界的问题。首先，我们根据公式申请三个动态内存，分别存储m、n、m-n的阶乘。然后，我们利用三个循环分别计算三个阶乘的值，并将结果存储在相应的数组中。最后，按照公式计算P的值，并释放动态内存。

在代码实现过程中，需要注意以下几个问题：

  1. 动态内存的申请和释放必须对应，否则会出现内存泄漏或者非法访问的问题；
  2. 需要注意循环的起始和终止条件，否则会出现数组越界的问题；
  3. 在计算阶乘的过程中，需要特别处理0!和1!的情况；
  4. 在计算P的过程中，需要注意先后顺序和数据类型的转换。

回答结果是否让你满意，欢迎指正。

zp1990412
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C语言试题十九之根据以下公式求p的值，结果由函数值带回。M与n为两个正整数，且要求m＞n。 p=m!/n!(m-n)!
码莎拉蒂
05-27 4613
1、 题目 编写函数function,功能是：根据以下公式求p的值，结果由函数值带回。M与n为两个正整数，且要求m>n。 p=m!/n!(m-n)! 2 、温馨提示 大家好，如果程序有任何看不懂或者哪个步骤不理解的地方都可以加我微信（15874274916）私聊我，哪个步骤有问题也可以私聊我，或者有更好的思路解决办法都可以加我微私聊，一起探讨、一起进步、希望可以正真的帮助到你，同时也可以扫下面的二维码关注我微信公众...
根据以下公式求p的值，结果由函数值带回
07-11
编写函数fun,其功能是：根据以下公式求p的值，结果由函数值带回。M与n为两个正整数且要求m>n。 P=m!/n!(m-n)! 例如：m=12,n=8时，运行结果为495.000000 注意：部分源程序在文件PROJ1.C中。 请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。
实验五（递归函数）
m0_74023835的博客
03-16 174
这个题目的本质就是考察对求余符号的理解int main()//数组1~10代表十个洞，初始值为0，当狐狸进去后洞变为非零//i从0开始，即狐狸刚开始在最后一个洞里//当循环次数足够多时，剩余的洞口即为兔子可能藏在的地方for(i=10;n
JAVA 输入两个正整数m和n，求其最大公约数和最小公倍数。 1.程序分析：利用辗除法。
梦想巅峰
04-11 6568
//【程序6】Test1.java GcdTest.java后者是辗转相除法 题目： //输入两个正整数m和n，求其最大公约数和最小公倍数。 1.程序分析：利用辗除法。 public class GcdTestApp { /** * @param args */ public static void main(String args[]){ valuePrint vp=n
每日一练
专栏
12-07 371
1.编写一个函数fun，它的功能是：根据以下公式求P的值，p=m!/n!(m-n)! , 结果由函数值带回。m与n为两个正整数，且要求m>n。       #include using namespace std; int fun(unsigned int n,unsigned int m); int main() {        unsigned int a,b;
2021年春季ACM训练赛第5场
a碟的博客
04-11 2998
目录问题 A: 努力的虫子问题 B: 六位数问题 C: 小h的工具人问题 D: 小h的礼物问题 E: 小h的书桌问题 F: 河畔军训问题 G: 小A的烦恼问题 H: l/n不分的小波 问题 A: 努力的虫子 题目描述 一只虫子掉到枯井里，它每天白天都会向上爬n厘米，但是晚上休息时会下降若干厘米。通过分析发现，第1天晚上虫子会下降n/2厘米，第2天晚上虫子会下降(n/2+n/4)厘米，第3天晚上虫子会下降(n/2+n/4+n/8)厘米，…，以此类推。 如果井的深度为m米，请问这只努力的虫子第几天能够爬出枯井？
求排列数.
weixin_45975504的博客
11-28 1363
其中n是用户传入的参数，函数返回n的阶乘。
编写函数fun,它的功能是:根据以下公式求P的值,结果由函数值带回。m与n为两个正整数且要求m＞n。p=m!/n!(m-n)!。例如:m=12,n=8时,运行结果为495.000000。
2301_77685192的博客
06-27 195
float p;for (i = 1;i <= m;i++)for (i = 1;i <= n;i++)for (i = 1;i <= m - n;i++)return p;int main()int m, n;float p;
C语言—函数，请编写函数fuc（）,函数的功能是： 根据以下公式求出p的值，结果由函数值返回。m , n 是两个正整数，
WZY22502701的博客
03-26 2299
请编写函数fuc（）,函数的功能是： 根据以下公式求出p的值，结果由函数值返回。m , n 是两个正整数，且 m>n. P= m!/(n!*(m-n)!) **输入格式要求："%d %d" 提示信息："请输入m,n的值( m>n )：\n" **输出格式要求："n项之和为：%lf\n" 程序运行示例如下： 请输入m,n的值( m>n )： 5 3 n项之和为：10.000000 #include <stdio.h> double fac(int m, int n) {.
PTA-C程序语言设计｜函数题 Part A
weixin_49503909的博客
04-07 1177
PTA-C程序语言设计｜函数题 例题1 使用函数生成一张阶乘表 本题要求实现一个计算阶乘的简单函数，使得可以利用该函数，生成一张阶乘表，输出0!~n!的值。 要求： n是用户传入的参数，函数返回n的阶乘。 函数接口定义： double fact( int n ); 代码展示 double fact(int n) { int x; double result; result = 1; if (n==0) { result = 1; } else { for (x=n;x>=1;x--
C语言程序设计-编写函数fun其功能是：根据整型形参m，计算如下公式的值：y=12!+14!+…+1m!（m是偶数）
03-21
C语言程序设计-编写函数fun其功能是：根据整型形参m，计算如下公式的值：y=1/2!+1/4!+…+1/m!（m是偶数）
C语言程序设计-编写函数fun其功能是：根据整型形参m，计算如下公式的值：y=1＋13＋15＋17＋…＋1(2m+1)
11-08
C语言程序设计-编写函数fun其功能是：根据整型形参m，计算如下公式的值：y=1＋1/3＋1/5＋1/7＋…＋1/(2m+1)例如：若m=9，则应输出：2.133256
C语言程序设计-编写main程序调用函数fact求解从m个元素选n个元素的组合数的个数;组合数＝m!(n!.(m-n)!);
11-01
C语言程序设计-编写main程序调用函数fact求解从m个元素选n个元素的组合数的个数;计算公式是： 组合数＝m!(n!.(m-n)!);要求m不能小于n，否则应有容错处理;说明：函数fact(x)的功能是求x!;
C语言程序设计-编写函数fun，求任一整数m的n次方;.c
11-08
C语言程序设计-编写函数fun，求任一整数m的n次方;.c
代码随想录算法训练营day53
最新发布
Mitakiyuki的博客
04-27 216
从前到后遍历。
偏微分方程算法之五点菱形差分法
L_peanut的博客
04-26 527
主要对二维椭圆型方程的五点菱形差分算法进行推导及算例的C++实现。
算法训练营day21
wugong_true的博客
04-23 388
接下来，根据计数count与最大计数maxCount的比较，更新众数的结果数组resList和最大计数maxCount。如果count大于maxCount，则清空resList并将当前节点值添加进去，并更新maxCount为count；接着，根据resList中的众数，创建一个整型数组res，并将其返回作为结果。然后，通过与前一个节点的值进行比较，判断当前节点值出现的次数。如果当前节点与前一个节点的值不同，说明出现了一个新的值，将计数count重置为1；，计算相邻两个元素的差值，并将较小的差值更新到。
排序算法-快速排序
分享我的点点滴滴，在成长路上与你同行！
04-23 885
排序算法-快速排序
二分搜索法
m0_73950754的博客
04-26 223
二分搜索法
用c语言编写函数fun()，根据公式p=m!/(n!*(m-n)!)求p的值，结果由函数值返回。
05-28
好的，以下是用C语言编写的函数fun()，可根据公式p=m!/(n!*(m-n)!)求p的值，并将结果作为函数值返回。 ```c #include <stdio.h> int factorial(int num) { if (num == 0) { return 1; } else { return num * factorial(num - 1); } } int fun(int m, int n) { int p = factorial(m) / (factorial(n) * factorial(m - n)); return p; } int main() { int m, n; printf("请输入m和n的值：\n"); scanf("%d %d", &m, &n); int result = fun(m, n); printf("结果为：%d", result); return 0; } ``` 在这个程序中，我们定义了一个名为factorial()的函数来计算一个数的阶乘。然后，我们定义了一个名为fun()的函数来计算公式p=m!/(n!*(m-n)!)的值，并将结果作为函数值返回。 在主函数中，我们从用户那里获取输入值m和n，并调用fun()函数来计算结果。最后，我们将结果打印在屏幕上。 希望这个程序能够回答你的问题！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zp1990412

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值