C语言判断两个数是否同号

可以使用逻辑运算符和条件语句来判断两个数是否同号。同号指两个数都为正数或都为负数。

示例代码如下：

#include <stdio.h>

int main() {
    int num1, num2;
    printf("请输入两个整数：\n");
    scanf("%d %d", &num1, &num2);
    
    if ((num1 > 0 && num2 > 0) || (num1 < 0 && num2 < 0)) {
        printf("两个数同号\n");
    } else {
        printf("两个数不同号\n");
    }
    
    return 0;
}

首先通过 `scanf` 函数读取用户输入的两个整数。然后使用逻辑运算符 `&&` 和 `||` 分别判断两个数是否都大于0或都小于0。如果满足其中之一，则表示两个数同号，否则不同号。最后通过条件语句 `if-else` 输出判断结果。

相关问题

有符号大数的加减链表实现C语言

以下是有符号大数的加减链表实现的 C 语言代码：

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

/* 定义链表节点 */
typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

/* 反转链表 */
ListNode* reverseList(ListNode* head) {
    ListNode* prev = NULL;
    ListNode* curr = head;
    while (curr) {
        ListNode* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

/* 删除链表头部的 0 */
ListNode* trimZero(ListNode* head) {
    while (head && head->val == 0) {
        ListNode* tmp = head;
        head = head->next;
        free(tmp);
    }
    return head;
}

/* 创建链表节点 */
ListNode* createNode(int val) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

/* 将数组转换为链表 */
ListNode* arrayToList(int* arr, int len) {
    ListNode* dummy = createNode(-1);
    ListNode* tail = dummy;
    for (int i = 0; i < len; i++) {
        ListNode* node = createNode(arr[i]);
        tail->next = node;
        tail = node;
    }
    return dummy->next;
}

/* 将链表转换为数组，并返回数组长度 */
int* listToArray(ListNode* head, int* len) {
    ListNode* curr = head;
    int count = 0;
    while (curr) {
        count++;
        curr = curr->next;
    }
    int* arr = (int*)malloc(sizeof(int) * count);
    curr = head;
    for (int i = 0; i < count; i++) {
        arr[i] = curr ? curr->val : 0;
        curr = curr ? curr->next : NULL;
    }
    *len = count;
    return arr;
}

/* 对链表进行加法运算 */
ListNode* add(ListNode* l1, ListNode* l2) {
    ListNode* dummy = createNode(-1);
    ListNode* tail = dummy;
    int carry = 0;
    while (l1 || l2) {
        int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
        carry = sum / 10;
        ListNode* node = createNode(sum % 10);
        tail->next = node;
        tail = node;
        l1 = l1 ? l1->next : NULL;
        l2 = l2 ? l2->next : NULL;
    }
    if (carry) {
        ListNode* node = createNode(carry);
        tail->next = node;
        tail = node;
    }
    return dummy->next;
}

/* 对链表进行减法运算 */
ListNode* subtract(ListNode* l1, ListNode* l2) {
    ListNode* dummy = createNode(-1);
    ListNode* tail = dummy;
    int borrow = 0;
    while (l1 || l2) {
        int diff = (l1 ? l1->val : 0) - (l2 ? l2->val : 0) - borrow;
        if (diff < 0) {
            diff += 10;
            borrow = 1;
        } else {
            borrow = 0;
        }
        ListNode* node = createNode(diff);
        tail->next = node;
        tail = node;
        l1 = l1 ? l1->next : NULL;
        l2 = l2 ? l2->next : NULL;
    }
    return dummy->next;
}

/* 对有符号大数进行加法运算 */
ListNode* addBigNumber(ListNode* l1, ListNode* l2) {
    // 处理符号位
    int sign1 = l1->val < 0 ? -1 : 1;
    int sign2 = l2->val < 0 ? -1 : 1;
    if (sign1 * sign2 == 1) {
        // 同号相加
        l1->val = abs(l1->val);
        l2->val = abs(l2->val);
        ListNode* result = add(l1, l2);
        result = trimZero(result);
        if (result == NULL) {
            result = createNode(0);
        }
        result->val *= sign1;
        return result;
    } else {
        // 异号相减
        l1->val = abs(l1->val);
        l2->val = abs(l2->val);
        ListNode* result = NULL;
        if (sign1 == -1) {  // l1 < 0, l2 > 0
            result = subtract(l2, l1);
        } else {  // l1 > 0, l2 < 0
            result = subtract(l1, l2);
        }
        result = trimZero(result);
        if (result == NULL) {
            result = createNode(0);
        }
        result->val *= sign1;
        return result;
    }
}

/* 主函数 */
int main() {
    int a[] = {1, 2, 3, 4, -5, 6, 7, 8, 9};
    int b[] = {9, 8, 7, -6, 5, 4, 3, 2, 1, 0};
    int len1 = sizeof(a) / sizeof(int);
    int len2 = sizeof(b) / sizeof(int);
    ListNode* l1 = arrayToList(a, len1);
    ListNode* l2 = arrayToList(b, len2);
    ListNode* result = addBigNumber(l1, l2);
    int len = 0;
    int* arr = listToArray(result, &len);
    printf("Result: ");
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    free(arr);
    return 0;
}

该代码实现了对有符号大数进行加减法运算的功能。其中，每一个链表节点表示一个数字（可能为正数或负数），符号位存储在链表头节点中。函数 `add` 和 `subtract` 分别实现了链表的加法和减法运算，函数 `addBigNumber` 判断两个数字的符号后，调用 `add` 或 `subtract` 进行相应的运算。最后，我们将结果从链表转换为数组并输出。

用c语言编写程序，实现超长整数的加减法运算

好的，我可以为您提供一些思路和参考代码。

对于超长整数的加减法运算，我们可以考虑使用字符串来表示这些数字。具体来说，我们可以将每个数字存储在一个字符数组中，然后通过模拟手算的方式来进行加减法运算。

下面是一个简单的例子，可以实现两个超长整数的加法运算：

#include <stdio.h>
#include <string.h>

#define MAX_LEN 1000

int main() {
    char str1[MAX_LEN], str2[MAX_LEN], result[MAX_LEN];
    int len1, len2, len, carry = 0, sum, i, j;

    printf("Please enter the first number: ");
    scanf("%s", str1);
    printf("Please enter the second number: ");
    scanf("%s", str2);

    len1 = strlen(str1);
    len2 = strlen(str2);
    len = len1 > len2 ? len1 : len2;

    for (i = len1 - 1, j = len2 - 1, len = len - 1; len >= 0; i--, j--, len--) {
        sum = carry;
        if (i >= 0) sum += str1[i] - '0';
        if (j >= 0) sum += str2[j] - '0';
        result[len] = sum % 10 + '0';
        carry = sum / 10;
    }

    if (carry > 0) {
        printf("Result: 1%s\n", result);
    } else {
        printf("Result: %s\n", result);
    }

    return 0;
}

在这个例子中，我们首先定义了三个字符数组：`str1`、`str2` 和 `result`，分别用来存储第一个数、第二个数和结果。然后，我们通过 `scanf` 函数从用户输入中读取这两个数的值。

接下来，我们使用 `strlen` 函数计算两个数的长度，并且取它们之中的最大值作为计算结果的长度。然后，我们从字符串的末尾开始，逐位相加，同时记录进位（如果有的话），最后将结果存储在 `result` 数组中。

最后，我们判断最高位是否有进位，如果有的话，在输出结果之前在最前面加上一个 1。

对于减法运算，我们可以先将两个数的符号判断出来，然后将它们转化为同号相加的形式。具体来说，我们可以先比较这两个数的大小，然后将较大的数减去较小的数，最后再根据符号加上或减去结果。