用C语言实现求出长度为 n 的数组的和，第一行输入一个正整数 n ，表示数组的长度 第二行输入 n 个正整数，表示数组中每个数字的值

以下是用 C 语言实现求出长度为 n 的数组的和的示例代码：

#include <stdio.h>

int main() {
    int n, i, sum = 0;
    int arr[100];

    printf("请输入数组的长度：");
    scanf("%d", &n);

    printf("请输入 %d 个正整数：", n);
    for (i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        sum += arr[i];
    }

    printf("数组的和为 %d\n", sum);

    return 0;
}

在这个示例中，我们首先通过 `scanf()` 函数来输入数组的长度 `n`，并定义一个 `arr` 数组来存储我们输入的 `n` 个正整数。接下来，我们使用 `for` 循环来逐个输入这 `n` 个正整数，并累加它们的和。最后，我们输出数组的和。

相关问题

最大元素 题目描述：编写程序，用递归方法求解长度为n的整型数组中最大元素值。 输入：第一行输入一个正整数n（0<n≤100），表示数组的元素个数；第二行依次输入n个整数，作为数组的元素。 输出：最大元素的值。c语言

好的,我可以为您提供一个使用递归方法在C语言中求解整型数组最大元素值的程序。以下是解决方案:

#include <stdio.h>

// 递归函数来查找最大元素
int findMax(int arr[], int n) {
    // 基本情况: 如果数组中只有一个元素,那就是最大值
    if (n == 1)
        return arr[0];
    
    // 递归查找剩余元素的最大值
    int max = findMax(arr, n-1);
    
    // 比较最后一个元素和前面元素的最大值
    return (arr[n-1] > max) ? arr[n-1] : max;
}

int main() {
    int n;
    
    // 输入数组大小
    scanf("%d", &n);
    
    int arr[n];
    
    // 输入数组元素
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
    
    // 调用递归函数并输出结果
    printf("%d\n", findMax(arr, n));
    
    return 0;
}

这个程序的工作原理如下：

1. `findMax`函数是一个递归函数，用于查找数组中的最大元素。

2. 基本情况：如果数组中只有一个元素，该元素就是最大值。

3. 递归情况：函数递归调用自身来查找前n-1个元素的最大值。

4. 比较第n个元素和前n-1个元素的最大值，返回较大的那个。

5. 在`main`函数中，我们首先读取数组的大小，然后读取数组元素。

6. 最后，我们调用`findMax`函数并输出结果。

这个解决方案的时间复杂度是O(n)，因为我们只遍历数组一次。空间复杂度是O(n)，因为递归调用栈的空间。

输入n个正整数，对这n个数去重之后排序，并输出从小到大排序结果。 输入要求：输入包含两行。第一行输入n，表示数组长度。第二行输入n个正整数。其中1＜=n＜=100，每个数的范围1＜=x＜=n 输出要求：输出去重之后从小到大的排序结果 用C语言解决

在C语言中，你可以使用`#include <stdio.h>`来处理输入和输出，`#include <stdlib.h>`来获取动态内存，以及`#include <stdbool.h>`来使用布尔值。这里是一个简单的解决方案，使用了哈希表（可以视为数组）来去重，然后使用快速排序算法进行排序：

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

bool compare(const void *a, const void *b) {
    return *(int *)a < *(int *)b;
}

void quicksort(int arr[], int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quicksort(arr, low, pivot - 1);
        quicksort(arr, pivot + 1, high);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void swap(int *xp, int *yp) {
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}

int main() {
    int n;
    scanf("%d", &n);

    int arr[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }

    // 使用哈希表去重
    bool hash[n+1] = {false};
    for (int i = 0; i < n; i++) {
        if (!hash[arr[i]]) {
            hash[arr[i]] = true;
        } else {
            continue;
        }
    }

    // 把非重复元素放入新的数组中，并排序
    int unique_arr[numberOfUniqueElements];
    int index = 0;
    for (int i = 0; i < n; i++) {
        if (hash[arr[i]]) {
            unique_arr[index++] = arr[i];
        }
    }

    quicksort(unique_arr, 0, index - 1);

    // 输出去重后的排序结果
    for (int i = 0; i < index; i++) {
        printf("%d ", unique_arr[i]);
    }

    return 0;
}

注意：这个代码假设`numberOfUniqueElements`是实际的唯一元素数量，你需要计算它，例如通过遍历`hash`数组判断非零元素个数。此外，如果`n`非常大，使用数组作为哈希表可能会导致溢出，这时可以考虑使用动态大小的数据结构如链表。