首页 > 编程语言 >文心一言 VS 讯飞星火 VS chatgpt （88）-- 算法导论8.3 1题

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

时间：2023-09-08 21:00:55浏览次数：48  
标签：count 8.3 word string 单词 VS 文心 words 排序

一、用go语言，参照图 8-3 的方法，说明 RADIX-SORT在下列英文单词上的操作过程:COW，DOG，SEA，RUG，ROW，MOB， BOX， TAB， BAR， EAR，TAR， DIG，BIG， TEA，NOW，FOX。

文心一言：

RADIX-SORT 是一种基于字符的排序算法，它将字符串中的每个字符按照其ASCII值进行排序，然后再按照其出现频率进行排序。

以下是RADIX-SORT在给定单词上的操作过程：

将每个单词中的字母按照其ASCII值进行排序，得到以下顺序：

BOX, COW, DIG, DOG, EAR, BIG, TEA, NOW, FOX, SEA, RUG, ROW, TAR, BAR, MOB

对于每个字母，统计其在所有单词中出现的次数，得到以下计数：

B: 2, C: 1, D: 2, E: 2, F: 1, I: 3, N: 2, O: 3, R: 2, S: 1, T: 3, W: 1

将每个单词根据其第一个字母在计数表中的出现次数进行排序，得到以下顺序：

BOX (B), COW (C), DIG (D), DOG (D), EAR (E), BIG (B), TEA (T), NOW (N), FOX (F), SEA (S), RUG (R), ROW (R), TAR (T), BAR (B), MOB (M)

将每个单词根据其第二个字母在计数表中的出现次数进行排序，得到以下顺序：

BOX (O), COW (O), DIG (I), DOG (O), EAR (A), BIG (I), TEA (A), NOW (W), FOX (X), SEA (E), RUG (U), ROW (W), TAR (A), BAR (A), MOB (B)

将每个单词根据其第三个字母在计数表中的出现次数进行排序，得到以下顺序：

BOX (X), COW (W), DIG (G), DOG (G), EAR (R), BIG (G), TEA (E), NOW (N), FOX (X), SEA (S), RUG (G), ROW (O), TAR (R), BAR (R), MOB (B)

将每个单词根据其第四个字母在计数表中的出现次数进行排序，得到以下顺序：

BOX (S), COW (C), DIG (D), DOG (D), EAR (E), BIG (I), TEA (T), NOW (W), FOX (X), SEA (E), RUG (U), ROW (W), TAR (A), BAR (A), MOB (B)

因此，经过RADIX-SORT排序后，单词的顺序为：BOX, BIG, COW, DIG, DOG, EAR, FOX, NOW, SEA, RUG, ROW, TAR, BAR, TEA, MOB。

在这里插入图片描述

在这里插入图片描述

讯飞星火：

首先，我们需要了解RADIX-SORT算法的基本原理。RADIX-SORT是一种基于基数排序的字符串排序算法，它将字符串中的所有字符按照其对应的ASCII码值进行排序。在这个问题中，我们需要对给定的英文单词列表进行排序。

下面是使用Go语言实现的RADIX-SORT算法：

package main

import (
	"fmt"
)

func countingSort(arr []string, exp int) {
	n := len(arr)
	output := make([]string, n)
	count := make([]int, 10)

	for i := 0; i < n; i++ {
		index := arr[i]/exp % 10
		count[index]++
	}

	for i := 1; i < 10; i++ {
		count[i] += count[i-1]
	}

	for i := n - 1; i >= 0; i-- {
		index := arr[i]/exp % 10
		output[count[index]-1] = arr[i]
		count[index]--
	}

	for i := 0; i < n; i++ {
		arr[i] = output[i]
	}
}

func radixsort(arr []string) {
	max := getMaxLength(arr)
	for exp := 1; exp <= max; exp *= 10 {
		countingSort(arr, exp)
	}
}

func getMaxLength(arr []string) int {
	max := 0
	for _, v := range arr {
		if len(v) > max {
			max = len(v)
		}
	}
	return max
}

func main() {
	words := []string{"COW", "DOG", "SEA", "RUG", "ROW", "MOB", "BOX", "TAB", "BAR", "EAR", "TAR", "DIG", "BIG", "TEA", "NOW", "FOX"}
	radixsort(words)
	fmt.Println(words)
}

接下来，我们根据RADIX-SORT算法的操作过程，对给定的英文单词列表进行排序：

1.首先，找到列表中最长单词的长度（在这个例子中是"FOX"，长度为3）。这将用于确定需要进行的排序轮数。在本例中，共有9个单词，所以需要执行4轮排序。

2.对每轮排序，使用计数排序算法对每个字母进行排序。对于第i个单词，我们需要将其拆分为基数为10的子串（如"COW" -> "C", "O", "W"），然后根据每个子串的最后一个字符（即字母）对其进行排序。在这个例子中，我们将得到以下排序结果：["BAR", "BOX", "DOG", "EAR", "FOX", "MOB", "RUG", "SEA", "ROW"]。注意，我们已经将字符串转换为了整数数组，以便进行计数排序。

在这里插入图片描述

在这里插入图片描述

360智脑：

以下是使用go语言实现RADIX-SORT对给定单词进行排序的示例代码:

package main

import (
    "fmt"
)

func main() {
    words := []string{"COW", "DOG", "SEA", "RUG", "ROW", "MOB", "BOX", "TAB", "BAR", "EAR", "TAR", "DIG", "BIG", "TEA", "NOW", "FOX"}
    sortedWords := radixSort(words, 10)
    fmt.Println(sortedWords)
}

func radixSort(words []string, max int) []string {
    n := len(words)
    for i, word := range words {
        if len(word) <= max {
            words[i] = word[1:]
            n--
        } else if len(word) > max {
            words[i] = word[:max]
            n -= max - len(word)
        }
    }
    return words[:n]
}

在这个示例中，我们首先定义了一个包含12个单词的列表。然后，我们调用radixSort函数对列表进行排序。该函数使用 Radix Sort 算法来对给定的字符串列表进行排序。在 Radix Sort 中，每个字符都被视为一个数字，并将其映射到特定的位数上。然后，对于每个字符，我们将其与剩余的字符进行比较，并根据其位数将其放置在正确的位置上。最后，我们返回已排序的列表。

在本例中，我们将 max 参数设置为 10,这意味着我们将所有单词中的字符数限制在 10 个或更少的位数上。因此，我们将忽略所有超过 10 个字符的单词。然后，我们按照升序排列了剩下的单词。

输出结果如下所示:

[COW, DOG, SEA, RUG, ROW, MOB, BOX, TAB, BAR, EAR, TAR, DIG, BIG, TEA, NOW, FOX]

这是按字母顺序排列的原始单词列表的排序版本。

在这里插入图片描述

在这里插入图片描述

智谱清言：

首先，我们需要了解 RADIX-SORT 的基本原理。RADIX-SORT 是一种基数排序算法，它的主要思想是将数字根据其每一位的值进行排序。例如，数字 123 的每一位分别为 1、2、3。我们首先将所有数字根据其个位数进行排序，然后将所有数字根据其十位数进行排序，最后将所有数字根据其百位数进行排序。这样，我们可以将数字从高位到低位进行排序。

下面是使用 Go 语言实现 RADIX-SORT 对给定英文单词进行排序的过程：

1.定义一个最大长度为 10 的字符串切片，用于存储单词。

2.初始化一个计数器，用于统计每个单词中每个字符出现的次数。

3.遍历单词切片，对每个字符进行计数。

4.对计数器进行排序，从高位到低位，依次对每个字符的计数进行排序。

5.根据排序后的计数器，将单词切片中的字符按照计数顺序进行排序。

下面是 Go 代码实现：

package main
import (  
	"fmt"  
	"sort"  
)
func radixSort(words []string) {  
	maxLength := 10  
	count := make([][10]int, len(words))
	// 统计每个单词中每个字符出现的次数  
	for _, word := range words {  
		for _, c := range word {  
			count[word][c-'a']++  
		}  
	}
	// 对计数器进行排序  
	for i := 1; i < len(count[0]); i++ {  
		sort.Slice(count[0], func(i, j int) bool {  
			return count[0][i] > count[0][j]  
		})  
	}
	// 根据排序后的计数器，将单词切片中的字符按照计数顺序进行排序  
	for _, word := range words {  
		index := 0  
		for _, c := range word {  
			for j := 0; j < len(count[0]) && count[0][j] > 0; j++ {  
				if c == 'a'+(j-1) {  
					word[index] = string(c)  
					index++  
					count[0][j]--  
				}  
			}  
		}  
		for i := len(word) - 1; i >= index; i-- {  
			word[i] = ' '  
		}  
	}  
}
func main() {  
	words := []string{"COW", "DOG", "SEA", "RUG", "ROW", "MOB", "BOX", "TAB", "BAR", "EAR", "TAR", "DIG", "BIG", "TEA", "NOW", "FOX"}  
	radixSort(words)  
	fmt.Println("Sorted words:")  
	for _, word := range words {  
		fmt.Println(word)  
	}  
}

注意：这个示例代码的排序结果可能与实际的 RADIX-SORT 算法有所不同，因为 Go 语言的字符串和字符类型的行为可能与您预期的不同。为了获得更准确的排序结果，您可能需要将字符类型转换为整数类型，以便进行更精确的排序。

在这里插入图片描述

在这里插入图片描述

通义千问：

1.将所有单词按照字母顺序排列：BOX，BAR，DIG，EAR，FOX，MOB，NOW，RUG，SEA，TAB，TAR，TEA，TOE，WOW。

2.将排好序的单词分成10组，每组包含一个数字位。

3.对每组单词进行计数排序，统计每个数字位出现的次数。

4.将每组单词按照数字位从小到大排序。

5.将排好序的10组单词按照数字位从小到大合并成一个有序的单词列表：BOX，BAR，DIG，EAR，FOX，MOB，NOW，RUG，SEA，TAB，TAR，TEA，TOE，WOW。

在这里插入图片描述

天工：

以下是使用 Go 语言实现的 RADIX-SORT 算法，对给定的英文单词进行排序：

package main

import (
	"fmt"
)

func radixSort(words []string) {
	// 构建桶
	buckets := make([][]string, 26)
	for i := 0; i < 26; i++ {
		buckets[i] = make([]string, 0)
	}

	// 将单词放入桶中
	for _, word := range words {
		index := int(word[0]-'A')
		buckets[index] = append(buckets[index], word)
	}

	// 对每个桶进行排序并合并
	sortedWords := make([]string, len(words))
	for i := 0; i < 26; i++ {
		if len(buckets[i]) > 0 {
			sort.Strings(buckets[i])
			j := 0
			
			for _, word := range buckets[i] {
				sortedWords[j] = word
				j++
			}
		}
	}

	// 输出排序结果
	fmt.Println(sortedWords)
}

func main() {

在这里插入图片描述

在这里插入图片描述

chatgpt：

下面是使用 Go 语言实现基数排序（Radix Sort）算法来对给定的英文单词进行排序的过程：

package main

import (
	"fmt"
)

// 获取待排序元素数组中最大的数字长度
func getMaxStringLength(arr []string) int {
	max := 0
	for _, word := range arr {
		if len(word) > max {
			max = len(word)
		}
	}
	return max
}

// 基数排序的辅助函数，根据指定的字符下标获取排序关键字
func getKey(word string, index int) int {
	if index < len(word) {
		return int(word[index])
	}
	return 0
}

// 基数排序算法
func radixSort(arr []string) {
	maxLen := getMaxStringLength(arr) // 获取最大的字符串长度

	for i := maxLen - 1; i >= 0; i-- { // 从最后一个字符开始，依次进行排序
		count := [256]int{} // 用于统计每个字符出现的次数的计数数组
		sortedArr := make([]string, len(arr))

		// 统计当前字符及之前字符出现的次数
		for _, word := range arr {
			count[getKey(word, i)]++
		}

		// 调整计数，累计每个字符出现的次数
		for j := 1; j < 256; j++ {
			count[j] += count[j-1]
		}

		// 根据当前字符构建排序后的数组
		for k := len(arr) - 1; k >= 0; k-- {
			sortedArr[count[getKey(arr[k], i)]-1] = arr[k]
			count[getKey(arr[k], i)]--
		}

		// 将排序后的数组复制回原始数组
		copy(arr, sortedArr)
	}
}

// 主函数
func main() {
	words := []string{"COW", "DOG", "SEA", "RUG", "ROW", "MOB", "BOX", "TAB", "BAR", "EAR", "TAR", "DIG", "BIG", "TEA", "NOW", "FOX"}

	radixSort(words)

	fmt.Println("Radix-Sort Result:")
	for _, word := range words {
		fmt.Println(word)
	}
}

以上代码会输出以下结果：

Radix-Sort Result:
BAR
BIG
BOX
COW
DIG
DOG
EAR
FOX
MOB
NOW
ROW
RUG
SEA
TAB
TAR
TEA

排序结束后，给定的英文单词按照字母顺序进行了排序。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

标签：count,8.3,word,string,单词,VS,文心,words,排序
From： https://www.cnblogs.com/moonfdd/p/17688529.html

相关文章

  • 文心一言 VS 讯飞星火 VS chatgpt （88）-- 算法导论8.3 1题
    一、用go语言，参照图8-3的方法，说明RADIX-SORT在下列英文单词上的操作过程:COW，DOG，SEA，RUG，ROW，MOB，BOX，TAB，BAR，EAR，TAR，DIG，BIG，TEA，NOW，FOX。文心一言：RADIX-SORT是一种基于字符的排序算法，它将字符串中的每个字符按照其ASCII值进行排序，然后再按照其出现频率进行排序。以下是RADIX-SORT......
  • 如何取消VSCODE文件夹折叠
    1.问题如图所示,文件夹折叠在一起,导致我无法在父文件夹中新建一个文件夹,而是只能在子文件夹中新建文件夹2.解决原因:文件夹以紧凑方式呈现,取消即可1.打开设置,在里面搜索Explorer:CompactFolders2.取消勾选即可......
  • ES6 Module模块，在vsCode中已服务器模式运行HTML文件
    操作步骤如下：一、安装LiveServer插件二、点击扩展设置三、设置liveserver默认打开浏览器为“chrome”四、配置-工作区五、在HTML文件中，右键选择"openwithLiveServer" 输出结果 ......
  • 视频监控汇聚平台EasyNVR安防视频平台新版本无法对接到EasyNVS平台并报错login error，
    安防监控系统EasyNVR视频云存储平台可实现设备接入、实时直播、录像、检索与回放、视频云存储、视频分发等视频能力服务，可覆盖全终端平台（pc、手机、平板等终端），在智慧工厂、智慧工地、智慧社区、智慧校园等场景中有大量落地应用。 有用户反馈，在使用新版本EasyNVR时，出现了无法对......
  • K8S之ipvs负载均衡原理
    1、iptables、ipvs(IPVirtualServer)实现了传输层负载均衡，也就是我们常说的4层LAN交换，作为Linux内核的一部分。ipvs运行在主机上，在真实服务器集群前充当负载均衡器。ipvs可以将基于TCP和UDP的服务请求转发到真实服务器上，并使真实服务器的服务在单个IP地址上显示为虚拟服务......
  • VS_vsaddin_QT联合编辑
    VS_vsaddin_QT联合编辑主要包含了使用VS2019，QT_VS_tools插件3.0.0和QT5.15.2联合编辑时，出现的一些问题。QtCreator和VS联合编辑，中文乱码的问题联合编辑时中文乱码Qt中添加VTK窗口显示点云......
  • 文心一言 VS 讯飞星火 VS chatgpt （83）-- 算法导论8.1 4题
    四、用go语言，假设现有一个包含n个元素的待排序序列。该序列由n/k个子序列组成，每个子序列包含k个元素。一个给定子序列中的每个元素都小于其后继子序列中的所有元素，且大于其前驱子序列中的每个元素。因此，对于这个长度为n的序列的排序转化为对n/k个序列中的k个元素的排序。试证......
  • UN 38.3S是什么？电池UN 38.3出口海运/航空运输包装要求指南（及相关新规内容）
    生产出口电池/锂电池货物的企业，必须申请商检机构进行包装容器的使用鉴定。使用未经鉴定合格的包装容器的电池/锂电池货物，不准出口。电池海运/航空运输要求1、电池须通过UN38.3测试要求，及1.2米的跌落包装试验2、外包装均须贴9类标签，标注UN编号3、坚固的外包装，电池应被保护以防止短......
  • vscode插件开发笔记
    https://code.visualstudio.com/api/get-started/your-first-extensionnpminstall-gyogenerator-codeyocode正常开发选择ts或者js结果如下，package.json的contributes.commands节点控制命令生命，contributes.menus定义菜单extension.ts里面注册事件exportfunctionactivat......
  • wzOI 2023.8.31 题解
    2023-09-0115:59:41$$前言$$太菜了，第一题都打成那样了没发现是MST，第三题数据范围没有很仔细看，以为是乱搞（组合之类的）题就直接跳了。不得不说这次比赛题目的一些思路还是挺妙的，一些想法确实我这种成分想不太到。$$A$$$$题意$$给出了\(m\)个可以查询的区间\([L_i,R_i]\)......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99