Matrix 在Golang中随机生成一个矩阵

我目前正在写一个程序，我想随机生成一个矩阵

目前，我正在对其中的值进行如下预设置：

    m1 := [3][3]int{
    [3]int{1, 1, 1},
    [3]int{4, 1, 7},
    [3]int{1, 65, 1},
}

但是，我希望输入的值在1-100范围内随机生成

import "math/rand"

我正在导入上述库并尝试使用它

我试图让这项工作，但似乎无法取得任何进展

    m1 := [3][3]int{
    [3]int{rand.Intn, 1, 1},
    [3]int{4, 1, 7},
    [3]int{1, 65, 1},
}

我试图用上面的解决方案来完成它，以使第一个数字随机，但我得到以下错误

cannot use rand.Intn (type func(int) int) as type int in array or slice literal

---

非常感谢您的帮助。

直接的答案是，

rand.Intn（）

生成一个介于0和

n

之间的随机整数，其中

n

是此方法的一个参数。您遇到的错误是编译器抱怨您试图使用需要两个

int

s并返回一个的函数初始化

int

值-您试图将函数分配给

int

。因此，正确的调用应该是类似于

rand.Intn（100）

，它将给您一个介于0-100之间的随机数

但是，为什么要这样做呢？为什么不使用随机数动态初始化数组，如下所示：

m1 := [3][3]int{}
for i:=0; i<3; i++ {
    for j:=0; j<3; j++ {
        m1[i][j] = rand.Int()
    }
}

m1:=[3][3]int{}
对于i:=0；i直接的答案是，
rand.Intn（）
生成一个介于0和
n
之间的随机整数，其中
n
是此方法的一个参数。您遇到的错误是编译器抱怨您试图使用需要两个
int
s并返回一个的函数初始化
int
值-您试图将函数分配给
int
。因此，正确的调用应该是类似于
rand.Intn（100）
，它将给您一个介于0-100之间的随机数

但是，为什么要这样做呢？为什么不使用随机数动态初始化数组，如下所示：

m1 := [3][3]int{}
for i:=0; i<3; i++ {
    for j:=0; j<3; j++ {
        m1[i][j] = rand.Int()
    }
}

m1:=[3][3]int{}
对于i:=0；我以上回答了您的问题，这是一个扩展

虽然
rand.Int（10）
总是给你1，因为它不是种子，
您可以添加此函数以在每次运行程序时获取随机值

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func init() {
    rand.Seed(time.Now().UnixNano())
//we are seeding the rand variable with present time 
//so that we would get different output each time
}

func main() {
    randMatrix := make([][]int, 3) 
// we have created a slice with length 3 
//which can hold type []int, these can be of different length
    for i := 0; i < 3; i++ {
        randMatrix[i] = make([]int, 3) 
// we are creating a slice which can hold type int
    }
    generate(randMatrix)
    fmt.Println(randMatrix)
}

func generate(randMatrix [][]int) {
    for i, innerArray := range randMatrix {
        for j := range innerArray {
            randMatrix[i][j] = rand.Intn(100)
//looping over each element of array and assigning it a random variable
        }
    }
}

主程序包
进口(
“fmt”
“数学/兰德”
“时间”
)
func init（）{
rand.Seed（time.Now（）.UnixNano（））
//我们正在使用当前时间播种rand变量
//这样我们每次都能得到不同的输出
}
func main（）{
随机矩阵：=make（[]int，3）
//我们已经创建了一个长度为3的切片
//它可以保存类型[]int，这些可以具有不同的长度
对于i:=0；i<3；i++{
随机矩阵[i]=make（[]整数，3）
//我们正在创建一个可以保存int类型的切片
}
生成（随机矩阵）
fmt.Println（随机矩阵）
}
func生成（随机矩阵[][]int）{
对于i，innerArray:=范围矩阵{
对于j:=范围数组{
随机矩阵[i][j]=rand.Intn（100）
//在数组的每个元素上循环并为其分配一个随机变量
}
}
}

这段代码生成100以下的随机矩阵，同时您也可以使用标志用于任何类型的未来用途，并泛化值

import  "flag"

var outerDim, innerDim, limit *int

func main() {
    outerDim = flag.Int("outerDim", 3, "Outer dimension of the matrix")
    innerDim = flag.Int("innerDim", 3, "inner dimenstion of the matrix")
    limit = flag.Int("limit", 100, "matrix values are limited specified value")
    flag.Parse()
    randMatrix := make([][]int, *outerDim)
    for i := 0; i < *outerDim; i++ {
        randMatrix[i] = make([]int, *innerDim)
    }
    generate(randMatrix)
    printMatrix(randMatrix)
}

func generate(randMatrix [][]int) {
    for i, innerArray := range randMatrix {
        for j := range innerArray {
            randMatrix[i][j] = rand.Intn(*limit)
        }
    }
}

func printMatrix(randMatrix [][]int) {
//looping over 2D slice and extracting 1D slice to val
    for _, val := range randMatrix {
        fmt.Println(val)// printing each slice
    }
}

导入“标志”
变量outerDim、innerDim、limit*int
func main（）{
outerDim=flag.Int（“outerDim”，3，“矩阵的外部维度”）
innerDim=flag.Int（“innerDim”，3，“矩阵的内部尺寸”）
limit=flag.Int（“limit”，100，“矩阵值是有限的指定值”）
flag.Parse（）
randMatrix:=make（[]int，*outerDim）
对于i:=0；i<*outerDim；i++{
随机矩阵[i]=make（[]int，*innerDim）
}
生成（随机矩阵）
printMatrix（randMatrix）
}
func生成（随机矩阵[][]int）{
对于i，innerArray:=范围矩阵{
对于j:=范围数组{
随机矩阵[i][j]=随机整数（*限制）
}
}
}
func printMatrix（随机矩阵[][]int）{
//在2D切片上循环并将1D切片提取到val
对于u，val:=范围矩阵{
fmt.Println（val）//打印每个切片
}
}

我们可以修改上面的printMatrix函数，方法是循环每个整数，然后使用
fmt.Printf（）
对其进行良好的格式化，但如果我们不知道限制的长度，这会使事情变得复杂…
您的问题的答案已在上面回答，这是一个扩展

虽然
rand.Int（10）
总是给你1，因为它不是种子，
您可以添加此函数以在每次运行程序时获取随机值

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func init() {
    rand.Seed(time.Now().UnixNano())
//we are seeding the rand variable with present time 
//so that we would get different output each time
}

func main() {
    randMatrix := make([][]int, 3) 
// we have created a slice with length 3 
//which can hold type []int, these can be of different length
    for i := 0; i < 3; i++ {
        randMatrix[i] = make([]int, 3) 
// we are creating a slice which can hold type int
    }
    generate(randMatrix)
    fmt.Println(randMatrix)
}

func generate(randMatrix [][]int) {
    for i, innerArray := range randMatrix {
        for j := range innerArray {
            randMatrix[i][j] = rand.Intn(100)
//looping over each element of array and assigning it a random variable
        }
    }
}

主程序包
进口(
“fmt”
“数学/兰德”
“时间”
)
func init（）{
rand.Seed（time.Now（）.UnixNano（））
//我们正在使用当前时间播种rand变量
//这样我们每次都能得到不同的输出
}
func main（）{
随机矩阵：=make（[]int，3）
//我们已经创建了一个长度为3的切片
//它可以保存类型[]int，这些可以具有不同的长度
对于i:=0；i<3；i++{
随机矩阵[i]=make（[]整数，3）
//我们正在创建一个可以保存int类型的切片
}
生成（随机矩阵）
fmt.Println（随机矩阵）
}
func生成（随机矩阵[][]int）{
对于i，innerArray:=范围矩阵{
对于j:=范围数组{
随机矩阵[i][j]=rand.Intn（100）
//在数组的每个元素上循环并为其分配一个随机变量
}
}
}

此代码生成100以下的随机矩阵，同时您也可以使用标志进行任何将来的使用并推广这些值

import  "flag"

var outerDim, innerDim, limit *int

func main() {
    outerDim = flag.Int("outerDim", 3, "Outer dimension of the matrix")
    innerDim = flag.Int("innerDim", 3, "inner dimenstion of the matrix")
    limit = flag.Int("limit", 100, "matrix values are limited specified value")
    flag.Parse()
    randMatrix := make([][]int, *outerDim)
    for i := 0; i < *outerDim; i++ {
        randMatrix[i] = make([]int, *innerDim)
    }
    generate(randMatrix)
    printMatrix(randMatrix)
}

func generate(randMatrix [][]int) {
    for i, innerArray := range randMatrix {
        for j := range innerArray {
            randMatrix[i][j] = rand.Intn(*limit)
        }
    }
}

func printMatrix(randMatrix [][]int) {
//looping over 2D slice and extracting 1D slice to val
    for _, val := range randMatrix {
        fmt.Println(val)// printing each slice
    }
}

导入“标志”
变量outerDim、innerDim、limit*int
func main（）{
outerDim=flag.Int（“outerDim”，3，“矩阵的外部维度”）
innerDim=flag.Int（“innerDim”，3，“矩阵的内部尺寸”）
limit=flag.Int（“limit”，100，“矩阵值是有限的指定值”）
flag.Parse（）
randMatrix:=make（[]int，*outerDim）
对于i:=0；i<*outerDim；i++{
随机矩阵[i]=make（[]int，*innerDim）
}
生成（随机矩阵）
printMatrix（randMatrix）
}
func生成（随机矩阵[][]int）{
对于i，innerArray：