目录
编写子函数,该函数的功能是是计算下列级数和,并将和值返回主调函数输出。数据由主函数输入。
[fun 函数](#fun 函数)
[sum 函数](#sum 函数)
[main 函数](#main 函数)
[编写函数,该函数的功能是,将所有大于1小于整数m的非素数存入xx数组中, 非素数的个数通过k传回。整数m的值由主函数输入。](#编写函数,该函数的功能是,将所有大于1小于整数m的非素数存入xx数组中, 非素数的个数通过k传回。整数m的值由主函数输入。)
[Y(int num)](#Y(int num))
[NO(int n, int xx[], int *k)](#NO(int n, int xx[], int *k))
(填空题)写一个判断素数的函数,在主函数输入一个整数,输出是否素数的信息。程序文件名:
[素数判断函数 prime](#素数判断函数 prime)
(填空题)求两个数的最大公约数和最小公倍数,用一个函数求最大公约数。用另一个函数根据求出的最大公约数求最小公倍数。
编写函数,该函数的功能是将任意的十六进制数转换为相应的十进制数,并返回主调函数。要求在主函数中输入十六进制数,输出转换后十进制数。
该博客文章主要讨论了几个编程相关的话题,包括计算特定级数和、判断素数、找出非素数并存入数组、以及计算两个数的最大公约数(HCF)和最小公倍数(LCM)。下面是这些主题的总结和关键代码段的解释:
计算级数和
- 功能:计算形如 ∑𝑖=1𝑛𝑥𝑖−1𝑖!∑i=1ni!xi−1 的级数和。
- 关键函数 :
fun(int n)
计算阶乘 𝑛!n!。sum(double x, int n)
利用fun
计算上述级数的和。
- 注意 :当 𝑛n 很大时,
fun
可能会遇到浮点数溢出问题。
判断并找出非素数
- 功能:找出所有大于1小于给定整数 𝑚m 的非素数,并存储在数组中。
- 关键函数 :
Y(int num)
判断一个数是否为素数。NO(int n, int xx[], int *k)
找出所有非素数并存入数组xx
,通过指针k
返回非素数数量。
- 示例:输入测试数据为17时,输出结果是4到16之间的所有非素数。
主函数操作流程
- 输入:从用户处获取所需的数据,如 𝑥x、𝑛n 或 𝑚m。
- 处理:调用相应的函数进行计算或处理。
- 输出:显示计算结果或处理后的信息。
求最大公约数和最小公倍数
- 功能:编写两个函数,一个求最大公约数(HCF),另一个根据HCF求最小公倍数(LCM)。
- 关键代码 提供了函数定义和如何在主函数中调用这些函数来读取输入、计算HCF和LCM并打印结果的示例。
文章还包含了对各个函数的详细解释,包括如何判断素数、遍历整数范围、使用循环和条件语句进行计算,以及如何处理数组和指针传递。此外,还强调了在实现过程中应注意的潜在问题,比如数值溢出,以及可能的性能优化方案。
第1个。
你看就有点扯淡。(:3_ヽ)_写作业
编写子函数,该函数的功能是 是计算下列级数和,并将和值返回主调函数输出。数据由主函数输入。
cpp
#include <stdio.h>
double fun(int n) {
double result = 1.0;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
double sum(double x, int n) {
double s = 1.0;
double term = 1.0;
for (int i = 1; i <= n; i++) {
term *= x / fun(i);
s += term;
}
return s;
}
int main() {
double x;
int n;
printf("Enter the value of x: ");
scanf("%lf", &x);
printf("Enter the value of n: ");
scanf("%d", &n);
double result = sum(x, n);
printf("The sum of the series is: %lf\n", result);
return 0;
}
搞起
fun 函数
|---|-----------------------------------|
| |double fun(int n) {
|
| |double result = 1.0;
|
| |for (int i = 2; i <= n; i++) {
|
| |result *= i;
|
| |}
|
| |return result;
|
| |}
|fun
函数用于计算
n!(n 的阶乘)。它接受一个整数
n作为参数,并返回
n!的值。注意,由于
result初始化为
1.0,并且循环从
i = 2开始,这个函数实际上计算的是
n!而不是
0!或
1!`(这两者都是 1)。sum 函数
|---|-----------------------------------|
| |double sum(double x, int n) {
|
| |double s = 1.0; // 初始化级数和
|
| |double term = 1.0; // 当前项
|
| |for (int i = 1; i <= n; i++) {
|
| |term *= x / fun(i); // 计算下一项
|
| |s += term; // 累加到级数和
|
| |}
|
| |return s;
|
| |}
|sum
函数用于计算级数和。它接受两个参数:
x和
n。
s初始化为
1.0,因为级数的第一项是
1。在循环中,
term变量被更新为下一项的值(即
x^(i-1) / i!),并将其累加到
s` 中。main 函数
|---|-------------------------------------------------------|
| |int main() {
|
| |double x;
|
| |int n;
|
| |printf("Enter the value of x: ");
|
| |scanf("%lf", &x);
|
| |printf("Enter the value of n: ");
|
| |scanf("%d", &n);
|
| | |
| |double result = sum(x, n);
|
| |printf("The sum of the series is: %lf\n", result);
|
| |return 0;
|
| |}
|main
函数是程序的入口点。它首先声明了两个变量
x和
n,并使用
printf和
scanf函数从用户那里获取这两个变量的值。然后,它调用
sum函数来计算级数和,并将结果存储在
result变量中。最后,它使用
printf` 函数输出结果。注意事项
- 当
n
很大时,fun
函数可能会返回非常大的数,这可能会导致浮点数溢出。为了避免这种情况,你可能需要使用一种更精确的方法来计算阶乘,或者使用一种可以避免大数直接相乘的方法(例如,使用对数来计算)。
编写函数,该函数的功能是,将所有大于 1 小于整数 m 的非素数存入 xx 数组中, 非素数的个数通过 k 传回。整数 m 的值由主函数输入。
输入测试数据:17
程序运行结果: 4 6 8 9 10 12 14 15 16
cpp
#include <stdio.h>
#include <stdbool.h>
bool Y(int num) {
int i;
if (num <= 1) return false;
if (num <= 3) return true;
if (num % 2 == 0 || num % 3 == 0) return false;
for (i = 5; i * i <= num; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) return false;
}
return true;
}
void NO(int n, int xx[], int *k) {
*k = 0;
int i;
for (i = 2; i < n; i++) {
if (!Y(i)) {
xx[*k] = i;
(*k)++;
}
}
}
int main() {
int n, i;
printf("请输入一个整数n:");
scanf("%d", &n);
int xx[n];
int k;
NO(n, xx, &k);
printf("所有大于1小于%d的非素数为:\n", n);
for (i = 0; i < k; i++) {
printf("%d ", xx[i]);
}
printf("\n非素数的个数为:%d\n", k);
return 0;
}
这个程序包含两个函数:
Y(int num)
: 这是一个判断整数num
是否为素数的函数。如果num
是素数,返回true
;否则返回false
。NO(int n, int xx[], int *k)
: 这是一个找出所有大于1且小于整数n
的非素数的函数。这些非素数被存储在数组xx
中,非素数的个数通过指针k
返回。在
main
函数中,程序首先接收用户输入的整数n
,然后调用NO
函数找出非素数并打印它们。函数详细解释
Y(int num)
- 输入:一个整数
num
。- 输出:如果
num
是素数,返回true
;否则返回false
。函数首先处理了一些特殊情况:
- 如果
num
小于或等于1,它不是素数,直接返回false
。- 如果
num
小于或等于3,它是素数(因为2和3都是素数),返回true
。接下来,函数检查
num
是否能被2或3整除。如果可以,则num
不是素数,返回false
。最后,函数使用一个循环来检查
num
是否能被小于其平方根的任何奇数整除(只检查形如6k ± 1
的数,因为其他奇数不是素数因子)。如果num
能被这样的数整除,则它不是素数,返回false
。如果循环结束都没有找到任何因子,则num
是素数,返回true
。
NO(int n, int xx[], int *k)
- 输入:一个整数
n
,一个整数数组xx
用于存储非素数,一个整数指针k
用于返回非素数的个数。- 输出:无直接输出,但会修改
xx
数组和k
的值。这个函数首先初始化计数器
*k
为0。然后,它使用一个循环来遍历从2到n-1
的所有整数。对于每个整数,它调用Y
函数来判断它是否为素数。如果整数不是素数(即!Y(i)
为真),则将其添加到xx
数组中,并增加计数器*k
的值。
main()
- 输入:从用户那里接收一个整数
n
。- 输出:打印所有大于1且小于
n
的非素数,以及非素数的个数。在
main
函数中,程序首先提示用户输入一个整数n
,并读取这个输入。然后,它定义了一个大小为n
的整数数组xx
来存储非素数,并定义了一个整数k
来存储非素数的个数。接着,它调用NO
函数来找出非素数并将它们存储在xx
数组中,同时获取非素数的个数。最后,程序打印出所有的非素数和它们的个数。
(填空题)写一个判断素数的函数,在主函数输入一个整数,输出是否素数的信息。程序文件名:
第一次
输入测试数据: 12
程序运行结果: 12 is not a prime
第二次
输入测试数据: 37
程序运行结果: 37 is a prime
【需要填空的源程序】:
#include<stdio.h>
void main( )
{
int prime(int n);
int n;
printf("\nInput an integer");
scanf("%d",&n);
if ( ++【1】++ )
printf("\n%d is a prime",n);
else
printf("\n%d is not a prime",n);
}
int prime(int n)
{ int flag=1,i;
for (i=2;i<=n/2 &&flag ;i++)
if ( ++【2】++ ) flag=0;
return(++【3】++ );}
cpp
#include<stdio.h>
void main()
{
int prime(int n);
int n;
printf("\nInput an integer");
scanf("%d", &n);
if (prime(n))//【1】
printf("\n%d is a prime", n);
else
printf("\n%d is not a prime", n);
}
int prime(int n)
{
int flag = 1, i;
for (i = 2; i <= n / 2 && flag; i++)
if (n % i == 0) //【2】
flag = 0;
return(flag);//【3】
}
输入整数
|---|----------------------------------|
| |int n;
|
| |printf("\nInput an integer");
|
| |scanf("%d", &n);
|这部分代码首先声明了一个整数变量
n
,然后通过printf
函数输出提示信息,最后使用scanf
函数从标准输入读取一个整数并存储在n
中。
- 判断素数并输出结果
|---|-------------------------------------|
| |if (prime(n))//【1】
|
| |printf("\n%d is a prime", n);
|
| |else
|
| |printf("\n%d is not a prime", n);
|在
if
语句中,调用了prime
函数来判断n
是否为素数。如果prime
函数返回非零值(通常表示true
),则输出n
是素数;否则,输出n
不是素数。素数判断函数
prime
- 初始化
|---|--------------------|
| |int flag = 1, i;
|这里声明了两个整数变量
flag
和i
。flag
用于标记n
是否为素数(初始值为1
,表示假设n
是素数),i
用于循环中遍历从2
到n/2
的所有整数。
- 循环判断
|---|-----------------------------------------|
| |for (i = 2; i <= n / 2 && flag; i++)
|
| |if (n % i == 0) //【2】
|
| |flag = 0;
|这个
for
循环从2
开始,遍历到n/2
(实际上,循环可以优化为遍历到sqrt(n)
的整数部分,但这在题目要求中未提及)。在每次循环中,使用if
语句检查n
是否能被i
整除。如果n
能被i
整除(即n % i == 0
),则将flag
设置为0
,表示n
不是素数。
- 返回结果
|---|----------------------|
| |return(flag);//【3】
|最后,函数返回
flag
的值。如果n
是素数,则flag
保持为1
;否则,flag
被设置为0
。由于if
语句在main
函数中检查prime
函数的返回值,因此这个返回值直接决定了输出的是"n is a prime
"还是"n is not a prime
"。
下一个:
(填空题)求两个数的最大公约数和最小公倍数,用一个函数求最大公约数。用另一个函数根据求出的最大公约数求最小公倍数。
输入测试数据: 16,24
程序运行结果: H.C.F=8
L.C.D=48
【需要填空的源程序】:
#include<stdio.h>
int hcf(int u,int v)
{
int t,r;
if(v>u)
{t=u;u=v;v=t;}
while(++【1】++ )
{
u=v;
++【2】++ ++;++
}
++【3】++ ++;++
}
int lcd(int u,int v,int h)
{
++【4】++ ++;++
}
void main( )
{
int m,n,h,l;
scanf("%d,%d",&m,&n);
h=++【5】++ ;
printf("H.C.F=%d\n",h);
l=++【6】++ ;
printf("L.C.D=%d\n",l);
cpp
#include<stdio.h>
int hcf(int u,int v)
{
int t,r;
if(v>u)
{t=u;u=v;v=t;}
while (v != 0) // 【1】
{
u=v;
v = t % v; // 【2】
}
return u; // 【3】 ;
}
int lcd(int u,int v,int h)
{
return (u * v) / h ;// 【4】
}
void main( )
{
int m,n,h,l;
scanf("%d,%d",&m,&n);
h=hcf(m, n); // 【5】
printf("H.C.F=%d\n",h);
l=lcd(m, n, h); // 【6】
printf("L.C.D=%d\n",l);
}
最大公约数(HCF)函数
|---|------------------------------------|
| |int hcf(int u,int v)
|
| |{
|
| |int t,r;
|
| |if(v>u)
|
| |{
|
| |t=u;
|
| |u=v;
|
| |v=t;
|
| |}
|
| |while (v != 0) // 【1】
|
| |{
|
| |u=v;
|
| |v = u % v; // 【2】 修正为 v = u % v
|
| |}
|
| |return u; // 【3】 当v为0时,u包含HCF的值
|
| |}
|
t
和r
用于在函数内部交换u
和v
(尽管r
在这个函数中没有使用)。- 如果
v
大于u
,则交换u
和v
的值。- 使用
while
循环和欧几里得算法来计算u
和v
的最大公约数。当v
不为0时,循环继续。- 在循环的每次迭代中,
u
被设置为v
的当前值,而v
被设置为u
除以v
的余数。- 当
v
最终变为0时,u
包含u
和v
的最大公约数。最小公倍数(LCM)函数
|---|--------------------------------------------------------------------|
| |int lcd(int u,int v,int h)
|
| |{
|
| |return (u * v) / h ;// 【4】 使用公式 LCM(u, v) = (u * v) / HCF(u, v)
|
| |}
|
- 这个函数接受三个参数:两个整数
u
和v
,以及它们的最大公约数h
。- 它返回
u
和v
的最小公倍数,使用公式LCM(u, v) = (u * v) / HCF(u, v)
。主函数(main)
|---|---------------------------------------------|
| |void main( ) // 注意:标准C中,main应该返回int类型
|
| |{
|
| |int m,n,h,l;
|
| |scanf("%d,%d",&m,&n);
|
| |h=hcf(m, n); // 【5】 调用hcf函数来计算m和n的HCF
|
| |printf("H.C.F=%d\n",h);
|
| |l=lcd(m, n, h); // 【6】 调用lcd函数来计算m和n的LCM
|
| |printf("L.C.D=%d\n",l);
|
| |}
|
- 定义了四个整数变量
m
、n
、h
和l
。- 使用
scanf
函数从标准输入读取两个整数m
和n
。- 调用
hcf
函数计算m
和n
的最大公约数,并将结果存储在h
中。- 使用
printf
函数打印最大公约数。- 调用
lcd
函数计算m
和n
的最小公倍数,并将结果存储在l
中。- 使用
printf
函数打印最小公倍数。
下一个:
编写函数,该函数的功能是将任意的十六进制数转换为相应的十进制数,并返回主调函数。要求在主函数中输入十六进制数,输出转换后十进制数。
输入测试数据:3A
程序运行结果:58
cpp
#include <stdio.h>
#include <string.h>
int hexToDecimal(char hex[])
{
int len = strlen(hex);
int dec = 0;
int i;
for (i = 0; hex[i] != '\0'; ++i)
{
int dig;
if (hex[i] >= '0' && hex[i] <= '9')
{
dig = hex[i] - '0';
}
else if (hex[i] >= 'A' && hex[i] <= 'F')
{
dig = hex[i] - 'A' + 10;
}
else if (hex[i] >= 'a' && hex[i] <= 'f')
{
dig = hex[i] - 'a' + 10;
}
else
{
printf("Invalid hexadecimal number\n");
return -1;
}
for (int j = 0; j < len - i - 1; ++j)
{
dig *= 16;
}
dec += dig;
}
return dec;
}
int main()
{
char hex[20];
printf("输入数据: ");
scanf("%19s", hex);
int dec = hexToDecimal(hex);
if (dec != -1)
{
printf("结果为: %d\n", dec);
}
return 0;
}
hexToDecimal
函数,它的目的是将一个十六进制字符串转换为其对应的十进制整数值。
- 函数定义:
|---|--------------------------------|
| |int hexToDecimal(char hex[])
|该函数接受一个字符数组
hex
作为参数,该数组存储了十六进制数的字符串表示。
- 计算字符串长度:
|---|--------------------------|
| |int len = strlen(hex);
|使用
strlen
函数来计算十六进制字符串的长度。
- 初始化变量:
|---|-----------------|
| |int dec = 0;
|
| |int i;
|dec
用于存储最终的十进制结果,初始化为0。
i`是一个循环计数器,用于遍历十六进制字符串的每一位。
- 遍历十六进制字符串:
|---|------------------------------------|
| |for (i = 0; hex[i] != '\0'; ++i)
|这个循环从字符串的开始遍历到结束(即遍历到字符串终止符
\0
)。
- 解析每一位十六进制数:
在循环内部,我们检查当前字符是0-9、A-F还是a-f,并将其转换为对应的十进制数字。
|---|---------------------------------------------|
| |int dig;
|
| |if (hex[i] >= '0' && hex[i] <= '9')
|
| |{
|
| |dig = hex[i] - '0';
|
| |}
|
| |else if (hex[i] >= 'A' && hex[i] <= 'F')
|
| |{
|
| |dig = hex[i] - 'A' + 10;
|
| |}
|
| |else if (hex[i] >= 'a' && hex[i] <= 'f')
|
| |{
|
| |dig = hex[i] - 'a' + 10;
|
| |}
|
| |else
|
| |{
|
| |printf("Invalid hexadecimal number\n");
|
| |return -1;
|
| |}
|如果字符不是有效的十六进制数字,则打印错误消息并返回-1。
- 计算每一位的权值并加到结果上:
这里我们使用了一个内部循环来手动计算每一位十六进制数字的权值(即16的幂),而不是使用
pow
函数。
|---|------------------------------------------|
| |for (int j = 0; j < len - i - 1; ++j)
|
| |{
|
| |dig *= 16;
|
| |}
|
| |dec += dig;
|注意,内部循环的次数是
len - i - 1
,这是因为我们是从最低位(即字符串的末尾)开始遍历的,所以每一位的权值都应该是16的递减幂。
- 返回结果:
当所有字符都被处理完毕后,函数返回最终的十进制结果
dec
。接下来是
main
函数:
- 我们定义了一个字符数组
hex
来存储用户输入的十六进制字符串。- 使用
printf
和scanf
来提示用户输入和读取输入的十六进制字符串。- 调用
hexToDecimal
函数将十六进制字符串转换为十进制数。- 如果转换成功(即返回值不是-1),则使用
printf
打印出十进制结果。最后,关于
scanf
中的%19s
格式说明符:这是为了防止用户输入超过hex
数组大小的字符串,从而避免缓冲区溢出。%19s
告诉scanf
最多读取19个字符(因为我们要为字符串终止符\0
留出空间)。
刺客,已要吐血