📌 Title: Working with Random Numbers, Filtering, Sorting, and Searching in Go

📝 Problem Statement :

In this exercise, you will write a Go program that :

• 1️⃣ Generates a list of random numbers.
• 2️⃣ Filters the even numbers.
• 3️⃣ Sorts the numbers in ascending order.
• 4️⃣ Searches for a specific number entered by the user.

Your program should also handle errors properly and provide clear messages to the user.

🎯 Learning Objectives :

By completing this task, you will learn how to :

• ✅ Generate random numbers in Go.
• ✅ Work with slices (dynamic arrays).
• ✅ Filter elements in a slice based on conditions.
• ✅ Sort a slice using built-in functions.
• ✅ Search for an element efficiently using binary search.

🔍 Understanding the Problem :

1️⃣ Generating Random Numbers :

To generate random numbers in Go, we use themath/rand/v2package.

• 💡Think about it :
  • 1- How do we generate a random integer in a given range (e.g., 1 to 100)?
  • 2- How do we store multiple random numbers?
• 👉 Your task : Create a slice (dynamic array) that stores n random numbers between 1 and 100.

2️⃣ Filtering Even Numbers :

Once we have a list of numbers, we need to extract only the even numbers.

• 💡Think about it :
  • 1- How can you check if a number is even?
  • 2- How do you create a new slice containing only the even numbers?
• 👉 Your task : Write a function that takes a slice of numbers and returns a new slice containing only even numbers .

3️⃣ Sorting the Numbers :

Sorting is a common task in programming. Fortunately, Go provides a built-in function for this.

• 💡Think about it :
  • 1- What is the easiest way to sort a slice in ascending order?
  • 2- Why is sorting useful before searching?
• 👉 Your task : Use a built-in Go function to sort the list of numbers.

4️⃣ Searching for a Number :

After sorting, we need to check if a specific number (provided by the user) exists in the list. The most efficient way to do this is binary search.

• 💡Think about it :
  • 1- What is binary search, and why does it require a sorted list?
  • 2- How can we use Go’s built-in function to perform binary search?
• 👉 Your task : Write a function that searches for a number efficiently using binary search.

✍️ Functions to Implement :

1️⃣ GenerateRandomSlice(n int) []int :

• 📌 Hint :
  • 1- This function should return a slice containing n random numbers between 1 and 100.
  • 2- Use math/rand/v2 to generate random numbers.

2️⃣ PrintSlice(label string, slice []int) :

• 📌 Hint :
  • 1- This function should display the slice elements in a clear format.
  • 2- Print a message if the slice is empty.

3️⃣ FilterEvenNumbers(slice []int) []int :

• 📌 Hint :
  • 1- This function should return a new slice containing only even numbers.
  • 2- Use a loop and check if num % 2 == 0.

4️⃣ SortSlice(slice []int) :

• 📌 Hint :
  • 1- This function should sort the slice in ascending order.
  • 2- Use the built-in function slices.Sort().

5️⃣ SearchNumber(slice []int, target int) bool :

• 📌 Hint :
  • 1- This function should search for a number in a sorted slice.
  • 2- Use binary search (slices.BinarySearch()).

Create the main() function

Write the main() function and integrate all the previously implemented functions.

Solution :

package main

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

// GenerateRandomSlice creates a slice of 'n' random integers between 1 and 100.
func GenerateRandomSlice(n int) []int {
	if n <= 0 {
		return nil
	}

	seed1 := uint64(time.Now().UnixNano())
	seed2 := uint64(seed1 >> 32) // Generate a second seed value
	rng := rand.NewPCG(seed1, seed2)

	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = int(rng.Uint64()%100 + 1) 
	}

	return slice
}

// PrintSlice displays the contents of an integer slice in a readable format.
func PrintSlice(label string, slice []int) {
	fmt.Print(label, ": ")
	if len(slice) == 0 {
		fmt.Println("Empty slice.")
		return
	}
	for _, num := range slice {
		fmt.Printf("%d ", num)
	}
	fmt.Println()
}

// FilterEvenNumbers returns a new slice containing only even numbers.
func FilterEvenNumbers(slice []int) []int {
	var evenNumbers []int
	for _, num := range slice {
		if num%2 == 0 {
			evenNumbers = append(evenNumbers, num)
		}
	}
	return evenNumbers
}

// SortSlice sorts the given slice in ascending order.
func SortSlice(slice []int) {
	slices.Sort(slice) // Sort in place
}

// SearchNumber checks if a target number exists in a sorted slice using binary search.
func SearchNumber(slice []int, target int) bool {
	_, found := slices.BinarySearch(slice, target)
	return found
}

// Main function to test everything
func main() {
	var n int

	// Ask for the size of the array
	fmt.Print("Enter the size of the array: ")
	_, err := fmt.Scan(&n)
	if err != nil || n <= 0 {
		fmt.Println("Invalid input. Please enter a positive integer.")
		return
	}

	// Generate and display the random slice
	randomNumbers := GenerateRandomSlice(n)
	PrintSlice("Generated slice", randomNumbers)

	// Filter even numbers and display them
	evenNumbers := FilterEvenNumbers(randomNumbers)
	PrintSlice("Even numbers", evenNumbers)

	// Sort and display the slice
	SortSlice(randomNumbers)
	PrintSlice("Sorted slice", randomNumbers)

	// Ask for a number to search
	var target int
	fmt.Print("Enter a number to search: ")
	_, err = fmt.Scan(&target)
	if err != nil {
		fmt.Println("Invalid input. Please enter an integer.")
		return
	}

	// Search the number and display the result
	if SearchNumber(randomNumbers, target) {
		fmt.Println(target, "is in the sorted slice.")
	} else {
		fmt.Println(target, "is not in the sorted slice.")
	}
}