Randomly generating a matrix in Golang

I'm currently writing a program and I want to randomly generate a matrix.

Currently I'm pre-setting the values in it as follows:

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

However I want the values inputted to be randomly generated in a range from 1-100.

import "math/rand"

I am importing the above library and trying to utilise it.

I have attempted to get this working however can't seem to make any headway.

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

I have attempted to complete it with the above solution to make the first number random however I get the following error.

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

Any help greatly appreciated.

The direct answer is the fact that rand.Intn() generates a random integer between 0 and n, where n is a parameter to this method. The error that you are getting is the compiler complaining that you are trying to initialize an int value with a function that requires two ints and returns one - you are trying to assign a function to an int. So the correct call would be something like rand.Intn(100), which will give you a random number between 0 - 100.

However, why do it this way? Why not dynamically initialize your array with random numbers as:

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

Answer to your question is answered above, this is an extension,

While rand.Int(10) always gives you 1, as it isn't seeded,
you can add this function to get random values each time you run your program,

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

This code generates random Matrix, below 100, while you can also use flags for any kind of future use and generalize the values,

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

We could modify the printMatrix function above, by looping over each integer and then formatting it well by using fmt.Printf(), but that would complicate things when we don't known the length of the limit...