欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

ChatGPT體驗(yàn)輔助寫代碼功能實(shí)測(cè)(附編程測(cè)試)

 更新時(shí)間:2023年04月20日 16:54:08   作者:Hann?Yang  
ChatGPT最近霸屏了,咱們也來(lái)玩玩,下面這篇文章主要給大家介紹使用ChatGPT輔助寫代碼的體驗(yàn),需要的朋友可以參考下

ChatGPT

美國(guó)OpenAI研發(fā)的聊天機(jī)器人程序,于2022年11月30日發(fā)布。ChatGPT是人工智能技術(shù)驅(qū)動(dòng)的自然語(yǔ)言處理工具,它能夠通過(guò)學(xué)習(xí)和理解人類的語(yǔ)言來(lái)進(jìn)行對(duì)話,還能根據(jù)聊天的上下文進(jìn)行互動(dòng),真正像人類一樣來(lái)聊天交流,甚至能完成撰寫郵件、視頻腳本、文案、翻譯、代碼等任務(wù)。

chat=閑聊,聊天的意思

GPT=Generative Pretrained Transformer(生成預(yù)訓(xùn)練變換器)的縮寫

chatGPT=聊天訓(xùn)練

組合解釋=智能的對(duì)話聊天工具(由美國(guó)OpenAI研發(fā),最近微軟投了100億刀)

最近發(fā)現(xiàn)一個(gè)網(wǎng)址很干凈,給大家實(shí)測(cè)一波輔助寫代碼功能。

編程測(cè)試

找一些編程題目,來(lái)測(cè)試一下chatGPT的編程能力。

1. 我想用golang實(shí)現(xiàn)二叉樹前序,請(qǐng)你幫我寫一下代碼。

// 定義二叉樹節(jié)點(diǎn)
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)
}

2. 用golang實(shí)現(xiàn)二叉樹中序遍歷,寫一下代碼。

// 定義二叉樹節(jié)點(diǎn)
type TreeNode struct {
    Val int
    Left *TreeNode
    Right *TreeNode
}
 
// 中序遍歷
func InOrderTraversal(root *TreeNode) {
    if root == nil {
        return
    }
    InOrderTraversal(root.Left)
    fmt.Println(root.Val)
    InOrderTraversal(root.Right)
}

3. 給定一個(gè)字符串?dāng)?shù)組,打印數(shù)組中的所有詞。請(qǐng)用C++代碼實(shí)現(xiàn)

#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. 零尾數(shù)個(gè)數(shù)

如下的10行數(shù)據(jù),每行有10個(gè)整數(shù),請(qǐng)你求出它們的乘積的末尾有多少個(gè)零?請(qǐng)用C代碼實(shí)現(xiàn)

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;
}

粗看原理好像是對(duì)的,先全部相乘再循環(huán)計(jì)數(shù)??上?shí)現(xiàn)不了,所有整數(shù)相乘肯定會(huì)溢出了。

5. 四數(shù)之和

給定一個(gè)包含 n 個(gè)整數(shù)的數(shù)組 nums 和一個(gè)目標(biāo)值 target,判斷 nums 中是否存在四個(gè)元素 a,b,c 和 d ,使得 a + b + c + d 的值與 target 相等?找出所有滿足條件且不重復(fù)的四元組,用python代碼實(shí)現(xiàn)。

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 res

6. 字符串編碼

問(wèn)題描述

小明發(fā)明了一種給由全大寫字母組成的字符串編碼的方法。

對(duì)于每一個(gè)大寫字母,小明將它轉(zhuǎn)換成它在 26 個(gè)英文字母中序號(hào),即 A → 1, B → 2, … Z →26。

這樣一個(gè)字符串就能被轉(zhuǎn)化成一個(gè)數(shù)字序列:比如 ABCXYZ → 123242526。

現(xiàn)在給定一個(gè)轉(zhuǎn)換后的數(shù)字序列,小明想還原出原本的字符串。

當(dāng)然這樣的還原有可能存在多個(gè)符合條件的字符串。

小明希望找出其中字典序最大的字符串。

請(qǐng)用C++代碼來(lái)實(shí)現(xiàn):

輸入格式
一個(gè)數(shù)字序列。

輸出格式
一個(gè)只包含大寫字母的字符串,代表答案

樣例輸入
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;
}

測(cè)試錯(cuò)誤,輸入123242526 輸出 FEDCBBBBA。你能找出錯(cuò)在哪里嗎?

寫一段正確的參考代碼,如下:

#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. 請(qǐng)給出七大排序算法的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. 請(qǐng)給出七大排序算法的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. 請(qǐng)給出七大排序算法的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. 請(qǐng)給出十大排序算法的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. 計(jì)數(shù)排序:
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. 基數(shù)排序:
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)
}

回答的篇幅夠長(zhǎng)吧,比CSDN的網(wǎng)頁(yè)版強(qiáng)。但上面代碼中的基數(shù)排序出現(xiàn)了(MISSING)錯(cuò)誤代碼,再來(lái)問(wèn)一次:

請(qǐng)用Golang寫出基數(shù)排序的代碼

// 基數(shù)排序
func RadixSort(arr []int) []int {
	// 獲取最大值
	max := arr[0]
	for _, v := range arr {
		if v > max {
			max = v
		}
	}
	// 計(jì)算最大值的位數(shù)
	maxDigit := 0
	for max != 0 {
		max /= 10
		maxDigit++
	}
	// 創(chuàng)建桶
	buckets := make([][]int, 10)
	// 將數(shù)據(jù)放入桶中
	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)
		}
		// 將桶中的數(shù)據(jù)放回原數(shù)組
		index := 0
		for _, bucket := range buckets {
			for _, v := range bucket {
				arr[index] = v
				index++
			}
			bucket = bucket[:0]
		}
		mod *= 10
		dev *= 10
	}
	return arr
}

41aec71572e04959a3fa066340f63961.gif

總結(jié)

到此這篇關(guān)于推薦一個(gè)ChatGPT體驗(yàn)輔助寫代碼的文章就介紹到這了,更多相關(guān)ChatGPT體驗(yàn)推薦內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!

相關(guān)文章

最新評(píng)論