用c语言编程 整数包含0的个数：输入任意1个整数，求这个整数中包含几个0。 示例： 输入格式：301009 输出格式：3 输入格式：-2009 输出格式：2

好的，我会用 C 语言编程解决这个问题。以下是代码实现：

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

int main() {
    int num, count = 0;
    printf("请输入一个整数：");
    scanf("%d", &num);
    num = abs(num); // 取绝对值，避免负数的影响
    while(num) {
        if(num % 10 == 0) { // 如果个位是 0
            count++; // 计数器加 1
        }
        num /= 10; // 去掉个位
    }
    printf("整数中包含 %d 个 0。\n", count);
    return 0;
}

代码的运行结果为：

请输入一个整数：301009
整数中包含 3 个 0。

请输入一个整数：-2009
整数中包含 2 个 0。

解释一下代码的实现过程：首先让用户输入一个整数，然后使用 while 循环不断取个位并判断是否为 0，如果是则计数器加 1，最后再去掉个位。这样循环直到整个数都被取完，最终得到整数中包含 0 的个数。需要注意的是，为了避免负数的影响，还要先对输入的整数取绝对值。

相关问题

编写一个C语言程序，输入10个整数，统计并输出其中正数、负数和零的个数。 程序运行结果示例： 请输入10个整数： -12 3 0 8 -7 37 1 0 -23 3 正数个数：5 负数个数：3 零的个数：2 输入提示："请输入10个整数：" 输入格式："% d " 输出提示："\ n 正数个数：% d \ n 负数个数：% d \ n 零的个数：% d \ n " 输出格式："% d "

好的，以下是符合您要求的 C 语言程序代码：

#include <stdio.h>

int main()
{
    int nums[10], positive = 0, negative = 0, zero = 0;

    printf("请输入10个整数：");
    for (int i = 0; i < 10; i++) {
        scanf("%d", &nums[i]);
        if (nums[i] > 0) {
            positive++;
        } else if (nums[i] < 0) {
            negative++;
        } else {
            zero++;
        }
    }

    printf("\n正数个数：%d\n负数个数：%d\n零的个数：%d\n", positive, negative, zero);

    return 0;
}

程序运行时，会提示您输入10个整数，您可以按照要求输入。程序会统计正数、负数和零的个数，并将结果输出。注意，输入时要用空格隔开每个数字。如果您输入的数字不足10个，程序将等待您输入完毕后再进行统计并输出结果。

c语言实现编程实现：输入一个正整数 repeat (0<repeat<10)，做 repeat 次下列运算： 输入一个正整数 n(0<n<=9)和一组(n个)整数，建立一个单向链表，再输入一个整数 x，将链表中最后一个与x相等的整数删除。 输入输出示例：括号内为说明 输入样例: 3 (repeat=3) 5 (数据的个数n=5) 1 2 4 3 7 (5个整数) 4 (待删除整数x=4) 5 (数据的个数n=5) 2 1 5 7 5 (5个整数) 5 (待删除整数x=5) 3 (数据的个数n=3) 1 2 4 (3个整数) 100 (待删除整数x=100) 输出样例: size=4:1 2 3 7 size=4:2 1 5 7 size=3:1 2 4

以下是 C 语言实现：

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

typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

ListNode* deleteLastEqual(ListNode* head, int x) {
    ListNode* dummy = (ListNode*)malloc(sizeof(ListNode));
    dummy->next = head;
    ListNode* prev = dummy;
    ListNode* curr = head;
    ListNode* last_node = NULL;
    while (curr) {
        if (curr->val == x) {
            last_node = curr;
        }
        prev->next = curr;
        prev = curr;
        curr = curr->next;
    }
    if (last_node) {
        prev->next = last_node->next;
    }
    return dummy->next;
}

void printList(ListNode* head) {
    int size = 0;
    int* nums = (int*)malloc(sizeof(int) * 10);
    while (head) {
        nums[size++] = head->val;
        head = head->next;
    }
    printf("size=%d:", size);
    for (int i = size - 1; i >= 0; i--) {
        printf("%d ", nums[i]);
    }
    printf("\n");
    free(nums);
}

int main() {
    int repeat;
    scanf("%d", &repeat);
    for (int i = 0; i < repeat; i++) {
        int n;
        scanf("%d", &n);
        ListNode* head = NULL;
        for (int j = 0; j < n; j++) {
            int val;
            scanf("%d", &val);
            ListNode* node = (ListNode*)malloc(sizeof(ListNode));
            node->val = val;
            node->next = head;
            head = node;
        }
        int x;
        scanf("%d", &x);
        head = deleteLastEqual(head, x);
        printList(head);
        ListNode* curr = head;
        while (curr) {
            ListNode* temp = curr;
            curr = curr->next;
            free(temp);
        }
    }
    return 0;
}

思路解析：

这个问题可以通过创建一个虚拟头节点 dummy，将它指向链表的头节点 head。然后用 prev 和 curr 指针遍历链表，prev 始终指向 curr 的前一个节点，curr 指向当前节点。如果 curr->val 等于 x，则将 last_node 指向 curr，表示找到与 x 相等的节点。遍历完后，如果 last_node 不为空，则删除 last_node 节点。

在构造链表时，我们需要不断地从输入中读取整数，每读一个整数就创建一个新的节点，并将它插入到链表的头部。最后得到的链表是逆序的。遍历链表，统计链表长度和节点值，最后输出即可。

需要注意的是，在释放链表节点的内存时，我们需要先遍历整个链表，将指针指向下一个节点，然后才能释放当前节点的内存。

时间复杂度分析：

遍历链表需要 O(n) 的时间复杂度，构造链表需要 O(n) 的时间复杂度，因此总的时间复杂度为 O(n)。