创建数组arr = [1,3,9,1,5,7,2,8,4]，打印输出排序、去重、均值、方差等的统计

首先，我们可以通过Python内置的`set()`函数去除数组arr中的重复元素，然后使用`sort()`函数对数组进行排序。接下来，我们将计算平均数（均值）、方差和标准差。

import statistics

# 定义数组 arr
arr = [1, 3, 9, 1, 5, 7, 2, 8, 4]

# 去除重复并排序
unique_arr = sorted(set(arr))

# 打印排序后的数组
print("排序后的数组:", unique_arr)

# 计算均值（平均数）
mean = sum(unique_arr) / len(unique_arr)
print("均值(平均数):", mean)

# 计算方差
variance = statistics.variance(unique_arr)
print("方差:", variance)

# 计算标准差（方差的平方根）
std_deviation = statistics.stdev(unique_arr)
print("标准差:", std_deviation)

执行上述代码后，将分别输出排序后的数组、均值、方差以及标准差。

相关问题

使用c++ 实现有结构体数组的递归去重排序

在 C++ 中，你可以通过递归和数据结构如`std::vector`、`std::set`或者自定义`std::unordered_set`来实现结构体数组的去重并排序。这里我们假设有一个结构体`Struct`，它有两个成员，例如`name`和`value`。以下是基本步骤：

1. 首先，你需要创建一个辅助函数，用于递归处理结构体数组，并将去重后的元素添加到集合中。

struct Struct {
    std::string name;
    int value;
};

void removeDuplicates(std::vector<Struct>& arr, std::set<std::pair<std::string, int>>& uniqueSet) {
    if (arr.empty())
        return;

    // 检查当前元素是否已经存在于集合中
    auto it = uniqueSet.find({arr[0].name, arr[0].value});
    if (it == uniqueSet.end()) {
        // 如果不存在，添加到集合中并将原数组的下一个元素传递给递归函数
        uniqueSet.insert({arr[0].name, arr[0].value});
        removeDuplicates(arr.begin() + 1, uniqueSet);
    } else {
        // 如果存在，跳过已有的元素
        arr.erase(arr.begin());
    }
}

2. 然后，你可以对原始数组进行排序，这可以使用 C++ 的 `sort` 函数，配合一个比较函数来按值排序。

bool compareStructs(const Struct& a, const Struct& b) {
    return a.value < b.value; // 按照 value 字段排序
}

// 排序并移除重复项
void sortAndRemoveDuplicates(std::vector<Struct>& arr) {
    std::set<std::pair<std::string, int>> uniqueSet;
    removeDuplicates(arr, uniqueSet);

    // 将集合转换回有序的向量
    arr.clear();
    for (const auto& pair : uniqueSet) {
        arr.push_back(Struct{pair.first, pair.second});
    }

    std::sort(arr.begin(), arr.end(), compareStructs);
}

java整型数组去重

在 Java 中，整型数组去重可以采用几种常见的方法：

1. **利用HashSet**：将数组元素添加到 HashSet 中，由于 HashSet 的特性不允许有重复元素，所以最后集合的大小就是去重后的元素数，然后再将其转换回数组。

import java.util.*;

public int[] removeDuplicates(int[] arr) {
    Set<Integer> set = new HashSet<>();
    for (int num : arr) {
        set.add(num);
    }
    return set.stream().mapToInt(Integer::intValue).toArray();
}

2. **使用双指针法**：创建两个指针，一个用于遍历整个数组，另一个用于检查已存在的元素。如果当前元素未在之前遇到过，则复制到新数组中。

public int[] removeDuplicates(int[] arr) {
    if (arr == null || arr.length == 0) {
        return arr;
    }
    int[] res = new int[arr.length];
    int j = 0;
    for (int i = 0; i < arr.length - 1; i++) {
        if (arr[i] != arr[i + 1]) {
            res[j++] = arr[i];
        }
    }
    // 添加最后一个元素，因为循环结束时j可能未达到最大值
    res[j++] = arr[arr.length - 1];
    return Arrays.copyOf(res, j);
}

3. **使用排序+遍历**：先对数组进行排序，然后从第二个元素开始遍历，如果当前元素大于前面的任何一个元素，则添加到结果数组中。

public int[] removeDuplicates(int[] arr) {
    Arrays.sort(arr);
    int n = arr.length;
    if (n <= 1) {
        return arr;
    }
    int result[] = new int[n];
    result = arr;
    for (int i = 1; i < n; i++) {
        if (arr[i] != arr[i - 1]) {
            result[i] = arr[i];
        }
    }
    return result;
}