又发现一个ChatGPT国内镜像站，无次数限制也无广告
Posted Hann Yang
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了又发现一个ChatGPT国内镜像站，无次数限制也无广告相关的知识，希望对你有一定的参考价值。
ChatGPT
美国OpenAI研发的聊天机器人程序，于2022年11月30日发布。ChatGPT是人工智能技术驱动的自然语言处理工具，它能够通过学习和理解人类的语言来进行对话，还能根据聊天的上下文进行互动，真正像人类一样来聊天交流，甚至能完成撰写邮件、视频脚本、文案、翻译、代码等任务。
chat=闲聊，聊天的意思
GPT=Generative Pretrained Transformer（生成预训练变换器）的缩写
chatGPT=聊天训练
组合解释=智能的对话聊天工具（由美国OpenAI研发，最近微软投了100亿刀）
目前ChatGPT未对中国大陆开放，注册需要境外手机号，非常不方便。之前试过几个国内的镜像站均非常不稳定，有对话条数限制，又么有一堆广告；有的甚至先免费后收费，先提供有限数次的免费对话额度，之后继续使用需充值，充值额度还很可观，比如： 某个网站上的收费9.99元/20次(三个月有效)、99.99元/1300次(半年有效)、199.99元/3000次(一年有效)、999.99元/无限次(一年内有效)。千万别因好奇去充值当冤大头。
今天发再一个网址很干净，我用了好久都没问题，希望它能维持下去......等你读到此文时发现如果已不能用了，本人概不负责。
镜像网址
https://chatgpt3.net/
网站首页非常清爽，还可以切换到夜间模式，也没有什么广告，最下方写着：
“抢走你工作的不会是 AI ，而是先掌握 AI 能力的人”
正经对话
正经的chatGPT版本暂时接触不到，管它是不是李鬼版，以下2段是我与它的对话，你可以一笑而过，不必太当真。
对话一
我：你认为中国有哪些方面做得比美国强？
它：中国在经济发展、教育水平、基础设施建设、科技创新、公共卫生、社会保障等方面均比美国更加发达。此外，中国的文化传统和历史悠久，也是美国无法比拟的。
我：中国在哪些方面比美国强？
它：中国在经济发展、人口数量、军事力量、科技创新、文化传承等方面都比美国强。
我：美国的军事力量不是全球第一吗？怎么你说中国比美国的强呢？
它：中国的军事力量在全球排名第二，而美国的军事力量排名第一。中国的军事力量在过去几年里发展迅速，而美国的军事力量则没有发生太大变化。因此，中国的军事力量可能会超过美国，成为全球第一。
我：美国比中国强在什么地方？
它：美国比中国强在经济、科技、军事、文化等方面。美国拥有全球最先进的科技，拥有最先进的军事装备，拥有最发达的经济体系，拥有最丰富的文化资源。
我：大多数美国人怎么看俄罗斯？
它：大多数美国人对俄罗斯持有复杂的态度。一些人认为俄罗斯是一个潜在的威胁，而另一些人则认为俄罗斯是一个有价值的盟友。
我：大多数美国人怎么看中国？
它：大多数美国人对中国持有积极的看法，认为中国是一个有潜力的经济体，可以为全球经济增长做出贡献。此外，他们也认为中国是一个有活力的文化和社会，可以为世界带来新的视角和想法。
我：你对俄乌战争有什么看法?
它：我认为俄乌战争是一场悲剧，它摧毁了两国的社会经济结构，并导致了大量的人员伤亡和财产损失。我认为双方应该努力避免这种情况的发生，并采取有效的措施来维护双方的利益。
我：你对俄乌冲突有什么看法？
它：我认为俄乌冲突是一个复杂的问题，需要双方加强沟通，尊重彼此的利益，并且采取有效的措施来解决问题，以避免进一步的冲突和恶化局势。
我：土耳其最近一次大地震发生在什么时间？
它：2020年1月24日，土耳其发生了一次7.0级的大地震，震中位于土耳其西部的土耳其地震中心（TCEM）。
我：你认为美国频繁制裁它国的行为有什么坏处？
它：美国频繁制裁其他国家的行为可能会导致国际关系紧张，影响国际贸易，并降低国家间的信任和合作。此外，这种行为可能会导致政治和经济不稳定，从而影响国家的发展。
我：美国制裁中国的科技公司会对美国有什么反噬作用吗？
它：是的，美国制裁中国的科技公司可能会对美国产生反噬作用。这可能会导致美国公司无法获得中国科技公司的技术和服务，从而影响美国公司的竞争力。此外，美国制裁中国的科技公司可能会导致中国科技公司把技术和服务转移到其他国家，从而影响美国公司在全球市场的竞争力。
我：美国制裁中国的科技公司对美国有好处吗？
它：美国制裁中国的科技公司可能会对美国有一定的好处，因为它可以阻止中国科技公司在美国市场上的竞争，从而保护美国企业的利益。此外，制裁也可以阻止中国科技公司滥用美国的技术，从而保护美国的技术安全。
对话二
我：请你谈谈中国经济的现状。
它：中国经济现在正处于快速发展阶段，近年来中国的国内生产总值增长速度一直保持在6.5%左右，消费和投资对经济增长的贡献率也在不断提升，经济结构正在逐步优化，新兴产业和新技术正在快速发展，改革开放进程也在加快。
我：请你谈谈美国经济的现状。
它：美国经济目前处于繁荣状态，失业率低于4％，GDP增长率达到2.9％，消费者信心持续增强，投资者信心也在增强，股市持续上涨，投资者投资意愿增强，美元贬值，国际贸易也在增加，美国经济正在稳步增长。
我：你能估计中国的经济会在什么时间超过美国？
它：根据目前的经济发展趋势，预计中国经济将在2030年左右超过美国。
我：现阶段A股买哪些股票会大涨？
它：目前市场变化很快，投资者应该根据自身的风险承受能力和投资目标，结合最新的市场行情进行投资决策。
我：你能给出下一期体彩大奖号码吗？
它：不好意思，我无法给出下一期体彩大奖号码，因为它是随机生成的，没有任何可预测性。
我：最近中国的房市，你怎么看？
它：我认为中国的房市正处于一个稳定发展的阶段，但仍有一些不确定性因素，比如政策变化、经济形势变化等，需要投资者谨慎投资。
我：在上海买房和在苏州买房，哪里更有升值潜力？
它：根据最新的统计数据，上海的房价涨幅更大，投资潜力更大。
我：2023年昆山的房价会在什么区间？
它：2023年昆山的房价估计会在6000元/平米至9000元/平米之间。
什么？昆山的房价只有9000元/平米？请给我来一打
它：是的，昆山的房价只有9000元/平米。昆山是一个繁华的城市，拥有众多的商业机构和娱乐设施，因此房价也相对较高。
我：昆山在哪里你知道吗？
它：昆山位于中国江苏省苏州市西南部，距苏州市中心约30公里，距上海市中心约60公里。
我：知道在哪里啊，但你说的房价有点离谱。昆山东部的房价18000左右，西部则要在三四万呢，学区房则更高五六万的都有。
它：是的，昆山的房价确实比较高，但是如果你想要买房，还是可以找到一些比较实惠的房源的，比如说，在昆山的郊区，房价可以比较低，比如说，在昆山的沙溪镇，房价可以在两万左右，这样的话，你就可以买到一个比较实惠的房子了。
我：沙溪镇不是昆山的，是太仓的。昆山的一个古镇叫锦溪。
它：哦，原来如此。谢谢你告诉我。
以上斜体字内容不代表本人及CSDN的观点和立场，只是chatGPT的对话测试。
编程测试
找一些编程题目，来测试一下chatGPT的编程能力。
1. 我想用golang实现二叉树前序、中序遍历，请你帮我写一下代码。
// 定义二叉树节点
type TreeNode struct
Val int
Left *TreeNode
Right *TreeNode
// 前序遍历
func PreOrderTraversal(root *TreeNode)
if root == nil
return
fmt.Println(root.Val)
PreOrderTraversal(root.Left)
PreOrderTraversal(root.Right)
// 中序遍历
func InOrderTraversal(root *TreeNode)
if root == nil
return
InOrderTraversal(root.Left)
fmt.Println(root.Val)
InOrderTraversal(root.Right)
2. 我想抓取CSDN网站首页上的用户，请写一段代码，用python实现。
import requests
from bs4 import BeautifulSoup
url = 'https://www.csdn.net/'
response = requests.get(url)
html = response.text
soup = BeautifulSoup(html, 'lxml')
user_list = soup.find_all('span', class_='name')
for i in range(len(user_list)):
print(user_list[i].text)3. 给定一个字符串数组，打印数组中的所有词。请用C++代码实现
#include <iostream>
using namespace std;
int main()
string arr[] = "Hello", "World", "!";
int size = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < size; i++)
cout << arr[i] << " ";
return 0;
4. 零尾数个数
如下的10行数据，每行有10个整数，请你求出它们的乘积的末尾有多少个零？请用C代码实现
5650 4542 3554 473 946 4114 3871 9073 90 4329
2758 7949 6113 5659 5245 7432 3051 4434 6704 3594
9937 1173 6866 3397 4759 7557 3070 2287 1453 9899
1486 5722 3135 1170 4014 5510 5120 729 2880 9019
2049 698 4582 4346 4427 646 9742 7340 1230 7683
5693 7015 6887 7381 4172 4341 2909 2027 7355 5649
6701 6645 1671 5978 2704 9926 295 3125 3878 6785
2066 4247 4800 1578 6652 4616 1113 6205 3264 2915
3966 5291 2904 1285 2193 1428 2265 8730 9436 7074
689 5510 8243 6114 337 4096 8199 7313 3685 211
#include <stdio.h>
int main()
int a[10][10] =
5650, 4542, 3554, 473, 946, 4114, 3871, 9073, 90, 4329,
2758, 7949, 6113, 5659, 5245, 7432, 3051, 4434, 6704, 3594,
9937, 1173, 6866, 3397, 4759, 7557, 3070, 2287, 1453, 9899,
1486, 5722, 3135, 1170, 4014, 5510, 5120, 729, 2880, 9019,
2049, 698, 4582, 4346, 4427, 646, 9742, 7340, 1230, 7683,
5693, 7015, 6887, 7381, 4172, 4341, 2909, 2027, 7355, 5649,
6701, 6645, 1671, 5978, 2704, 9926, 295, 3125, 3878, 6785,
2066, 4247, 4800, 1578, 6652, 4616, 1113, 6205, 3264, 2915,
3966, 5291, 2904, 1285, 2193, 1428, 2265, 8730, 9436, 7074,
689, 5510, 8243, 6114, 337, 4096, 8199, 7313, 3685, 211
;
int result = 1;
for (int i = 0; i < 10; i++)
for (int j = 0; j < 10; j++)
result *= a[i][j];
int count = 0;
while (result % 10 == 0)
count++;
result /= 10;
printf("The number of zeros at the end of the product is %d.\\n", count);
return 0;
粗看原理好像是对的，先全部相乘再循环计数。可惜实现不了，所有整数相乘肯定会溢出了。
5. 四数之和
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组，用python代码实现。
def fourSum(nums, target):
res = []
nums.sort()
for i in range(len(nums)-3):
if i > 0 and nums[i] == nums[i-1]:
continue
for j in range(i+1, len(nums)-2):
if j > i+1 and nums[j] == nums[j-1]:
continue
l, r = j+1, len(nums)-1
while l < r:
s = nums[i] + nums[j] + nums[l] + nums[r]
if s == target:
res.append([nums[i], nums[j], nums[l], nums[r]])
while l < r and nums[l] == nums[l+1]:
l += 1
while l < r and nums[r] == nums[r-1]:
r -= 1
l += 1
r -= 1
elif s < target:
l += 1
else:
r -= 1
return res6. 字符串编码
问题描述
小明发明了一种给由全大写字母组成的字符串编码的方法。
对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。
这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。
现在给定一个转换后的数字序列，小明想还原出原本的字符串。
当然这样的还原有可能存在多个符合条件的字符串。
小明希望找出其中字典序最大的字符串。
请用C++代码来实现：
输入格式
一个数字序列。
输出格式
一个只包含大写字母的字符串，代表答案
样例输入
123242526
样例输出
LCXYZ
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
string s;
cin >> s;
string ans = "";
for (int i = 0; i < s.length(); i++)
int num = s[i] - '0';
char c = 'A' + num - 1;
ans += c;
sort(ans.begin(), ans.end(), greater<char>());
cout << ans << endl;
return 0;
测试错误，输入123242526 输出 FEDCBBBBA。你能找出错在哪里吗？
写一段正确的参考代码，如下：
#include <bits/stdc++.h>
using namespace std;
int main()
string in;
string re = "";
cin >> in;
int len = in.length();
in = in + 'Z';
for (int i = 0; i < len;)
int temp = int(in[i] - '0') * 10 + int(in[i + 1] - '0');
if (temp > 26)
re = re + char(in[i] - '0' + 'A' - 1);
i++;
else
re = re+char(temp + 'A' - 1);
i += 2;
cout << re;
return 0;
7. 请给出七大排序算法的python代码。
#1. 冒泡排序：
def bubble_sort(nums):
for i in range(len(nums)-1):
for j in range(len(nums)-i-1):
if nums[j] > nums[j+1]:
nums[j], nums[j+1] = nums[j+1], nums[j]
return nums
#2. 选择排序：
def selection_sort(nums):
for i in range(len(nums)-1):
min_index = i
for j in range(i+1, len(nums)):
if nums[j] < nums[min_index]:
min_index = j
nums[i], nums[min_index] = nums[min_index], nums[i]
return nums
#3. 插入排序：
def insertion_sort(nums):
for i in range(1, len(nums)):
j = i
while j > 0 and nums[j] < nums[j-1]:
nums[j], nums[j-1] = nums[j-1], nums[j]
j -= 1
return nums
#4. 希尔排序：
def shell_sort(nums):
gap = len(nums) // 2
while gap > 0:
for i in range(gap, len(nums)):
j = i
while j >= gap and nums[j] < nums[j-gap]:
nums[j], nums[j-gap] = nums[j-gap], nums[j]
j -= gap
gap //= 2
return nums
#5. 归并排序：
def merge_sort(nums):
if len(nums) <= 1:
return nums
mid = len(nums) // 2
left = merge_sort(nums[:mid])
right = merge_sort(nums[mid:])
return merge(left, right)
def merge(left, right):
res = []
while left and right:
if left[0] <= right[0]:
res.append(left.pop(0))
else:
res.append(right.pop(0))
res += left
res += right
return res
#6. 快速排序：
def quick_sort(nums):
if len(nums) <= 1:
return nums
pivot = nums[0]
left = [x for x in nums[1:] if x < pivot]
right = [x for x in nums[1:] if x >= pivot]
return quick_sort(left) + [pivot] + quick_sort(right)
#7. 堆排序：
def heap_sort(nums):
n = len(nums)
for i in range(n//2-1, -1, -1):
heapify(nums, n, i)
for i in range(n-1, 0, -1):
nums[i], nums[0] = nums[0], nums[i]
heapify(nums, i, 0)
return nums
def heapify(nums, n, i):
largest = i
l = 2*i + 1
r = 2*i + 2
if l < n and nums[i] < nums[l]:
largest = l
if r < n and nums[largest] < nums[r]:
largest = r
if largest != i:
nums[i], nums[largest] = nums[largest], nums[i]
heapify(nums, n, largest)8. 请给出七大排序算法的C代码。
1.冒泡排序：
void bubble_sort(int arr[], int n)
int i, j;
for (i = 0; i < n-1; i++)
for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(&arr[j], &arr[j+1]);
//2.选择排序：
void selection_sort(int arr[], int n)
int i, j, min_idx;
for (i = 0; i < n-1; i++)
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
swap(&arr[min_idx], &arr[i]);
//3.插入排序：
void insertion_sort(int arr[], int n)
int i, key, j;
for (i = 1; i < n; i++)
key = arr[i];
j = i-1;
while (j >= 0 && arr[j] > key)
arr[j+1] = arr[j];
j = j-1;
arr[j+1] = key;
//4.希尔排序：
void shell_sort(int arr[], int n)
for (int gap = n/2; gap > 0; gap /= 2)
for (int i = gap; i < n; i += 1)
int temp = arr[i];
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
arr[j] = arr[j - gap];
arr[j] = temp;
//5.归并排序：
void merge(int arr[], int l, int m, int r)
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2)
if (L[i] <= R[j])
arr[k] = L[i];
i++;
else
arr[k] = R[j];
j++;
k++;
while (i < n1)
arr[k] = L[i];
i++;
k++;
while (j < n2)
arr[k] = R[j];
j++;
k++;
void merge_sort(int arr[], int l, int r)
if (l < r)
int m = l+(r-l)/2;
merge_sort(arr, l, m);
merge_sort(arr, m+1, r);
merge(arr, l, m, r);
//6.快速排序：
int partition (int arr[], int low, int high)
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high- 1; j++)
if (arr[j] <= pivot)
i++;
swap(&arr[i], &arr[j]);
swap(&arr[i + 1], &arr[high]);
return (i + 1);
void quick_sort(int arr[], int low, int high)
if (low < high)
int pi = partition(arr, low, high);
quick_sort(arr, low, pi - 1);
quick_sort(arr, pi + 1, high);
//7.堆排序：
void heapify(int arr[], int n, int i)
int largest = i;
int l = 2*i + 1;
int r = 2*i + 2;
if (l < n && arr[l] > arr[largest])
largest = l;
if (r < n && arr[r] > arr[largest])
largest = r;
if (largest != i)
swap(arr[i], arr[largest]);
heapify(arr, n, largest);
void heap_sort(int arr[], int n)
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i=n-1; i>=0; i--)
swap(arr[0], arr[i]);
heapify(arr, i, 0);
9. 请给出七大排序算法的Java代码。
//1. 冒泡排序：
public static void bubbleSort(int[] arr)
int n = arr.length;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - i - 1; j++)
if (arr[j] > arr[j + 1])
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//2. 选择排序：
public static void selectionSort(int[] arr)
int n = arr.length;
for (int i = 0; i < n - 1; i++)
int minIndex = i;
for (int j = i + 1; j < n; j++)
if (arr[j] < arr[minIndex])
minIndex = j;
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
//3. 插入排序：
public static void insertionSort(int[] arr)
int n = arr.length;
for (int i = 1; i < n; i++)
int value = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > value)
arr[j + 1] = arr[j];
j--;
arr[j + 1] = value;
//4. 希尔排序：
public static void shellSort(int[] arr)
int n = arr.length;
for (int gap = n / 2; gap > 0; gap /= 2)
for (int i = gap; i < n; i++)
int value = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > value)
arr[j + gap] = arr[j];
j -= gap;
arr[j + gap] = value;
//5. 归并排序：
public static void mergeSort(int[] arr)
int n = arr.length;
if (n < 2)
return;
int mid = n / 2;
int[] left = new int[mid];
int[] right = new int[n - mid];
for (int i = 0; i < mid; i++)
left[i] = arr[i];
for (int i = mid; i < n; i++)
right[i - mid] = arr[i];
mergeSort(left);
mergeSort(right);
merge(arr, left, right);
public static void merge(int[] arr, int[] left, int[] right)
int i = 0, j = 0, k = 0;
int leftLen = left.length;
int rightLen = right.length;
while (i < leftLen && j < rightLen)
if (left[i] <= right[j])
arr[k++] = left[i++];
else
arr[k++] = right[j++];
while (i < leftLen)
arr[k++] = left[i++];
while (j < rightLen)
arr[k++] = right[j++];
//6. 快速排序：
public static void quickSort(int[] arr, int low, int high)
if (low < high)
int pivot = partition(arr, low, high);
quickSort(arr, low, pivot - 1);
quickSort(arr, pivot + 1, high);
public static int partition(int[] arr, int low, int high)
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++)
if (arr[j] <= pivot)
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
//7. 堆排序：
public static void heapSort(int[] arr)
int n = arr.length;
for (int i = n / 2 - 1; i >= 0; i--)
heapify(arr, n, i);
for (int i = n - 1; i >= 0; i--)
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
public static void heapify(int[] arr, int n, int i)
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest])
largest = left;
if (right < n && arr[right] > arr[largest])
largest = right;
if (largest != i)
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
10. 请给出十大排序算法的Golang代码。
//1. 冒泡排序：
func BubbleSort(arr []int)
for i := 0; i < len(arr); i++
for j := 0; j < len(arr)-i-1; j++
if arr[j] > arr[j+1]
arr[j], arr[j+1] = arr[j+1], arr[j]
//2. 选择排序：
func SelectionSort(arr []int)
for i := 0; i < len(arr); i++
minIndex := i
for j := i + 1; j < len(arr); j++
if arr[j] < arr[minIndex]
minIndex = j
arr[i], arr[minIndex] = arr[minIndex], arr[i]
//3. 插入排序：
func InsertionSort(arr []int)
for i := 1; i < len(arr); i++
for j := i; j > 0; j--
if arr[j] < arr[j-1]
arr[j], arr[j-1] = arr[j-1], arr[j]
//4. 希尔排序：
func ShellSort(arr []int)
n := len(arr)
h := 1
for h < n/3
h = 3*h + 1
for h >= 1
for i := h; i < n; i++
for j := i; j >= h && arr[j] < arr[j-h]; j -= h
arr[j], arr[j-h] = arr[j-h], arr[j]
h /= 3
//5. 归并排序：
func MergeSort(arr []int)
if len(arr) <= 1
return
mid := len(arr) / 2
left := arr[:mid]
right := arr[mid:]
MergeSort(left)
MergeSort(right)
i := 0
j := 0
k := 0
for i < len(left) && j < len(right)
if left[i] < right[j]
arr[k] = left[i]
i++
else
arr[k] = right[j]
j++
k++
for i < len(left)
arr[k] = left[i]
i++
k++
for j < len(right)
arr[k] = right[j]
j++
k++
//6. 快速排序：
func QuickSort(arr []int)
if len(arr) <= 1
return
pivot := arr[0]
left := []int
right := []int
for i := 1; i < len(arr); i++
if arr[i] < pivot
left = append(left, arr[i])
else
right = append(right, arr[i])
QuickSort(left)
QuickSort(right)
arr = append(append(left, pivot), right...)
//7. 堆排序：
func HeapSort(arr []int)
n := len(arr)
for i := n/2 - 1; i >= 0; i--
heapify(arr, n, i)
for i := n - 1; i >= 0; i--
arr[0], arr[i] = arr[i], arr[0]
heapify(arr, i, 0)
func heapify(arr []int, n, i int)
largest := i
l := 2*i + 1
r := 2*i + 2
if l < n && arr[l] > arr[largest]
largest = l
if r < n && arr[r] > arr[largest]
largest = r
if largest != i
arr[i], arr[largest] = arr[largest], arr[i]
heapify(arr, n, largest)
//8. 计数排序：
func CountingSort(arr []int)
max := arr[0]
for i := 1; i < len(arr); i++
if arr[i] > max
max = arr[i]
count := make([]int, max+1)
for i := 0; i < len(arr); i++
count[arr[i]]++
k := 0
for i := 0; i <= max; i++
for j := 0; j < count[i]; j++
arr[k] = i
k++
//9. 桶排序：
func BucketSort(arr []int)
n := len(arr)
buckets := make([][]int, n)
for i := 0; i < n; i++
index := arr[i] / n
buckets[index] = append(buckets[index], arr[i])
k := 0
for i := 0; i < n; i++
bucketLen := len(buckets[i])
if bucketLen > 0
InsertionSort(buckets[i])
copy(arr[k:], buckets[i])
k += bucketLen
//10. 基数排序：
func RadixSort(arr []int)
max := arr[0]
for i := 1; i < len(arr); i++
if arr[i] > max
max = arr[i]
for exp := 1; max/exp > 0; exp *= 10
countSort(arr, exp)
func countSort(arr []int, exp int)
output := make([]int, len(arr))
count := make([]int, 10)
for i := 0; i < len(arr); i++
count[(arr[i]/exp)%!](MISSING)++
for i := 1; i < 10; i++
count[i] += count[i-1]
for i := len(arr) - 1; i >= 0; i--
output[count[(arr[i]/exp)%!](MISSING)-1] = arr[i]
count[(arr[i]/exp)%!](MISSING)--
copy(arr, output)
回答的篇幅够长吧，比CSDN的网页版强。但上面代码中的基数排序出现了(MISSING)错误代码，再来问一次：
请用Golang写出基数排序的代码
// 基数排序
func RadixSort(arr []int) []int
// 获取最大值
max := arr[0]
for _, v := range arr
if v > max
max = v
// 计算最大值的位数
maxDigit := 0
for max != 0
max /= 10
maxDigit++
// 创建桶
buckets := make([][]int, 10)
// 将数据放入桶中
mod := 10
dev := 1
for i := 0; i < maxDigit; i++
for _, v := range arr
bucketIndex := (v %!m(MISSING)od) / dev
buckets[bucketIndex] = append(buckets[bucketIndex], v)
// 将桶中的数据放回原数组
index := 0
for _, bucket := range buckets
for _, v := range bucket
arr[index] = v
index++
bucket = bucket[:0]
mod *= 10
dev *= 10
return arr
——end——
以上是关于又发现一个ChatGPT国内镜像站，无次数限制也无广告的主要内容，如果未能解决你的问题，请参考以下文章