Prime Number Checker in Go

Understanding Prime Numbers

A prime number is a number greater than 1 that has no divisors other than 1 and itself.

• ✔️ Prime examples: 2, 3, 5, 7, 11, 13...
• ❌ Non-prime examples: 4 (2×2), 6 (2×3), 9 (3×3)...

Step 1: Writing the Prime Checker Function

We will write a function isPrime(n int) bool that checks if a number is prime.

package main
    
    import "math"
    
    // isPrime checks if a number is prime
    func isPrime(n int) bool {
        if n < 2 {
            return false
        }
        for i := 2; i <= int(math.Sqrt(float64(n))); i++ {
            if n%i == 0 {
                return false
            }
        }
        return true
    }

Step 2: Generate a List of Prime Numbers

We now create a function generatePrimes(limit int) []int that finds all prime numbers up to a given limit.

// generatePrimes generates a list of prime numbers up to a given limit
    func generatePrimes(limit int) []int {
        var primes []int
        for i := 2; i <= limit; i++ {
            if isPrime(i) {
                primes = append(primes, i)
            }
        }
        return primes
    }

Step 3: Running the Prime Checker

Here is the complete Go program to check if a number is prime and generate prime numbers:

package main
    
    import (
        "fmt"
        "math"
    )
    
    // Check if a number is prime
    func isPrime(n int) bool {
        if n < 2 {
            return false
        }
        for i := 2; i <= int(math.Sqrt(float64(n))); i++ {
            if n%i == 0 {
                return false
            }
        }
        return true
    }
    
    // Generate a list of prime numbers
    func generatePrimes(limit int) []int {
        var primes []int
        for i := 2; i <= limit; i++ {
            if isPrime(i) {
                primes = append(primes, i)
            }
        }
        return primes
    }
    
    func main() {
        var num int
        fmt.Print("Enter a number to check if it's prime: ")
        fmt.Scan(&num)
    
        if isPrime(num) {
            fmt.Printf("%d is a prime number.\n", num)
        } else {
            fmt.Printf("%d is NOT a prime number.\n", num)
        }
    
        var limit int
        fmt.Print("Enter a limit to generate prime numbers: ")
        fmt.Scan(&limit)
        primes := generatePrimes(limit)
        fmt.Println("Prime numbers up to", limit, ":", primes)
    }

Expected Output

Example of user interaction with the program:

Enter a number to check if it's prime: 11
    11 is a prime number.
    Enter a limit to generate prime numbers: 20
    Prime numbers up to 20: [2 3 5 7 11 13 17 19]

Common Mistakes and How to Fix Them

• ❌ Using math.Sqrt() incorrectly

🔴 Problem: Trying to pass an int directly into math.Sqrt() causes an error.

✅ Solution: Convert int to float64 before using math.Sqrt():

for i := 2; i <= int(math.Sqrt(float64(n))); i++ { ... }

• ❌ Forgetting to initialize the slice primes

🔴 Problem: Using append(primes, i) without declaring primes causes an error.

✅ Solution: Always initialize it like this:

var primes []int

• ❌ Checking divisibility up to n instead of √n

🔴 Problem: Using a full loop from 2 to n instead of 2 to √n makes the program much slower.

✅ Solution: Optimize by looping up to math.Sqrt(n).

• ❌ Not handling negative numbers

🔴 Problem: Negative numbers should never be considered prime, but the function might allow them.

✅ Solution: Add a condition at the start of isPrime():

if n < 2 { return false }

• ❌ Using incorrect variable types

🔴 Problem: Using var primes int instead of []int for a slice.

✅ Solution: Make sure you're using the correct types for lists:

var primes []int

• ❌ Not resetting values in loops

🔴 Problem: If you store prime numbers globally, they may accumulate across runs.

✅ Solution: Make sure the prime list is reset for each call of generatePrimes().

FAQs

1 : Can this program handle very large numbers?

It works for reasonable values, but for very large numbers, consider using optimized prime algorithms like the Sieve of Eratosthenes.

2 : Why do we use math.Sqrt(n)?

To optimize performance. A number is composite if it has a factor ≤ √n.

3 : Why does 1 return false in this program?

By definition, 1 is not a prime number because it has only one divisor (itself). A prime number needs exactly two divisors: 1 and itself.

4 : How can I modify this program to check multiple numbers in one run?

You can wrap the fmt.Scan input inside a loop to allow multiple checks without restarting the program.

5 : How do I print only the first N prime numbers instead of up to a limit?

Modify generatePrimes to stop after finding N primes instead of checking up to a number limit.