Question

How to generate an 8 digits random number in Go

Answer 1

package main

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

func main() {
	for i := 0; i < 10; i++ {
		// rand.IntN(n) returns a value in [0, n)
		// 10000000 + [0, 90000000) gives [10000000, 99999999]
		num := 10000000 + rand.IntN(90000000)
		fmt.Println(num)
	}
}


/*
run:

81767523
26778111
33804060
57738916
81129844
27210250
54238060
13044647
88232744
93841132

*/

 

70+ SQL courses for beginners and professionals

Answer 2

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
)

func generate8DigitNumber() (int64, error) {
	min := int64(10000000)
	rangeSize := int64(90000000) // [0, 89999999]

	// rand.Int generates a secure random number in [0, max)
	n, err := rand.Int(rand.Reader, big.NewInt(rangeSize))
	if err != nil {
		return 0, err
	}

	return min + n.Int64(), nil
}

func main() {
	for i := 0; i < 10; i++ {
		num, err := generate8DigitNumber()
		if err != nil {
			panic(err)
		}
		fmt.Println(num)
	}
}


/*
run:

22475237
85152583
53857678
98726598
66902620
70612087
19258619
64518714
84861079
56002732

*/

 

70+ SQL courses for beginners and professionals

Answer 3

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
)

func generate8DigitCode() (string, error) {
	// Generates a secure random big.Int in the range [0, 99999999]
	n, err := rand.Int(rand.Reader, big.NewInt(100000000))
	if err != nil {
		return "", err
	}

	// Fix: Use Sprintf (capital S) instead of sprintf
	return fmt.Sprintf("%08d", n.Int64()), nil
}

func main() {
	for i := 0; i < 10; i++ {
		code, err := generate8DigitCode()
		if err != nil {
			panic(err)
		}
		fmt.Println(code)
	}
}


/*
run:

36124963
34309939
91572739
64064857
94246777
70746152
83714055
91125339
69361452
81401760

*/

 

70+ SQL courses for beginners and professionals

Answer 4

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
)

// Const definitions with digit separators for readability.
const (
	min8DigitInt      int64 = 10_000_000
	max8DigitRange    int64 = 90_000_000 // Covers range [0, 89,999,999]
	codeUpperExclusive int64 = 100_000_000 // Covers range [0, 99,999,999]
)

// Generate8DigitNumber returns a cryptographically secure random 8-digit integer
// between 10,000,000 and 99,999,999 (inclusive). Guaranteed to start with digits 1-9.
func Generate8DigitNumber() (int64, error) {
	// crypto/rand.Int generates a random big.Int in the uniform range [0, max).
	// We pass max8DigitRange (90,000,000) to get a random offset in [0, 89,999,999].
	n, err := rand.Int(rand.Reader, big.NewInt(max8DigitRange))
	if err != nil {
		return 0, fmt.Errorf("failed to generate secure random int: %w", err)
	}

	// Add min8DigitInt (10,000,000) to shift the range to [10,000,000, 99,999,999]
	return min8DigitInt + n.Int64(), nil
}

// Generate8DigitCode returns a cryptographically secure 8-character numeric string code
// between "00000000" and "99999999". Preserves leading zeros using fmt.Sprintf,
// making it suitable for OTPs, PINs, or verification tokens.
func Generate8DigitCode() (string, error) {
	// Generate an integer in the range [0, 99,999,999]
	n, err := rand.Int(rand.Reader, big.NewInt(codeUpperExclusive))
	if err != nil {
		return "", fmt.Errorf("failed to generate secure random code: %w", err)
	}

	// Format as an 8-digit string with leading zeros (%08d)
	return fmt.Sprintf("%08d", n.Int64()), nil
}

func main() {
	// 1. Generate a mathematical 8-digit integer [10000000 to 99999999]
	num, err := Generate8DigitNumber()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	fmt.Printf("Generated 8-digit integer: %d\n", num)

	// 2. Generate an 8-character string code [00000000 to 99999999] preserving leading zeros
	code, err := Generate8DigitCode()
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}
	fmt.Printf("Generated 8-digit string code: %s\n", code)
}


/*
run:

Generated 8-digit integer: 11766012
Generated 8-digit string code: 03328841

*/

 

70+ SQL courses for beginners and professionals