给定一个长度为n的数组a，请你编写一个函数： int get_unique_count(int a[], int n); // 返回数组前n个数中的不同数的个数

题目要求编写一个函数，输入一个长度为n的数组a，返回数组前n个数中的不同数的个数。

解题思路：

1. 定义一个计数器count，用于记录不同数的个数。

2. 对数组a进行排序，这样相同的数就会排在一起。

3. 遍历数组a，如果当前数与前一个数不同，则计数器加1。

4. 返回计数器的值。

代码实现：

int get_unique_count(int a[], int n) {
int count = 1; // 初始化计数器为1，因为第一个数肯定是不同的
sort(a, a + n); // 对数组a进行排序
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) { // 如果当前数与前一个数不同
count++; // 计数器加1
}
}
return count; // 返回计数器的值
}

相关问题

给定一个长度为n的数组a和一个整数size，请你编写一个函数，void reverse(int a[], int size)，实现将数组a中的前size个数翻转。 输出翻转后的数组a。

### 回答1：
题目要求编写一个函数，实现将数组a中的前size个数翻转，并输出翻转后的数组a。

函数的声明为：void reverse(int a[], int size)。

其中，a是一个长度为n的数组，size是一个整数，表示需要翻转的前size个数。

函数的实现思路如下：

1. 定义两个指针，分别指向数组a的第一个元素和第size个元素。

2. 通过循环，交换这两个指针所指向的元素，并将指针向中间移动，直到指针相遇。

3. 输出翻转后的数组a。

函数的代码实现如下：

void reverse(int a[], int size) {
int left = , right = size - 1;
while (left < right) {
int temp = a[left];
a[left] = a[right];
a[right] = temp;
left++;
right--;
}
for (int i = ; i < size; i++) {
cout << a[i] << " ";
}
}

其中，变量left和right分别表示左指针和右指针，temp表示交换时需要用到的临时变量。

函数中的循环通过不断交换左右指针所指向的元素，实现了数组的翻转。

最后，通过循环输出翻转后的数组a。

### 回答2：
解题思路：

本题需要将数组a中的前size个数翻转。我们可以使用双指针的方法，定义两个指针：一个指向数组的第一个元素，一个指向数组的第size个元素；然后交换两个指针所指向的元素，再将左指针往右移动一位，右指针往左移动一位，直到两个指针相遇即可。

代码实现：

void reverse(int a[], int size){
int left = 0; //定义左指针
int right = size - 1; //定义右指针
while(left < right){ //当左指针小于右指针时执行循环
int temp = a[left]; //交换左右指针所指向的元素
a[left] = a[right];
a[right] = temp;
left++; //左指针右移
right--; //右指针左移
}
for(int i=0; i<n; i++){ //输出翻转后的数组a
cout<<a[i]<<" ";
}
}

时间复杂度：O(n)

空间复杂度：O(1)

### 回答3：
这道题目可以使用一个双指针的思路来解决。我们可以设定一个指针left指向数组a的第一个元素，一个指针right指向数组a的第size个元素。然后我们开始交换left和right指向的元素，直到left和right指针相遇为止，这时我们就完成了数组a前size个元素的翻转。

具体的实现过程如下：

void reverse(int a[], int size) {
    int left = 0, right = size - 1; // 设定左右指针
    while (left < right) { // 当左右指针没有相遇时
        int temp = a[left]; // 交换左右指针的元素
        a[left] = a[right];
        a[right] = temp;
        left++; // 左指针向右移动
        right--; // 右指针向左移动
    }
}

测试代码如下：

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int size = 3;
    reverse(a, size);
    for (int i = 0; i < 5; i++) { // 输出翻转后的数组a
        cout << a[i] << " ";
    }
    return 0;
}

这样我们就完成了将数组a中前size个元素翻转的操作，并成功输出了翻转后的结果。

题目：给定一个长度为n的数组a,求出其中所有子数组的最大值和最小值之差的和。

题目分析：

对于一个长度为n的数组a，我们可以先通过枚举的方式遍历所有子数组。然后对于每个子数组，我们可以求出该子数组的最大值和最小值，最后将它们的差累加起来即可。

时间复杂度：O(n^3)，空间复杂度：O(1)。

但是，这种暴力枚举的方法时间复杂度太高，不适合处理大规模的数据。因此，我们需要寻找更高效的算法。

我们可以使用动态规划来解决这个问题。具体地，我们可以维护两个状态数组：一个用来存储当前位置之前的最大值，另一个用来存储当前位置之前的最小值。然后我们可以通过这两个数组来计算每个子数组的最大值和最小值之差，并将它们的和累加起来。

时间复杂度：O(n)，空间复杂度：O(n)。

C语言代码实现：

#include <stdio.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int maxMinDiffSum(int a[], int n) {
    int max_dp[n], min_dp[n], ans = 0;
    max_dp[0] = min_dp[0] = a[0];
    for (int i = 1; i < n; i++) {
        max_dp[i] = max(max_dp[i-1] + a[i], a[i]);
        min_dp[i] = min(min_dp[i-1] + a[i], a[i]);
        ans += max_dp[i] - min_dp[i];
    }
    return ans;
}

int main() {
    int a[] = {1, 2, 3, 4};
    int n = sizeof(a) / sizeof(int);
    int ans = maxMinDiffSum(a, n);
    printf("%d\n", ans);    // 输出10
    return 0;
}