一元函数相加c语言数组

以下是一个简单的C语言程序，用于将两个一元函数的数组相加：

#include <stdio.h>

#define SIZE 10

int main()
{
    int f1[SIZE] = {1,2,3,4,5,6,7,8,9,10};
    int f2[SIZE] = {10,9,8,7,6,5,4,3,2,1};
    int sum[SIZE];

    for(int i=0; i<SIZE; i++)
    {
        sum[i] = f1[i] + f2[i];
        printf("%d + %d = %d\n", f1[i], f2[i], sum[i]);
    }

    return 0;
}

在这个程序中，我们定义了两个长度为10的数组f1和f2，分别表示两个一元函数。然后，我们定义了一个长度为10的数组sum，用于保存两个一元函数相加的结果。

通过for循环，我们遍历f1和f2数组中的每个元素，并将它们相加，并将结果保存到sum数组中。最后，我们使用printf函数输出每个元素的值，以及它们相加的结果。

输出结果如下：

1 + 10 = 11
2 + 9 = 11
3 + 8 = 11
4 + 7 = 11
5 + 6 = 11
6 + 5 = 11
7 + 4 = 11
8 + 3 = 11
9 + 2 = 11
10 + 1 = 11

相关问题

用单链表实现一元多项式的表示及相加的c语言 具体代码

以下是使用单链表实现一元多项式表示及相加的 C 语言代码示例：

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

// 定义链表节点结构体
typedef struct node {
    int coef; // 系数
    int exp; // 指数
    struct node* next; // 指向下一个节点的指针
} Node;

// 创建链表节点
Node* create_node(int coef, int exp) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    new_node->coef = coef;
    new_node->exp = exp;
    new_node->next = NULL;
    return new_node;
}

// 将一元多项式转换为链表表示
Node* poly_to_list(int* coef, int* exp, int n) {
    Node *head = create_node(coef[0], exp[0]);
    Node *p = head;
    for (int i = 1; i < n; i++) {
        Node *new_node = create_node(coef[i], exp[i]);
        p->next = new_node;
        p = new_node;
    }
    return head;
}

// 打印链表表示的一元多项式
void print_poly(Node* head) {
    Node* p = head;
    while (p != NULL) {
        printf("%dx^%d", p->coef, p->exp);
        if (p->next != NULL && p->next->coef > 0) {
            printf("+");
        }
        p = p->next;
    }
    printf("\n");
}

// 两个一元多项式相加
Node* poly_add(Node* head1, Node* head2) {
    Node *p1 = head1, *p2 = head2, *result = NULL, *tail = NULL;
    while (p1 != NULL && p2 != NULL) {
        if (p1->exp < p2->exp) {
            Node *new_node = create_node(p1->coef, p1->exp);
            if (result == NULL) {
                result = tail = new_node;
            } else {
                tail->next = new_node;
                tail = new_node;
            }
            p1 = p1->next;
        } else if (p1->exp > p2->exp) {
            Node *new_node = create_node(p2->coef, p2->exp);
            if (result == NULL) {
                result = tail = new_node;
            } else {
                tail->next = new_node;
                tail = new_node;
            }
            p2 = p2->next;
        } else { // 指数相同
            int coef_sum = p1->coef + p2->coef;
            if (coef_sum != 0) {
                Node *new_node = create_node(coef_sum, p1->exp);
                if (result == NULL) {
                    result = tail = new_node;
                } else {
                    tail->next = new_node;
                    tail = new_node;
                }
            }
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    // 将未遍历完的链表连接到结果链表的末尾
    while (p1 != NULL) {
        Node *new_node = create_node(p1->coef, p1->exp);
        tail->next = new_node;
        tail = new_node;
        p1 = p1->next;
    }
    while (p2 != NULL) {
        Node *new_node = create_node(p2->coef, p2->exp);
        tail->next = new_node;
        tail = new_node;
        p2 = p2->next;
    }
    return result;
}

int main() {
    int coef1[] = {3, 2, 5, 0};
    int exp1[] = {4, 3, 1, 0};
    int n1 = 4;
    Node *poly1 = poly_to_list(coef1, exp1, n1);
    printf("Poly 1: ");
    print_poly(poly1);

    int coef2[] = {-2, 2, 3, 1};
    int exp2[] = {5, 3, 2, 1};
    int n2 = 4;
    Node *poly2 = poly_to_list(coef2, exp2, n2);
    printf("Poly 2: ");
    print_poly(poly2);

    Node *result = poly_add(poly1, poly2);
    printf("Result: ");
    print_poly(result);

    return 0;
}

以上代码实现了将两个一元多项式转换为链表表示并相加的功能，其中 `poly_to_list` 函数将一元多项式数组转换为链表表示，`print_poly` 函数打印链表表示的一元多项式，`poly_add` 函数实现了两个一元多项式相加，并返回结果链表。

c语言实现一元多项式的乘法

以下是一元多项式乘法的C语言实现：

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

// 定义多项式结构体
typedef struct {
    int coef;   // 系数
    int expn;   // 指数
} Elem;

typedef struct {
    Elem *elems;    // 项数组
    int len;        // 项数
} Poly;

// 创建多项式
Poly createPoly(int len) {
    Poly p;
    p.elems = (Elem*)malloc(sizeof(Elem) * len);
    p.len = len;
    return p;
}

// 释放多项式
void freePoly(Poly *p) {
    free(p->elems);
    p->len = 0;
}

// 读取多项式
void readPoly(Poly *p) {
    printf("请输入多项式的项数：");
    scanf("%d", &p->len);
    p->elems = (Elem*)malloc(sizeof(Elem) * p->len);
    printf("请输入多项式的每一项（系数和指数，以空格分隔）：\n");
    for (int i = 0; i < p->len; i++) {
        scanf("%d %d", &p->elems[i].coef, &p->elems[i].expn);
    }
}

// 打印多项式
void printPoly(Poly p) {
    for (int i = 0; i < p.len; i++) {
        printf("%dX^%d", p.elems[i].coef, p.elems[i].expn);
        if (i < p.len - 1) {
            printf(" + ");
        }
    }
    printf("\n");
}

// 多项式乘法
Poly polyMul(Poly p1, Poly p2) {
    Poly res = createPoly(p1.len * p2.len);
    int k = 0;
    for (int i = 0; i < p1.len; i++) {
        for (int j = 0; j < p2.len; j++) {
            res.elems[k].coef = p1.elems[i].coef * p2.elems[j].coef;
            res.elems[k].expn = p1.elems[i].expn + p2.elems[j].expn;
            k++;
        }
    }
    // 合并同类项
    for (int i = 0; i < res.len; i++) {
        for (int j = i + 1; j < res.len; j++) {
            if (res.elems[i].expn == res.elems[j].expn) {
                res.elems[i].coef += res.elems[j].coef;
                // 将该项删除，将数组前移
                for (int l = j; l < res.len - 1; l++) {
                    res.elems[l] = res.elems[l + 1];
                }
                res.len--;
                // j指针回退
                j--;
            }
        }
    }
    // 重新分配内存
    res.elems = (Elem*)realloc(res.elems, sizeof(Elem) * res.len);
    return res;
}

int main() {
    Poly p1, p2, res;
    printf("请输入第一个多项式：\n");
    readPoly(&p1);
    printf("请输入第二个多项式：\n");
    readPoly(&p2);
    res = polyMul(p1, p2);
    printf("相乘的结果为：\n");
    printPoly(res);
    freePoly(&p1);
    freePoly(&p2);
    freePoly(&res);
    return 0;
}

这段代码首先定义了一个多项式的结构体，包括了一个项数组和项数。然后实现了创建、释放、读取和打印多项式的函数。

接下来是多项式乘法的核心代码。它首先创建一个结果多项式，其长度为两个多项式的项数之积。然后使用两层循环遍历两个多项式的每一项，将相乘的结果存入结果多项式中。最后再合并同类项，即将指数相同的项的系数相加，并删除其中一个项，将数组前移。

最后在main函数中调用相应的函数实现多项式乘法，并释放内存。