golang常见算法题

1、 翻转一个字符串

//字符串是不可变的，所以你需要将字符串转换成可以修改的类型(比如切片)
// rune切片,可以正确处理 Unicode 字符
func ReverseString(s string) string {
   
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
   
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

2、 判断两个给定的字符串排序后是否一致

3、 判断字符串中字符是否全都不同

//1.将字符串设置到一个map中,转化为检测map中某个val是否存在
func IsUniqueChars(str string) bool {
   
	if len(str) > 128 {
    // 假设字符集是 ASCII
		return false
	}
	charSet := make(map[rune]bool)
	for _, char := range str {
   
		if _, found := charSet[char]; found {
   
			// 如果字符已经在集合中，返回 false
			return false
		}
		charSet[char] = true
	}
	return true
}
//2.判断字符出现的第一次和最后一次位置是否相同
//strings.IndexRune 用于查找单个 Unicode 字符
//而 strings.Index 用于查找一个子字符串
func IsUniqueChars(str string) bool {
   
    for _, char := range str {
   
        if strings.IndexRune(str, char) != strings.LastIndexRune(str, char) {
   
            return false
        }
    }
    return true
}

4、交替打印数字和字母

package main

import (
	"fmt"
	"sync"
)

func main() {
   
	var wg sync.WaitGroup
	letterCh := make(chan struct{
   })
	numberCh := make(chan struct{
   })

	wg.Add(1)
	go printLetters(letterCh, numberCh, &wg)
	wg.Add(1)
	go printNumbers(letterCh, numberCh, &wg)

	letterCh <- struct{
   }{
   } // 启动字母打印

	wg.Wait()
}

func printLetters(letterCh, numberCh chan struct{
   }, wg *sync.WaitGroup) {
   
	defer wg.Done()
	letters := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

	for i := 0; i < len(letters); i++ {
   
		<-letterCh
		fmt.Printf("%c ", letters[i])
		numberCh <- struct{
   }{
   }
	}
}

func printNumbers(letterCh, numberCh chan struct{
   }, wg *sync.WaitGroup) {
   
	defer wg.Done()
	numbers := "123456789"

	for i := 0; i < len(numbers); i++ {
   
		<-numberCh
		fmt.Printf("%c ", numbers[i])
		letterCh <- struct{
   }{
   }
	}
}

5、 字符串对位交换

6、 返回一个数组所有可能排列

package main

import (
	"fmt"
)

func permute(nums []int) [][]int {
   
	result := [][]int{
   }
	generatePermutations(nums, 0, &result)
	return result
}

func generatePermutations(nums []int, index int, result *[][]int) {
   
	if index == len(nums)-1 {
   
		// 将当前排列加入结果集
		temp := make([]int, len(nums))
		copy(temp, nums)
		*result = append(*result, temp)
		return
	}

	for i := index; i < len(nums); i++ {
   
		// 交换元素位置
		nums[index], nums[i] = nums[i], nums[index]

		// 递归生成下一个位置的排列
		generatePermutations(nums, index+1, result)

		// 恢复原始数组，以便下一次交换
		nums[index], nums[i] = nums[i], nums[index]
	}
}

func main() {
   
	nums := []int{
   1, 2, 3}
	result := permute(nums)

	// 打印所有排列
	for _, perm := range result {
   
		fmt.Println(perm)
	}
}

7、有两个切片 []int{1,3,5,7}. []int{2,4,6,8,9} 将两个切片按照递增合并为一个新的切片[]int{1,2,3,4,5,6,7,8,9}

// sort.Ints 升序排列
func main() {
   
	slice1 := []int{
   1, 3, 5, 7}
	slice2 := []int{
   2, 4, 6, 8, 9}

	// 将两个切片合并
	mergedSlice := append(slice1, slice2...)

	// 对合并后的切片进行排序
	sort.Ints(mergedSlice)

	fmt.Println(mergedSlice)
}

语法题