文心一言 VS 讯飞星火 VS chatgpt （84）-- 算法导论8.2 1题

news2024/9/23 11:28:03

一、用go语言，参照图8-2 的方法，说明 COUNTING-SORT 在数组 A=(6，0，2，0，1，3，4，6，1，3，2)上的操作过程。

文心一言：

Counting Sort 是一种非比较型整数排序算法，适用于一定范围内的整数排序。它的基本思想是，对每一个输入元素 x，确定小于 x 的元素个数，从而确定 x 在输出数组中的位置。

下面是使用 Go 语言实现的 Counting Sort 算法的代码：

package main  
  
import (  
 "fmt"  
)  
  
func countingSort(array []int) []int {  
 // 找出数组中的最大值和最小值  
 max := int(^uint(0) >> 1)  
 min := int(^uint(max) >> 1)  
  
 // 初始化计数数组，长度为最大值减最小值加1  
 count := make([]int, max-min+1)  
  
 // 统计每个元素出现的次数  
 for _, v := range array {  
 count[v-min]++  
 }  
  
 // 重新赋值，使得每个元素等于它出现的次数加上之前已经排序好的元素个数  
 index := 0  
 for i, v := range count {  
 for v > 0 {  
 array[index] = i + min  
 count[i]--  
 index++  
 }  
 }  
 return array  
}  
  
func main() {  
 array := []int{6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2}  
 fmt.Println(countingSort(array))  
}

这段代码首先找到输入数组的最大值和最小值，然后创建一个计数数组，长度为最大值减去最小值再加1。然后遍历输入数组，对每个元素在计数数组中对应的位置增加1。最后，重新赋值，使得每个元素等于它出现的次数加上之前已经排序好的元素个数。这样就可以得到排序后的数组。

在这里插入图片描述

在这里插入图片描述

讯飞星火：

首先，我们需要了解COUNTING-SORT算法的基本原理。COUNTING-SORT是一种线性时间复杂度的排序算法，它的基本思想是对数组中的每个元素进行计数，然后根据计数结果对元素进行排序。具体操作过程如下：

1.初始化一个计数数组count，用于存储每个元素出现的次数。

2.遍历数组A，对每个元素进行计数。

3.根据计数数组count，将元素重新放回数组A中的正确位置。

下面是使用Go语言实现的COUNTING-SORT算法，并对数组A=(6,0,2,0,1,3,4,6,1,3,2)进行排序的过程：

package main

import (
	"fmt"
)

func countingSort(arr []int) {
	count := make([]int, len(arr)+1)
	for i := 0; i < len(arr); i++ {
		count[arr[i]]++
	}

	for i := 1; i < len(count); i++ {
		count[i] += count[i-1]
	}

	result := make([]int, len(arr))
	for i := len(arr) - 1; i >= 0; i-- {
		result[count[arr[i]]-1] = arr[i]
		count[arr[i]]--
	}

	copy(arr, result)
}

func main() {
	arr := []int{6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2}
	fmt.Println("原始数组：", arr)
	countingSort(arr)
	fmt.Println("排序后的数组：", arr)
}

运行上述代码，可以得到数组A在COUNTING-SORT算法下的排序结果：

原始数组： [6 0 2 0 1 3 4 6 1 3 2]
排序后的数组： [0 0 1 1 2 2 3 3 3 4 6 6]

在这里插入图片描述

在这里插入图片描述

360智脑：

首先，我们需要确定数组 A 中有多少元素。使用 range 循环遍历数组 A,并使用变量 count 记录当前元素的位置。


for i := 0; i < len(A); i++ { 

    count := i 

    // ... 

}

接下来，我们可以使用一个 for 循环将每个元素从 count 的位置开始逐个比较，直到达到 count + 1 的位置为止。在每次比较中，如果当前元素大于下一个元素，就将它们交换位置。


for i, count := range A { 

    if A[i] > A[count]: 

        A[i], A[count] = A[count], A[i] 

        count++ 

}

最后，我们可以使用 range 循环遍历数组 A,并使用变量 sum 记录每个元素的累加和。然后，我们可以将结果输出到控制台。


for i, count := range A { 

    sum += A[i] 

    fmt.Printf("Element %d: %d 

", i+1, A[i]) 

}

完整代码如下:


package main 

 

import "fmt" 

 

func main() { 

    A := []int{6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2} 

    for i, count := range A { 

        sum += A[i] 

        fmt.Printf("Element %d: %d 

", i+1, A[i]) 

    } 

    fmt.Println() 

}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

智谱清言：

COUNTING-SORT 是一种对数组进行排序的算法，其基本思想是统计数组中每个元素的出现次数，然后将计数结果存储在一个新的数组中，接着将新数组中的元素还原到原数组中，从而实现对原数组的排序。

以下是使用 Go 语言实现 COUNTING-SORT 算法对数组 A=(6，0，2，0，1，3，4，6，1，3，2) 进行排序的过程：

1.初始化一个长度为 10 的数组 count，用于存储每个元素的出现次数。

2.遍历数组 A 中的元素，将 count 数组中对应元素的计数加 1。

3.创建一个长度为 10 的临时数组 temp，用于存储排序后的元素。

4.遍历 count 数组，将 count 数组中每个元素的值还原到 temp 数组中，同时将 temp 数组的对应位置置为 1。

5.将 temp 数组的元素复制回数组 A。

下面是使用 Go 语言实现上述过程的代码：

package main
import "fmt"
func countingSort(A []int) []int {  
   count := make([]int, 10) // 初始化计数数组  
   for _, v := range A {  
       count[v]++             // 统计每个元素的出现次数  
   }
   temp := make([]int, len(A)) // 初始化临时数组  
   for _, v := range count {  
       for v == 0 {  
           temp[v] = 0           // 将计数为 0 的元素值还原到临时数组中  
           v++  
       }  
   }
   for i := 0; i < len(A); i++ {  
       A[i] = temp[i]       // 将临时数组的元素复制回原数组  
   }
   return A  
}
func main() {  
   A := []int{6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2}  
   fmt.Println("Before sorting:", A)  
   fmt.Println("After sorting:", countingSort(A))  
}

执行上述代码，可以得到排序后的数组 A：[0 0 1 1 2 2 3 3 4 6 6]。

在这里插入图片描述

在这里插入图片描述

通义千问：

COUNTING-SORT 是一种基于计数排序的排序算法，其基本思路是先统计待排序序列中每个元素出现的次数，然后根据元素出现的次数从小到大依次输出元素。

在对数组 A=(6，0，2，0，1，3，4，6，1，3，2) 进行 COUNTING-SORT 操作的过程如下：

1.初始化计数数组 C，其中 C[i] 表示元素 i 在原始数组 A 中出现的次数。初始状态下，C[i] 均为 0。

2.遍历原始数组 A，将每个元素 A[i] 的出现次数累加到计数数组 C 中，即 C[A[i]]++。

3.找到最大的元素 M，即 M=max(A…)。

4.创建一个新的数组 B，其长度为 M+1。

5.遍历计数数组 C，将每个元素 A[i] 在数组 B 中对应的位置的值设为 C[A[i]]。即 B[C[A[i]]] = A[i]。

6.从数组 B 的第一位开始，输出每个元素，直到输出到最后一位。

在对数组 A=(6，0，2，0，1，3，4，6，1，3，2) 进行 COUNTING-SORT 操作的过程中，每个元素的出现次数如下：

6: 2
0: 2
2: 2
1: 2
3: 2
4: 1
6: 1
1: 1
3: 1
2: 1

根据元素出现的次数从小到大依次输出元素，得到的有序数组为：

1, 1, 2, 2, 2, 3, 3, 4, 6, 6

在这里插入图片描述

天工：

下面是使用 Go 语言实现 COUNTING-SORT 算法的示例代码，参照图8-2的方法对数组 A=(6，0，2，0，1，3，4，6，1，3，2) 进行排序：

package main

import "fmt"
	// 导入 fmt 包

func countingSort(arr []int) []int {
    // 初始化计数数组
    count := make([]int, 10)
    for i := 0; i < 10; i++ {
        count[i] = 0
    }

    // 统计每个元素出现的次数
    for _, num := range arr {
        count[num]++
    }

    // 计算每个元素在排好序数组中的位置
    index := make([]int, len(arr))
    for i := 0; i < len(arr); i++ {
        index[count[arr[i]]-1] = arr[i]
        count[arr[i]]--
    }

    // 将排好序的数组复制回原数组
    copy(arr, index)
    return arr
}

func main() {
	// 定义测试数组
	arr := []int{6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2}

	// 输出原始数组
	fmt.Println("Original array:", arr)

	// 对数组进行 COUNTING-SORT 排序
	arr = countingSort(arr)

	// 输出排序后的数组
	fmt.Println("Sorted array:", arr)
}

运行上述代码，输出结果为：

Original array: 	[6 0 2 0 1 3 4 6 1 3 2]
Sorted array:	[0 0 1 1 2 2 3 4 6 6 6]

可以看到，COUNTING-SORT 算法成功地对数组 A 进行了排序，并得到了正确的结果。

在这里插入图片描述

在这里插入图片描述

chatgpt：

COUNTING-SORT 是一种线性时间复杂度的排序算法，适用于待排序元素的范围比较有限的情况。下面是参照图8-2的方法在数组 A=(6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2) 上执行 COUNTING-SORT 的操作过程：

1.初始化计数数组 C：
C = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
数组 C 的长度为待排序数组 A 的最大值加1，即10。

2.计算每个元素出现的次数：
遍历数组 A，统计每个元素出现的次数，并在数组 C 对应的位置上增加计数。
A[0] = 6，C[6] = C[6] + 1 = 1
A[1] = 0，C[0] = C[0] + 1 = 1
A[2] = 2，C[2] = C[2] + 1 = 1
A[3] = 0，C[0] = C[0] + 1 = 2
A[4] = 1，C[1] = C[1] + 1 = 1
A[5] = 3，C[3] = C[3] + 1 = 1
A[6] = 4，C[4] = C[4] + 1 = 1
A[7] = 6，C[6] = C[6] + 1 = 2
A[8] = 1，C[1] = C[1] + 1 = 2
A[9] = 3，C[3] = C[3] + 1 = 2
A[10] = 2，C[2] = C[2] + 1 = 2
统计完成后，数组 C 的内容为：C = [2, 2, 2, 2, 1, 0, 2, 0, 0, 0]

3.累加计数数组 C：
对数组 C 进行累加， C[i] = C[i] + C[i-1]。
C = [2, 4, 6, 8, 9, 9, 11, 11, 11, 11]

4.构建有序输出数组 B：
初始化输出数组 B，长度与待排序数组 A 相同。
B = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
从右向左遍历数组 A，根据计数数组 C 的值，将元素放置到有序数组 B 的相应位置上，同时更新计数数组 C 的值。
A[10] = 2，C[2] = C[2] - 1 = 1，B[1] = 2
A[9] = 3，C[3] = C[3] - 1 = 1，B[2] = 3
A[8] = 1，C[1] = C[1] - 1 = 1，B[3] = 1
A[7] = 6，C[6] = C[6] - 1 = 1，B[4] = 6
A[6] = 4，C[4] = C[4] - 1 = 0，B[5] = 4
A[5] = 3，C[3] = C[3] - 1 = 0，B[6] = 3
A[4] = 1，C[1] = C[1] - 1 = 0，B[7] = 1
A[3] = 0，C[0] = C[0] - 1 = 1，B[8] = 0
A[2] = 2，C[2] = C[2] - 1 = 0，B[9] = 2
A[1] = 0，C[0] = C[0] - 1 = 0，B[10] = 0
A[0] = 6，C[6] = C[6] - 1 = 0，B[11] = 6
完成后，输出数组 B 的内容为：B = [0, 0, 0, 0, 0, 0, 1, 2, 2, 3, 4, 6]

经过 COUNTING-SORT 操作后，数组 A=(6, 0, 2, 0, 1, 3, 4, 6, 1, 3, 2) 被排序为 B = [0, 0, 0, 0, 0, 0, 1, 2, 2, 3, 4, 6]。

在这里插入图片描述

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2023-8-31 有边数限制的最短路(bellman-ford)

2023-8-31 有边数限制的最短路(bellman-ford)

题目链接&#xff1a;有边数限制的最短路 #include <iostream> #include <cstring> #include <algorithm>using namespace std;const int N 510, M 10010;int n, m, k; int dist[N], backup[N];// 存放边的信息 struct Edge {int a, b, w; }edges[M];void …
阅读更多...
mysql group by 字段 与 select 字段

mysql group by 字段 与 select 字段

表数据如下&#xff1a; 执行SQL语句1&#xff1a; SELECT * FROM z_course GROUP BY NAME,SEX 结果&#xff1a; 执行SQL语句2&#xff1a; SELECT * FROM z_course GROUP BY NAME sql 1 根据 name&#xff0c;sex 两个字段分组&#xff0c;查询 所有字段&#xff0c;返回结…
阅读更多...
GitHub打不开解决方法——授人以渔

GitHub打不开解决方法——授人以渔

打不开GitHub的原因之一&#xff0c;DNS地址解析到了无法访问的ip。&#xff08;为什么无法访问&#xff1f;&#xff09; 1、打开GitHub看是哪个域名无法访问&#xff0c;F12一下 2、DNS解析看对应的域名目前哪个IP可以访问 DNS解析的网址&#xff1a; &#xff08;1&#x…
阅读更多...
OpenBSD新版将增加KARL功能：重启换内核

OpenBSD新版将增加KARL功能：重启换内核

在 OpenBSD 的测试快照中加入了一个新的功能&#xff0c;每次当 OpenBSD 用户重启或升级计算机时都会创建一个独特的内核。该功能被称之为 KARL&#xff08;内核地址随机化链接Kernel Address Randomized Link&#xff09;&#xff0c;即以随机的顺序重新链接其内部的内核文件&…
阅读更多...
深度学习技巧应用26-CNN中多种注意力机制的嵌入方法，终于搞懂注意力机制了

深度学习技巧应用26-CNN中多种注意力机制的嵌入方法，终于搞懂注意力机制了

大家好，我是微学AI，今天给大家介绍一下深度学习技巧应用26-CNN中多种注意力机制的嵌入方法，终于搞懂注意力机制了。CNN是一种能够有效处理图像和其他二维数据的深度学习模型。在传统的CNN中，每个卷积核都会对输入的所有位置进行相同的操作，这可能导致网络无法针对特定区域…
阅读更多...
Oracle中LEFT JOIN后AND与WHERE的异同

Oracle中LEFT JOIN后AND与WHERE的异同

1、AND 过滤之后再连接 2、WHERE 连接之后再过滤 下面以具体例子来说明&#xff1a; (1)、建表及插入测试数据 --建测试表 create table FACT_TAB ( ID INTEGER,STATUS VARCHAR2(8) ); create table DIM_STATUS ( STSTUS_CLASS VARCHAR2(8),STATUS_CODE VARCHAR2(8),S…
阅读更多...
VMware tools的安装以及按钮灰色的解决方法

VMware tools的安装以及按钮灰色的解决方法

VMware tools的安装 ** 注意&#xff1a;** 新版本的 VMware 会自动安装的 VMware tools&#xff0c;如何测试 VMware tools 呢&#xff1f;在Windows 系统里复制一段话&#xff0c;能粘贴到 Ubuntu 系统里终端里&#xff0c;说明 VMware tools 已经安装了。 没有安装的请参考…
阅读更多...
聚观早报｜阿维塔完成B轮融资；文心一言向全社会开放

聚观早报｜阿维塔完成B轮融资；文心一言向全社会开放

【聚观365】9月1日消息 阿维塔完成B轮融资 文心一言向全社会开放 长安汽车上半年销量超121万辆 北京工人体育场5G超级网络启用 挚文集团Q2净利润5.684亿元 阿维塔完成B轮融资 日前&#xff0c;阿维塔科技宣布完成B轮融资&#xff0c;募集资金30亿元&#xff0c;投后估值近…
阅读更多...
指针：程序员的望远镜

指针：程序员的望远镜

指针 1. 前言2. 指针概述2.1 内存与地址2.2 取地址2.3 指针是什么&#xff1f;2.4 解引用&#xff08;间接访问&#xff09;2.5 指针的大小 3. 指针类型的作用3.1 指针-整数3.2 指针的解引用 4. 野指针4.1 野指针成因4.2 如何规避野指针 5. 指针运算5.1 指针-整数5.2 指针-指针…
阅读更多...
若依后台管理系统学习

若依后台管理系统学习

前端系统是指运行在浏览器或者移动设备上的用户界面层&#xff0c;它负责与用户交互&#xff0c;展示数据&#xff0c;调用后端服务等。前端系统的架构设计需要考虑以下几个方面&#xff1a; 前端系统在整个系统中的位置和关系&#xff1a;你需要明确前端系统与后端服务&#…
阅读更多...
GE IS200JPDDG1AAA输入模块

GE IS200JPDDG1AAA输入模块

多通道输入&#xff1a; IS200JPDDG1AAA 可能具有多个输入通道&#xff0c;允许连接多个传感器或信号源。 信号类型&#xff1a; 这个模块通常支持不同类型的输入信号&#xff0c;包括模拟信号和数字信号。 高精度&#xff1a; 输入模块通常具有高精度的信号测量能力&#xf…
阅读更多...
Dialog 的标题title属性用slot实现。（复制功能）

Dialog 的标题title属性用slot实现。（复制功能）

当你的标题内容需要一些除了文字以外的功能&#xff0c;比如复制按钮&#xff0c;那么就需要用slot传入。 文档中是这么写的&#xff1a; 举例&#xff1a; <span slot"title" class"whitelist-title"><span> {{ whitelistId }} </span&g…
阅读更多...
亚马逊、速卖通如何批量养号？自养号测评对卖家有哪些好处？

亚马逊、速卖通如何批量养号？自养号测评对卖家有哪些好处？

测评养号就是自己用真实环境养出来的买家账号。通过国外的邮箱、手机号码和注册当地真实收货地址&#xff0c;包括当地的国外住宅专线IP、国外真实虚拟信用卡等等&#xff0c;不过很多卖家也没有完全认清自养号的好处。那么测评自养号对卖家有哪些好处&#xff1f; 1、不用担心…
阅读更多...
【C++】set和map

【C++】set和map

set和map 1. 预备知识2. set2.1 set的概念2.2 set的常见接口 3. multiset4. map4.1 map的概念4.2 map的常见接口 5. multimap6. 练习 1. 预备知识 set和map是关联式容器&#xff0c;里面存储的不是元素本身&#xff0c;存储的是<key,value>结构的键值对&#xff0c;比ve…
阅读更多...
Python入门教程 | Python3 字符串

Python入门教程 | Python3 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。 创建字符串很简单&#xff0c;只要为变量分配一个值即可。例如&#xff1a; var1 Hello World! var2 "Tarzan"Python 访问字符串中的值 Python 不支持单字符类型&#xff…
阅读更多...
J. Med. Chem 2022｜TocoDecoy+: 针对机器学习打分函数训练和测试的无隐藏偏差的数据集构建新方法

J. Med. Chem 2022｜TocoDecoy+: 针对机器学习打分函数训练和测试的无隐藏偏差的数据集构建新方法

原文标题&#xff1a;TocoDecoy: A New Approach to Design Unbiased Datasets for Training and Benchmarking Machine-Learning Scoring Functions 论文链接&#xff1a;https://pubs.acs.org/doi/10.1021/acs.jmedchem.2c00460 论文代码&#xff1a;GitHub - 5AGE-zhang/T…
阅读更多...
苹果手机安装Loanmate步骤

苹果手机安装Loanmate步骤

1.电脑端下载爱思助手桌面软件并安装 https://www.i4.cn/ 2.苹果手机连接电脑&#xff0c;出现以下成功连接界面 3.切换到应用游戏选项 4.把Loanmate.ipa 包拖到3 界面 5.等待手机安装成功
阅读更多...
智能电话机器人的出现，能够解决哪些问题？

智能电话机器人的出现，能够解决哪些问题？

经济的繁荣与高速的发展&#xff0c;使得电销这个方式快速地融合在房地产与金融投资等大部分行业上。在电销人员与客户的沟通上&#xff0c;难免会出现很多问题&#xff0c;毕竟所面对的客户都是各行各业&#xff0c;他们有着不同的经历和身份。 对于时常需要处理客户投诉、安…
阅读更多...
linux上vscode中.cpp文件中引入头文件.hpp时报错：找不到头文件（启用错误钵形曲线）

linux上vscode中.cpp文件中引入头文件.hpp时报错：找不到头文件（启用错误钵形曲线）

当在.cpp文件中引入系统给定的头文件时&#xff1a;#include < iostream > 或者引入自定义的头文件 &#xff1a;#include <success.hpp> 报错&#xff1a;找不到相应的头文件&#xff0c;即在引入头文件的改行底下标出红波浪线 解决方法为&#xff1a; &#…
阅读更多...
【前端】CSS-flexbox弹性盒模型布局

【前端】CSS-flexbox弹性盒模型布局

目录 一、前言二、flexbox简介三、属性1、容器属性2、容器成员属性 四、容器属性的作用1、flex-direction①、定义②、语句1&#xff09;、属性值 ③、代码示例1&#xff09;、flex-direction: row2&#xff09;、flex-direction: row-reverse3&#xff09;、flex-direction: c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023