Golang如何在运行时创建动态大小的数组

Golang如何在运行时创建动态大小的数组 我正在将这段 Crystal 代码翻译成 Go

def gen_pg_parameters(prime)
  # Create prime generator parameters for given Pn
  puts "using Prime Generator parameters for P#{prime}"
  primes = [2, 3, 5, 7, 11, 13, 17, 19, 23]
  modpg, res_0 = 1, 0              
  primes.each { |prm| res_0 = prm; break if prm > prime; modpg *= prm }

  restwins = [] of Int32          
  inverses = Array.new(modpg + 2, 0)  
  pc, inc, res = 5, 2, 0            
  while pc < modpg // 2        
    if gcd(pc, modpg) == 1   
      pc_mc = modpg - pc        
      inv_r = modinv(pc, modpg)    
      inverses[pc] = inv_r            
      inverses[inv_r] = pc           
      inv_r = modinv(pc_mc, modpg)  
      inverses[pc_mc] = inv_r    
      inverses[inv_r] = pc_mc   
      if res + 2 == pc; restwins << pc; restwins << (pc_mc + 2) end 
      res = pc
    end
    pc += inc; inc ^= 0b110
  end
  restwins.sort!;          restwins << (modpg + 1)  
  inverses[modpg + 1] = 1; inverses[modpg - 1] = modpg - 1
  {modpg, res_0, restwins.size, restwins, inverses}
end

以下是 Go 语言的翻译版本。

func gen_pg_parameters(prime int) (int, int, int, []int, []int) {
  // Create prime generator parameters for given Pn
  fmt.Println("using Prime Generator parameters for P",prime)
  primes := []int{2, 3, 5, 7, 11, 13, 17, 19, 23}
  modpg, res_0 := 1, 0          
  for _, prm := range primes { res_0 = prm; if prm > prime { break }; modpg *= prm }
  
  restwins := []int{}            
  inverses := [modpg + 2]int{}         
  pc, inc, res := 5, 2, 0       
  for pc < modpg / 2 {           
    if gcd(pc, modpg) == 1 {          
      var pc_mc = modpg - pc     
      var inv_r = modinv(pc, modpg)  
      inverses[pc] = inv_r        
      inverses[inv_r] = pc           
      inv_r = modinv(pc_mc, modpg)    
      inverses[pc_mc] = inv_r        
      inverses[inv_r] = pc_mc   
      if res + 2 == pc { restwins = append(restwins, pc, pc_mc + 2) }
      res = pc
    }
    pc += inc; inc ^= 0b110
  }
  sort.Ints(restwins); restwins = append(restwins, modpg + 1)
  inverses[modpg + 1] = 1; inverses[modpg - 1] = modpg - 1 
  pairscnt := len(restwins)
  return modpg, res_0, pairscnt, restwins, inverses
}

Go 语言无法在运行时使用 [modpg + 2]int 这样的表达式来创建 inverses 数组。 那么在 Go 中应该如何实现呢？是否必须使用哈希表或关联数组？


更多关于Golang如何在运行时创建动态大小的数组的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

谢谢，效果非常好。 🙂

我最终做了： inverses := make([]int, modpg + 2)

更多关于Golang如何在运行时创建动态大小的数组的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


无法创建动态大小的数组。可以使用无固定大小的切片作为替代。

可以使用 make([]int, size, capacity) 来预先分配切片。

在Go中，运行时创建动态大小的数组需要使用切片(slice)。以下是修正后的代码：

func gen_pg_parameters(prime int) (int, int, int, []int, []int) {
    // Create prime generator parameters for given Pn
    fmt.Println("using Prime Generator parameters for P", prime)
    primes := []int{2, 3, 5, 7, 11, 13, 17, 19, 23}
    modpg, res_0 := 1, 0
    for _, prm := range primes {
        res_0 = prm
        if prm > prime {
            break
        }
        modpg *= prm
    }

    restwins := []int{}
    inverses := make([]int, modpg+2) // 使用make创建动态大小的切片
    pc, inc, res := 5, 2, 0
    for pc < modpg/2 {
        if gcd(pc, modpg) == 1 {
            pc_mc := modpg - pc
            inv_r := modinv(pc, modpg)
            inverses[pc] = inv_r
            inverses[inv_r] = pc
            inv_r = modinv(pc_mc, modpg)
            inverses[pc_mc] = inv_r
            inverses[inv_r] = pc_mc
            if res+2 == pc {
                restwins = append(restwins, pc, pc_mc+2)
            }
            res = pc
        }
        pc += inc
        inc ^= 0b110
    }
    sort.Ints(restwins)
    restwins = append(restwins, modpg+1)
    inverses[modpg+1] = 1
    inverses[modpg-1] = modpg - 1
    pairscnt := len(restwins)
    return modpg, res_0, pairscnt, restwins, inverses
}

关键修改是使用 make([]int, modpg+2) 替代 [modpg+2]int{}。make 函数在运行时动态分配指定长度的切片，切片底层是数组，可以像数组一样通过索引访问：

// 创建长度为10的int切片
slice := make([]int, 10)
slice[0] = 1
slice[9] = 10

// 创建长度和容量都为10的切片
slice2 := make([]int, 10, 10)

// 如果需要后续追加元素，可以指定更大的容量
slice3 := make([]int, 10, 20) // 长度10，容量20
slice3 = append(slice3, 100)  // 可以追加元素

切片提供了数组的所有功能，同时支持动态调整大小。在您的代码中，由于 modpg 在运行时确定，使用切片是正确的选择。

回到顶部