目录

计算级数和

判断并找出非素数

主函数操作流程

求最大公约数和最小公倍数

编写子函数，该函数的功能是是计算下列级数和，并将和值返回主调函数输出。数据由主函数输入。

fun 函数

sum 函数

main 函数

注意事项

编写函数，该函数的功能是，将所有大于1小于整数m的非素数存入xx数组中， 非素数的个数通过k传回。整数m的值由主函数输入。

函数详细解释

Y(int num)

NO(int n, int xx[], int *k)

main()

（填空题）写一个判断素数的函数，在主函数输入一个整数，输出是否素数的信息。程序文件名：

素数判断函数 prime

（填空题）求两个数的最大公约数和最小公倍数，用一个函数求最大公约数。用另一个函数根据求出的最大公约数求最小公倍数。

最大公约数（HCF）函数

最小公倍数（LCM）函数

主函数（main）

 编写函数，该函数的功能是将任意的十六进制数转换为相应的十进制数，并返回主调函数。要求在主函数中输入十六进制数，输出转换后十进制数。

---

该博客文章主要讨论了几个编程相关的话题，包括计算特定级数和、判断素数、找出非素数并存入数组、以及计算两个数的最大公约数（HCF）和最小公倍数（LCM）。下面是这些主题的总结和关键代码段的解释：

计算级数和

• 功能：计算形如 ∑𝑖=1𝑛𝑥𝑖−1𝑖!∑i=1n​i!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_ヽ)_写作业

编写子函数，该函数的功能是是计算下列级数和，并将和值返回主调函数输出。数据由主函数输入。

#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

#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;  
}

这个程序包含两个函数：

1. Y(int num): 这是一个判断整数num是否为素数的函数。如果num是素数，返回true；否则返回false。
2. 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】  );}

#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 中。
3. 判断素数并输出结果

	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

1. 初始化

int flag = 1, i;

这里声明了两个整数变量 flag 和 i。flag 用于标记 n 是否为素数（初始值为 1，表示假设 n 是素数），i 用于循环中遍历从 2 到 n/2 的所有整数。
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 不是素数。
3. 返回结果

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);

#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

#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函数，它的目的是将一个十六进制字符串转换为其对应的十进制整数值。

1. 函数定义:

int hexToDecimal(char hex[])

该函数接受一个字符数组hex作为参数，该数组存储了十六进制数的字符串表示。

1. 计算字符串长度:

int len = strlen(hex);

使用strlen函数来计算十六进制字符串的长度。

1. 初始化变量:

	int dec = 0;
	int i;

dec用于存储最终的十进制结果，初始化为0。i`是一个循环计数器，用于遍历十六进制字符串的每一位。

1. 遍历十六进制字符串:

for (i = 0; hex[i] != '\0'; ++i)

这个循环从字符串的开始遍历到结束（即遍历到字符串终止符\0）。

1. 解析每一位十六进制数:

在循环内部，我们检查当前字符是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。

1. 计算每一位的权值并加到结果上:

这里我们使用了一个内部循环来手动计算每一位十六进制数字的权值（即16的幂），而不是使用pow函数。

	for (int j = 0; j < len - i - 1; ++j)
	{
	dig *= 16;
	}
	dec += dig;

注意，内部循环的次数是len - i - 1，这是因为我们是从最低位（即字符串的末尾）开始遍历的，所以每一位的权值都应该是16的递减幂。

1. 返回结果:

当所有字符都被处理完毕后，函数返回最终的十进制结果dec。

接下来是main函数：

• 我们定义了一个字符数组hex来存储用户输入的十六进制字符串。
• 使用printf和scanf来提示用户输入和读取输入的十六进制字符串。
• 调用hexToDecimal函数将十六进制字符串转换为十进制数。
• 如果转换成功（即返回值不是-1），则使用printf打印出十进制结果。

最后，关于scanf中的%19s格式说明符：这是为了防止用户输入超过hex数组大小的字符串，从而避免缓冲区溢出。%19s告诉scanf最多读取19个字符（因为我们要为字符串终止符\0留出空间）。

 刺客，已要吐血