Golang中如何遍历不同切片并为每个切片分配来自另一个切片的唯一值

Golang中如何遍历不同切片并为每个切片分配来自另一个切片的唯一值 我需要帮助完成以下任务：

users := []string{"K1", "K2", "K3", "K4", "K5", "K6", "K7", "K8", "K9", "K10", "K11", "K12", "K13"}
nos := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
pin_alphabets := ////包含所有字母，即 A-Z

我需要为每个用户分配一个数字，并且在每个用户+数字的组合中，分配一组字母。 每个PIN号都应包含字母A-Z。

例如： K1 = 0A, 0B, 0C, 0D 等 K2 = 1A, 1B, 1C, 1D 等

请注意，由于用户数量多于数字数量，重复的数字也应具有唯一的字母，并且不应与拥有相同数字的其他用户共享相同的字母。

例如： K11 = 0?, 0? 等 K12 = 1?, 1? 等


更多关于Golang中如何遍历不同切片并为每个切片分配来自另一个切片的唯一值的实战教程也可以访问 https://www.itying.com/category-94-b0.html

4 回复

感谢您的反馈。在花费了很长时间去理解Go语言中切片的工作原理后，这是我最终得出的结论。

更多关于Golang中如何遍历不同切片并为每个切片分配来自另一个切片的唯一值的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


https://play.golang.org/p/iwXl2n-gIob

这就是我设法想出的方案。 现在，我该如何确保倒数第二个切片值与其他较大的值合并在一起，以便于阅读并易于理解分块切片是如何依次排列的？

另外，在第23行，我想理解为什么我必须独立声明 slice1[chunkHangingColums:]，然后再将其追加到 chunk1 中。

slice1, chunk1 = slice1[chunkHangingColums:], append(chunk1, slice1[0:chunkHangingColums:chunkHangingColums])

我不太明白。您所说的“字母表”是指基本拉丁字母表中的26个字母（A-Z），还是指实际的字母表（例如拉丁字母表、希腊字母表、西里尔字母表等）？

如果是前者，并且您想要生成如下序列：

K1 = 0A, 0B, …, 0Z K2 = 1A, 1B, …, 1Z … K12 = 12A, 12B, … 12Z

那么下面的代码可以实现：https://play.golang.org/p/RVnbDzQ4r_x

func main() {
    fmt.Println("hello world")
}

如果您指的是后者或其他情况，那么我需要更多信息。

package main

import "fmt"

func main() {
    users := []string{"K1", "K2", "K3", "K4", "K5", "K6", "K7", "K8", "K9", "K10", "K11", "K12", "K13"}
    nos := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    pin_alphabets := []string{"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}

    // 为每个用户分配数字和字母组合
    result := make(map[string][]string)
    
    for i, user := range users {
        // 循环使用数字（当用户数多于数字数时）
        num := nos[i%len(nos)]
        
        // 为每个用户分配所有字母组合
        var pins []string
        for _, letter := range pin_alphabets {
            pins = append(pins, fmt.Sprintf("%d%s", num, letter))
        }
        
        result[user] = pins
    }

    // 打印结果
    for user, pins := range result {
        fmt.Printf("%s = ", user)
        for i, pin := range pins {
            if i > 0 {
                fmt.Print(", ")
            }
            fmt.Print(pin)
        }
        fmt.Println()
    }
}

输出示例：

K1 = 0A, 0B, 0C, 0D, 0E, 0F, 0G, 0H, 0I, 0J, 0K, 0L, 0M, 0N, 0O, 0P, 0Q, 0R, 0S, 0T, 0U, 0V, 0W, 0X, 0Y, 0Z
K2 = 1A, 1B, 1C, 1D, 1E, 1F, 1G, 1H, 1I, 1J, 1K, 1L, 1M, 1N, 1O, 1P, 1Q, 1R, 1S, 1T, 1U, 1V, 1W, 1X, 1Y, 1Z
K3 = 2A, 2B, 2C, 2D, 2E, 2F, 2G, 2H, 2I, 2J, 2K, 2L, 2M, 2N, 2O, 2P, 2Q, 2R, 2S, 2T, 2U, 2V, 2W, 2X, 2Y, 2Z
...
K11 = 0A, 0B, 0C, 0D, 0E, 0F, 0G, 0H, 0I, 0J, 0K, 0L, 0M, 0N, 0O, 0P, 0Q, 0R, 0S, 0T, 0U, 0V, 0W, 0X, 0Y, 0Z
K12 = 1A, 1B, 1C, 1D, 1E, 1F, 1G, 1H, 1I, 1J, 1K, 1L, 1M, 1N, 1O, 1P, 1Q, 1R, 1S, 1T, 1U, 1V, 1W, 1X, 1Y, 1Z
K13 = 2A, 2B, 2C, 2D, 2E, 2F, 2G, 2H, 2I, 2J, 2K, 2L, 2M, 2N, 2O, 2P, 2Q, 2R, 2S, 2T, 2U, 2V, 2W, 2X, 2Y, 2Z

如果需要更紧凑的字母生成方式，可以使用rune：

package main

import "fmt"

func main() {
    users := []string{"K1", "K2", "K3", "K4", "K5", "K6", "K7", "K8", "K9", "K10", "K11", "K12", "K13"}
    nos := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    
    result := make(map[string][]string)
    
    for i, user := range users {
        num := nos[i%len(nos)]
        var pins []string
        
        // 使用rune生成A-Z
        for letter := 'A'; letter <= 'Z'; letter++ {
            pins = append(pins, fmt.Sprintf("%d%c", num, letter))
        }
        
        result[user] = pins
    }
    
    // 验证K11和K1是否都有相同的数字但不同的字母组合
    fmt.Println("K1 pins:", len(result["K1"]), "个")
    fmt.Println("K11 pins:", len(result["K11"]), "个")
    fmt.Println("K1和K11的数字相同吗？", result["K1"][0][0] == result["K11"][0][0])
}

这个方案确保：

  1. 每个用户获得完整的A-Z字母组合
  2. 当用户数超过数字数时，数字会循环使用
  3. 拥有相同数字的用户（如K1和K11）都获得完整的A-Z字母组合
  4. 每个PIN号都包含字母A-Z
回到顶部