CompassArena 司南大模型测评--代码编写

测试角度

要说测试模型，对咱们程序员来说，那自然是写代码的能力强不强比较重要了。那么下面我们以 leetcode 中的一道表面上是困难题的题目来考考各家大模型，看看哪个才应该是咱们日常写程序的帮手。

部分模型回答

问题部分如下截图，后边就不再重复粘贴了，主要来看回答。我们注意到这里的难点在于在于对时间复杂度有要求，看看各个模型能不能注意到这一点。
出于篇幅，这里只贴出来结果比较好的几个模型进行点评。

图片.png

Abab6.5 Chat (MiniMax) 结果

要找到两个正序数组的中位数，并且要求算法的时间复杂度为 O(log (m+n))，可以使用二分查找的方法。以下是一种可能的解决方案：

  1. 首先，确保 nums1 是较短的数组，如果不是，则交换 nums1 和 nums2。
  2. 使用二分查找，在较短的数组 nums1 中查找合适的分割线，使得 nums1 分割线左侧的元素和 nums2 分割线右侧的元素个数之和等于 nums1 分割线右侧的元素和 nums2 分割线左侧的元素个数之和（或者相差1，如果总元素个数是奇数）。
  3. 通过比较 nums1 中分割线两侧的元素与 nums2 中分割线两侧的元素，调整分割线的位置，直到找到正确的分割线位置。
  4. 根据分割线的位置，计算中位数。

下面是具体的算法实现：

def findMedianSortedArrays(nums1, nums2):
    # 确保 nums1 是较短的数组
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
    
    m, n = len(nums1), len(nums2)
    total_left = (m + n + 1) // 2
    
    # 在 nums1 的区间 [0, m] 里查找恰当的分割线，
    # 使得 nums1[i-1] <= nums2[j] && nums2[j-1] <= nums1[i]
    left, right = 0, m
    while left < right:
        i = left + (right - left) // 2
        j = total_left - i
        if nums1[i] < nums2[j - 1]:
            # i 需要增大
            left = i + 1
        else:
            # i 需要减小
            right = i
    
    i = left
    j = total_left - i
    
    # 处理数组长度为奇数和偶数的情况
    nums1_left_max = float('-inf') if i == 0 else nums1[i - 1]
    nums2_left_max = float('-inf') if j == 0 else nums2[j - 1]
    nums1_right_min = float('inf') if i == m else nums1[i]
    nums2_right_min = float('inf') if j == n else nums2[j]
    
    if (m + n) % 2 == 1:
        return max(nums1_left_max, nums2_left_max)
    else:
        return (max(nums1_left_max, nums2_left_max) + min(nums1_right_min, nums2_right_min)) / 2

# 示例
nums1 = [1, 3]
nums2 = [2]
print(findMedianSortedArrays(nums1, nums2))  # 输出 2.0

nums1 = [1, 2]
nums2 = [3, 4]
print(findMedianSortedArrays(nums1, nums2))  # 输出 2.5

这个算法的时间复杂度是 O(log(min(m, n)))，因为二分查找是在较短的数组上进行的。

Abab6.5 Chat (MiniMax) 点评

Abab6.5 Chat (MiniMax)给出的答案是python写的，估计训练使用python的代码比较多。模型注意到了时间复杂度，并且一直在强调，且给出的代码是可运行的，算法描述也比较清晰，代码的质量中规中矩，且加了注释，还不错。

Baichuan 4 (百川智能) 回答

为了找到两个有序数组的中位数，我们可以使用二分查找的方法来减少时间复杂度到O(log(min(m, n)))。以下是解决这个问题的步骤：

  1. 确保nums1是较短的数组，如果nums1比nums2长，交换它们。这样做是为了优化二分查找的性能。

  2. 在nums1上执行二分查找，找到适当的分割线，使得nums1左边的元素和nums2左边的元素一起组成了整个合并数组左边的一半，同时nums1右边的元素和nums2右边的元素组成右边的一半。

  3. 调整分割线，以确保左右两边的元素数量相等或最多相差一个，这取决于合并后数组长度的奇偶性。

  4. 计算中位数。如果合并后数组的长度是奇数，则中位数是两个数组左边部分的最大值。如果是偶数，则中位数是两个数组左边部分的最大值和两个数组右边部分的最小值的平均值。

下面是这个算法的Python代码实现：

def findMedianSortedArrays(nums1, nums2):
    # 确保nums1是较短的数组
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
    
    m, n = len(nums1), len(nums2)
    imin, imax, half_len = 0, m, (m + n + 1) // 2
    while imin <= imax:
        i = (imin + imax) // 2
        j = half_len - i
        if i < m and nums2[j-1] > nums1[i]:
            # i太小，必须增加它
            imin = i + 1
        elif i > 0 and nums1[i-1] > nums2[j]:
            # i太大，必须减小它
            imax = i - 1
        else:
            # i正好
            if i == 0: max_of_left = nums2[j-1]
            elif j == 0: max_of_left = nums1[i-1]
            else: max_of_left = max(nums1[i-1], nums2[j-1])
            
            if (m + n) % 2 == 1:
                return max_of_left
            
            if i == m: min_of_right = nums2[j]
            elif j == n: min_of_right = nums1[i]
            else: min_of_right = min(nums1[i], nums2[j])
            
            return (max_of_left + min_of_right) / 2.0
    
    # 这种情况不应该发生，如果发生了说明输入有误
    raise ValueError("Input arrays are not sorted or other error occurred")

# 示例
print(findMedianSortedArrays([1,3], [2])) # 输出: 2.00000
print(findMedianSortedArrays([1,2], [3,4])) # 输出: 2.50000

这段代码首先确保了nums1是较短的数组，然后通过二分查找在nums1上找到一个合适的索引i，使得nums1的前i个元素和nums2的前j个元素共同构成了合并后数组的前一半。最后根据合并后数组长度的奇偶性来计算中位数。

Baichuan 4 (百川智能) 点评

我们看到，这里同样使用了python的解法，代码可运行，解法描述比较清晰，并且考虑到了错误处理，还是不错的。

ERNIE 4.0 8K 0329 (百度文心一言) 回答

要实现时间复杂度为 O(log(m+n)) 的算法来找到两个正序数组的中位数，可以使用二分查找的方法。但请注意，严格的 O(log(m+n)) 解决方案可能相当复杂。为了简化，如果我们允许一个稍微宽松的时间复杂度界限（例如，在某些情况下接近 O(log(min(m, n)))），我们可以采用一个更容易理解的方法。

下面是一个简化的方法，它基于二分查找，但并不是严格的 O(log(m+n))，而是更接近于 O(log(min(m, n)))，因为它每次都在较短的数组上进行二分操作：

def findMedianSortedArrays(nums1, nums2):
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1  # 确保 nums1 是较短的数组
    m, n = len(nums1), len(nums2)
    left, right = 0, m
    while left <= right:
        partitionX = (left + right) // 2  # 在 nums1 中的分割点
        partitionY = ((m + n + 1) // 2) - partitionX  # 在 nums2 中的分割点

        # 确保左半部分都小于右半部分
        maxLeftX = float('-inf') if partitionX == 0 else nums1[partitionX - 1]
        minRightX = float('inf') if partitionX == m else nums1[partitionX]
        maxLeftY = float('-inf') if partitionY == 0 else nums2[partitionY - 1]
        minRightY = float('inf') if partitionY == n else nums2[partitionY]

        if maxLeftX <= minRightY and maxLeftY <= minRightX:
            # 已经找到了正确的划分
            if (m + n) % 2 == 0:
                return max(maxLeftX, maxLeftY, key=float) / 2 + min(minRightX, minRightY, key=float) / 2
            else:
                return max(maxLeftX, maxLeftY, key=float)  # 总是取较大的左半部分作为中位数

        elif maxLeftX > minRightY:  # 太靠右，需要向左调整
            right = partitionX - 1
        else:  # 太靠左，需要向右调整
            left = partitionX + 1
            
    # 如果未找到中位数，则抛出异常（实际上，由于我们的逻辑，这里不会被执行到）
    raise ValueError("No median found")

# 示例测试
print(findMedianSortedArrays([1, 3], [2]))  # 输出: 2.0
print(findMedianSortedArrays([1, 2], [3, 4]))  # 输出: 2.5

这个算法通过二分查找确定两个数组中的分割点，以确保左半部分的所有元素都小于或等于右半部分的所有元素。然后，根据分割点找到中位数。注意，这个解决方案在数组长度不等的情况下也能正确工作，并且处理了总数组长度是奇数还是偶数的情况。

虽然这个解决方案的时间复杂度并不是严格的 O(log(m+n))，但在很多实际应用中，它的性能已经足够好，并且比严格的 O(log(m+n)) 解决方案更容易理解和实现。如果需要严格的 O(log(m+n)) 解决方案，请参考一些高级的二分查找变种，它们通常涉及更复杂的边界条件和分割逻辑。

ERNIE 4.0 8K 0329 (百度文心一言) 点评

文心一言给的也是python的回答，可见python确实是比较常用。文心一言没有给出具体的算法步骤，但代码注释和中文描述都很流畅易懂，比百川智能要稍强一些。

Hunyuan Pro (腾讯混元) 回答

为了实现 O(log(m+n)) 的时间复杂度，我们可以使用二分查找的方法。首先，我们需要找到两个数组中较短的那个数组，并将其作为二分查找的主体。假设较短数组为 A，长数组为 B，我们可以在 A 中进行二分查找，找到一个位置 partitionA，使得 A 中有 partitionA 个元素在左侧，有 len(A) - partitionA 个元素在右侧。同时，我们需要在 B 中找到一个位置 partitionB，使得 B 中有 partitionB 个元素在左侧，有 len(B) - partitionB 个元素在右侧。这样，我们可以保证左侧的所有元素都小于等于右侧的所有元素。

接下来，我们需要判断当前的分割是否满足条件。如果满足条件，我们就可以计算中位数。如果不满足条件，我们需要根据实际情况调整二分查找的范围。

以下是具体的算法步骤：

  1. 找到较短的数组 A 和长数组 B。
  2. 初始化二分查找的范围：imin = 0，imax = len(A)。
  3. 进行二分查找：
    a. 计算 partitionA = (imin + imax) // 2。
    b. 计算 partitionB = (len(A) + len(B) + 1) // 2 - partitionA。
    c. 判断当前分割是否满足条件：
    • 如果 partitionA > 0 且 A[partitionA-1] > B[partitionB]，说明当前分割过于右侧，需要将 imax 更新为 partitionA - 1。
    • 如果 partitionA < len(A) 且 A[partitionA] < B[partitionB-1]，说明当前分割过于左侧，需要将 imin 更新为 partitionA + 1。
    • 否则，当前分割满足条件，可以计算中位数。
  4. 计算中位数：
    • 如果 (len(A) + len(B)) 是奇数，那么中位数为 max(A[partitionA-1], B[partitionB-1])。
    • 如果 (len(A) + len(B)) 是偶数，那么中位数为 (max(A[partitionA-1], B[partitionB-1]) + min(A[partitionA], B[partitionB])) / 2。

以下是 Python 代码实现：

def findMedianSortedArrays(nums1, nums2):
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1

    m, n = len(nums1), len(nums2)
    imin, imax, half_len = 0, m, (m + n + 1) // 2

    while imin <= imax:
        partitionA = (imax + imin) // 2
        partitionB = half_len - partitionA

        if partitionA > 0 and nums1[partitionA - 1] > nums2[partitionB]:
            imax = partitionA - 1
        elif partitionA < m and nums2[partitionB - 1] > nums1[partitionA]:
            imin = partitionA + 1
        else:
            if partitionA == 0:
                max_of_left = nums2[partitionB - 1]
            elif partitionB == 0:
                max_of_left = nums1[partitionA - 1]
            else:
                max_of_left = max(nums1[partitionA - 1], nums2[partitionB - 1])

            if (m + n) % 2 == 1:
                return max_of_left

            if partitionA == m:
                min_of_right = nums2[partitionB]
            elif partitionB == n:
                min_of_right = nums1[partitionA]
            else:
                min_of_right = min(nums1[partitionA], nums2[partitionB])

            return (max_of_left + min_of_right) / 2

这个算法的时间复杂度为 O(log(min(m, n)))，满足题目要求。

Hunyuan Pro (腾讯混元) 点评

腾讯混元给出了具体的思路和具体步骤，并给出了常规的python解答，还是不错的。

Mixtral 8x22B Instruct (Mistral) 回答

这个问题可以使用二分查找的思想来解决。

首先，我们需要找到两个数组的中位数，如果两个数组的长度之和为奇数，那么中位数就是中间那个数，如果为偶数，那么中位数就是中间两个数的平均值。

我们可以定义两个指针，分别指向两个数组的开头，然后我们可以不断地比较这两个指针所指向的数，将较小的那个数放入一个新的数组中，直到我们找到中位数。

具体实现如下：

def findMedianSortedArrays(nums1, nums2):
    nums = nums1 + nums2
    nums.sort()
    length = len(nums)
    if length % 2 == 0:
        return (nums[length // 2] + nums[length // 2 - 1]) / 2
    else:
        return nums[length // 2]

这个实现的时间复杂度是 O(m+n)，因为我们需要将两个数组合并成一个数组，然后排序，最后找到中位数。但是这个实现并不满足题目要求的时间复杂度为 O(log(m+n))。

为了满足题目要求的时间复杂度，我们可以使用二分查找的思想。具体实现如下：

def findMedianSortedArrays(nums1, nums2):
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
    x, y = len(nums1), len(nums2)
    start = 0
    end = x
    while start <= end:
        partitionX = (start + end) // 2
        partitionY = ((x + y + 1) // 2) - partitionX
        maxLeftX = float('-inf') if partitionX == 0 else nums1[partitionX - 1]
        minRightX = float('inf') if partitionX == x else nums1[partitionX]
        maxLeftY = float('-inf') if partitionY == 0 else nums2[partitionY - 1]
        minRightY = float('inf') if partitionY == y else nums2[partitionY]
        if maxLeftX <= minRightY and maxLeftY <= minRightX:
            if (x + y) % 2 == 0:
                return max(maxLeftX, maxLeftY), min(minRightX, minRightY)
            else:
                return max(maxLeftX, maxLeftY)
        elif maxLeftX > minRightY:
            end = partitionX - 1
        else:
            start = partitionX + 1

这个实现的时间复杂度是 O(log(min(m, n)))，因为我们使用二分查找的思想，每次都将问题规模减半。

这个实现的基本思想是，我们需要找到两个数组的中位数，因此我们需要将这两个数组分成两部分，使得左半部分的最大值小于等于右半部分的最小值。如果左半部分的最大值大于右半部分的最小值，那么我们就需要将分割点向左移动，否则我们就需要将分割点向右移动。

当我们找到了分割点后，我们就可以根据两个数组的长度来判断中位数是左半部分的最大值还是右半部分的最小值。如果两个数组的长度之和为奇数，那么中位数就是左半部分的最大值，如果为偶数，那么中位数就是左半部分的最大值和右半部分的最小值的平均值。

Mixtral 8x22B Instruct (Mistral) 点评

Mistral给出了两个思路，并且给出了对应代码的解析，中文描述也很流畅。对于这个我不是很熟的模型，我感觉还是不错的。

Qwen Max 0428 (阿里通义千问)回答

这个问题可以通过使用二分查找算法来解决，以达到O(log(min(m, n)))的时间复杂度，而不是题目要求的O(log(m+n))，但这是解决此问题最有效的方法。下面是详细的解决方案：

首先，确定哪个数组作为“较小”的数组可以简化问题。我们希望在两个数组之间进行相等划分，因此将较小的数组作为分割操作的目标会更高效。如果m > n，就交换两个数组，确保nums1是两个数组中较小或相等的那个。

然后，我们定义一个函数findKthElement用来寻找两个已排序数组中的第k小元素。这个函数的核心思想是使用二分查找法在nums1数组上找到一个位置i，使得nums1[i-1] <= nums2[k-i] && nums2[k-i-1] <= nums1[i]。这样，第k小的元素要么是nums1[i]，要么是nums2[k-i]，具体取决于它们的相对位置和值。

以下是该算法的Python实现：

def findMedianSortedArrays(nums1, nums2):
    # 确保nums1是较短的数组
    if len(nums1) > len(nums2):
        nums1, nums2 = nums2, nums1
        
    x, y = len(nums1), len(nums2)
    low, high = 0, x
    
    while low <= high:
        partitionX = (low + high) // 2
        partitionY = (x + y + 1) // 2 - partitionX
        
        # 如果partitionX是0，说明我们已经超出了nums1的左侧边界，此时nums1[-1]相当于一个负无穷
        maxLeftX = float('-inf') if partitionX == 0 else nums1[partitionX - 1]
        # 类似地处理nums1的右侧边界
        minRightX = float('inf') if partitionX == x else nums1[partitionX]
        
        maxLeftY = float('-inf') if partitionY == 0 else nums2[partitionY - 1]
        minRightY = float('inf') if partitionY == y else nums2[partitionY]
        
        if maxLeftX <= minRightY and maxLeftY <= minRightX:
            # 找到了正确的分区
            if (x + y) % 2 == 0:
                # 数组总长度为偶数
                return max(maxLeftX, maxLeftY), min(minRightX, minRightY)
            else:
                # 数组总长度为奇数
                return max(maxLeftX, maxLeftY)
        elif maxLeftX > minRightY:
            # 缩小nums1的右边界
            high = partitionX - 1
        else:
            # 扩大nums1的左边界
            low = partitionX + 1
            
    # 上述逻辑应始终能找到答案，理论上不会执行到这一步
    return None

这段代码实现了寻找两个有序数组中位数的功能，符合题目要求。注意，虽然这里的解释提到时间复杂度为O(log(min(m, n)))，但实际解决问题的思路是正确的，且效率较高，满足题目的实际需求。

Qwen Max 0428 (阿里通义千问)点评

通义千问这个大家都比较熟悉了，它给出了思路和代码，并且代码有注释，但没有给测试用例，整体还是不错的。

测评总结

在这道题上，文中的各个模型都给出了不错的回答。从整体上来看，以下是各个模型在我心目中的排名：

  1. Mistral
  2. Qwen Max 0428
  3. 腾讯混元
  4. 百度文心一言
  5. MiniMax
  6. 百川智能

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/666867.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ArcGIS教程(05)：计算服务区和创建 OD 成本矩阵

ArcGIS教程(05)：计算服务区和创建 OD 成本矩阵

准备视图 启动【ArcMap】->双击打开【Exercise05.mxd】->启用【Network Analyst 扩展模块】。前面的文章已经讲过&#xff0c;这里不再赘述。 创建服务区分析图层 1、在 Network Analyst 工具栏上&#xff0c;单击 【Network Analyst】&#xff0c;然后单击【新建服务…
阅读更多...
CAC2.0全生命周期防护，助力企业构建安全闭环

CAC2.0全生命周期防护，助力企业构建安全闭环

5月29日&#xff0c;CACTER邮件安全团队凭借多年的邮件安全防护经验&#xff0c;在“防御邮件威胁-企业如何筑起最后防线”直播分享会上展示了构建安全闭环的重要性&#xff0c;并深入介绍了全新CAC 2.0中的“威胁邮件提示”功能。 下滑查看更多直播精彩内容 构建安全闭环的必要…
阅读更多...
Solidity学习-投票合约示例

Solidity学习-投票合约示例

以下的合约有一些复杂&#xff0c;但展示了很多Solidity的语言特性。它实现了一个投票合约。 当然&#xff0c;电子投票的主要问题是如何将投票权分配给正确的人员以及如何防止被操纵。 我们不会在这里解决所有的问题&#xff0c;但至少我们会展示如何进行委托投票&#xff0c;…
阅读更多...
显示器与电脑如何分屏显示？

显示器与电脑如何分屏显示？

1.点击电脑屏幕右键--显示设置 2、然后找到屏幕---找到多显示器---选择扩展显示器
阅读更多...
亚马逊云科技峰会盛大举行 | 光环新网携光环云数据以高性能智算服务助力企业创新发展

亚马逊云科技峰会盛大举行 | 光环新网携光环云数据以高性能智算服务助力企业创新发展

2024年5月29日&#xff0c;云计算行业的年度盛典”2024亚马逊云科技中国峰会”在上海世博中心再次盛大启幕。作为全球领先的云计算服务提供商&#xff0c;亚马逊云科技峰会聚焦前沿科技&#xff0c;与来自不同行业、不同科技领域的优秀企业和用户共同探索AI时代的云端创新发展。…
阅读更多...
游戏逆向工具分析及解决方案

游戏逆向工具分析及解决方案

游戏逆向&#xff0c;是指通过各类工具对游戏进行反编译及源码分析&#xff0c;尝试分析游戏的实现逻辑的过程。这个过程需要使用解密、反编译、解压缩等技术&#xff0c;目的是还原或分析出游戏的代码逻辑及资源。 游戏逆向工具可以按照不同功能进行划分&#xff0c;如&#…
阅读更多...
分布式任务队列系统 celery 原理及入门

分布式任务队列系统 celery 原理及入门

基本 Celery 是一个简单、灵活且可靠的分布式任务队列系统&#xff0c;用于在后台执行异步任务处理大量消息。支持任务调度、任务分发和结果存储&#xff0c;并且可以与消息代理&#xff08;如 RabbitMQ、Redis 等&#xff09;一起工作&#xff0c;以实现任务的队列管理和执行…
阅读更多...
对于vsc中的vue命令 vue.json

对于vsc中的vue命令 vue.json

打开vsc 然后在左下角有一个设置 2.点击用户代码片段 3.输入 vue.json回车 将此代码粘贴 &#xff08;我的不一定都适合&#xff09; { "vue2 template": { "prefix": "v2", "body": [ "<template>", " <…
阅读更多...
更新详情 | Flutter 3.22 与 Dart 3.4

更新详情 | Flutter 3.22 与 Dart 3.4

作者 / Michael Thomsen 过去几个月&#xff0c;Dart & Flutter 部门可谓忙碌非凡&#xff0c;但我们很高兴地宣布&#xff0c;Flutter 3.22 和 Dart 3.4 已经在今年的 Google I/O 大会上精彩亮相&#xff01; Google I/Ohttps://io.google/2024/intl/zh/ 我们始终致力于提…
阅读更多...
【调试笔记-20240530-Linux-在 OpenWRT-23.05 上为 nginx 配置 HTTPS 网站】

【调试笔记-20240530-Linux-在 OpenWRT-23.05 上为 nginx 配置 HTTPS 网站】

调试笔记-系列文章目录 调试笔记-20240530-Linux-在 OpenWRT-23.05 上为 nginx 配置 HTTPS 网站 文章目录 调试笔记-系列文章目录调试笔记-20240530-Linux-在 OpenWRT-23.05 上为 nginx 配置 HTTPS 网站 前言一、调试环境操作系统&#xff1a;OpenWrt 23.05.3调试环境调试目标…
阅读更多...
CS61C | lecture2

CS61C | lecture2

# CS61C | lecture2 C 语言是一种编译语言。C 编译器将 C 程序映射到特定与体系结构的机器代码(实际上是一串 0 和 1)。 而 Java 会通过 JVM(Java 虚拟机) 将代码转换为独立于架构的字节码。 Python 则会直接解释代码。C 不会直接解释代码&#xff0c;而是将其编译成机器代码之…
阅读更多...
计算机基础学习路线

计算机基础学习路线

计算机基础学习路线 整理自学计算机基础的过程&#xff0c;虽学习内容众多&#xff0c;然始终相信世上无难事&#xff0c;只怕有心人&#xff0c;期间也遇到许多志同道合的同学&#xff0c;现在也分享自己的学习过程来帮助有需要的。 一、数据结构与算法 视频方面我看的是青…
阅读更多...
Bean作用域和生产周期已经Bean的线程安全问题

Bean作用域和生产周期已经Bean的线程安全问题

bean 的作用域 单例(Singletion) : Spring 容器中只有一个 bean &#xff0c;这个 bean 在整个应用程序内共享。 原话(Prototype) : 每次 getBean()&#xff0c; 都是不同的bean&#xff0c;都会创建一个实例。 请求(Request)&#xff1a;每个HTTP请求都会创建一个新的 Bean …
阅读更多...
ARM虚拟机安装OMV

ARM虚拟机安装OMV

OMV(OpenMediaVault)是基于 Debian GNU/Linux 的网络连接存储&#xff08;network attached storage&#xff0c;NAS&#xff09;解决方案。它包含 SSH、(S) FTP、SMB/CIFS、DAAP 媒体服务器、rsync、 BitTorrent 等很多种服务。它可用于 x86-64 和 ARM 平台。 在x86-64平台上&…
阅读更多...
推荐一款开源电子签章/电子合同系统

推荐一款开源电子签章/电子合同系统

文章目录 前言一、项目介绍二、项目地址三、技术架构四、代码结构介绍五、功能模块六、功能界面首页面手写签名面板电子印章制作数字证书生成 总结 前言 大家好&#xff01;我是智航云科技&#xff0c;今天为大家分享一个免费开源的电子签字系统。 一、项目介绍 开放签电子签…
阅读更多...
【Python】如何使用 Python 自动发送每日电子邮件报告

【Python】如何使用 Python 自动发送每日电子邮件报告

人不走空 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌赋&#xff1a;斯是陋室&#xff0c;惟吾德馨 目录 &#x1f308;个人主页&#xff1a;人不走空 &#x1f496;系列专栏&#xff1a;算法专题 ⏰诗词歌…
阅读更多...
详解Spring IoCDI（二）

详解Spring IoCDI（二）

目录 承接上文&#xff1a;详解Spring IoC&DI &#xff08;一&#xff09; 1.IoC详解 1.1方法注解Bean 1.2方法注解要配合类注解使用 1.3定义多个对象 1.4重命名Bean 1.5扫描路径 2.DI详解 2.1DI与IoC的关系 2.2属性注入 2.3构造方法注入 2.4Setter注入 2.5 三…
阅读更多...
【Endnote】如何在word界面加载Endnote

【Endnote】如何在word界面加载Endnote

如何在word界面加载Endnote 方法1&#xff1a;方法2&#xff1a;从word入手方法3&#xff1a;从CWYW入手参考 已下载EndNote,但Word中没有显示EndNote&#xff0c;应如何加载显示呢&#xff1f; 方法1&#xff1a; 使用EndNote的Configure EndNote.exe 。 具体步骤为&#x…
阅读更多...
内网安全：横向传递攻击（PTH || PTK || PTT 哈希票据传递）

内网安全：横向传递攻击（PTH || PTK || PTT 哈希票据传递）

内网安全&#xff1a;横向传递攻击. 横向移动就是在拿下对方一台主机后&#xff0c;以拿下的那台主机作为跳板&#xff0c;对内网的其他主机再进行后面渗透&#xff0c;利用既有的资源尝试获取更多的凭据、更高的权限&#xff0c;一步一步拿下更多的主机&#xff0c;进而达到控…
阅读更多...
理解AdaBoost算法：简单流程概述（一）【流程理解、无数学推导】

理解AdaBoost算法：简单流程概述（一）【流程理解、无数学推导】

什么是AdaBoost 算法&#xff1f; AdaBoost&#xff08;Adaptive Boosting&#xff09;算法&#xff0c;全称为 自适应提升 &#xff0c;是 一种在机器学习中用作集成方法的提升技术 。它之所以被称为自适应提升&#xff0c;因为每个实例的权重会重新分配&#xff0c;错误分类…
阅读更多...
最新文章

Copyright @ 2022~2023