2023's Ultimate Guide to Golang Interview Questions - IQCode

Overview of Golang

Go, commonly known as Golang, is a powerful open-source programming language developed at Google in 2012 by Robert Griesemer, Rob Pike, and Ken Thompson. It was designed to address the shortcomings of contemporary programming languages.

Go is a high-level programming language that prioritizes simple and efficient code compilation without compromising on speed. It is rapidly gaining popularity in the software development industry due to its fast development, runtime efficiency, garbage collection strategies, concurrency, and reduced bugs. Notable companies that have adopted Golang include Apple, Google, and Uber.

Here are some common interview questions for freshers interested in Golang:

1. What is Golang?

Why Learn Go Programming Language? Advantages of Go Over Other Languages

Go, also known as Golang, is a relatively new programming language that has gained popularity in recent years. Learning Go has several advantages over other languages, including:

1. Simplicity: Go is a simple language, which means it has a smaller set of features that are easy to understand and use. This makes it easier to write and read code, reducing errors and increasing productivity.

2. Concurrency and Parallelism: Go has built-in support for concurrency and parallelism, making it easy to write programs that can efficiently use multiple CPU cores. This is especially useful for high-performance applications, such as web servers.

3. Performance: Go is designed to be fast, with a small memory footprint and efficient garbage collection. This makes it ideal for building high-performance applications, such as network servers, that need to handle large amounts of data quickly.

4. Safety and Security: Go has built-in support for error handling and memory safety, making it less likely to crash or be vulnerable to security exploits.

5. Open Source Community: Go is an open-source language with a large and active community. This means there are a lot of resources available for learning and developing with Golang, including libraries, frameworks, and tools.

Overall, Go is a powerful and versatile language that offers several advantages over other languages for certain use cases. Learning Go can be a valuable addition to a programmer's skill set.

Introduction to Golang Packages

In Golang, a package is a collection of source code files that are organized together to provide a specific functionality. Packages can be reused across various programs by importing them into a different program. The standard library of Golang contains a large number of packages that can be used to perform various tasks such as formatting, reading and writing files, networking, and many more.

When we create a program in Golang, we can divide it into multiple packages to improve the structure and maintainability of the code. Packages make it easier to test, modify and reuse code.

To use a package in a program, we need to import it at the beginning of the program using the "import" keyword followed by the package name. Once imported, the functions and variables defined in the package can be accessed and used within the program.

Overall, Golang packages provide a modular approach to programming that helps developers in building robust and scalable applications.

Is Golang case sensitive or insensitive?

In Go programming language, identifiers such as variable names and function names are case sensitive. This means that variables with different capitalizations are treated as different variables. For example, "myVar" and "myvar" are two different variables in Go.

On the other hand, keywords like "if", "else", and "func" in Go are case insensitive. This means that they can be written in any combination of capital and lowercase letters and will still be recognized as keywords by the Go compiler. However, it is recommended to use the standard capitalization for keywords for the sake of readability and maintainability of code.

Golang Pointers Explained

In Golang, pointers are variables that store memory addresses. They are used to reference the location of other variables in the memory, allowing direct modification of the data stored in the referenced location. Pointers are always denoted by an asterisk (*) followed by the variable name.

One of the key benefits of using pointers in Golang is that they allow for pass-by-reference instead of pass-by-value. This means that a function can modify the original variable in memory, instead of creating a copy of it. This can help conserve memory and improve the performance of programs dealing with large amounts of data.

However, it's important to use pointers with care to avoid pointer-related errors such as null pointer dereference and memory leaks. In Golang, there are a number of tools and conventions to help avoid such issues, such as the new() function and defer statements.

Golang String Literals

Golang string literals are a sequence of characters surrounded by double quotes. They can contain escape sequences like \n (newline), \t (tab), and \". Backslashes themselves can be escaped with another backslash. Here's an example of a string literal in Go:

go
greeting := "Hello, world! \n"

This creates a string variable called `greeting` that contains the text "Hello, world!" followed by a newline character. We can print the contents of this variable using `fmt.Println()`:

go
fmt.Println(greeting)

This would output:

Hello, world!

String literals are immutable, meaning that once they are defined, their value cannot be changed. However, we can create new string variables by concatenating existing ones using the `+` operator:

go
greeting2 := greeting + " How are you?"
fmt.Println(greeting2)

This would output:

Hello, world!
How are you?

We can also use backticks (`) instead of double quotes to create a raw string literal. Raw string literals preserve the literal value of all characters, including backslashes and newlines, without the need for escape sequences. Here's an example:

go
message := `This is a
multi-line message
with "quotes" and backslashes: \a \n`

fmt.Println(message)

This would output:

This is a
multi-line message
with "quotes" and backslashes: \a \n

Syntax for For Loop in Golang

The syntax for a for loop in Golang is as follows:

for initialization; condition; increment/decrement {
    // Code to be executed
}

Here's what each part of the syntax stands for:

- `initialization`: This declares and initializes the loop variable. It is executed only once at the beginning of the loop. - `condition`: This is the condition that is evaluated before each iteration of the loop. If the condition is true, the loop will continue to execute. If the condition is false, the loop will terminate. - `increment/decrement`: This is the statement that is executed at the end of each iteration of the loop. It is used to modify the loop variable so that the condition will eventually become false and the loop will terminate. - `Code to be executed`: This is the code that will be executed repeatedly as long as the condition is true.

Example:

for i := 1; i <= 5; i++ {
    fmt.Println(i)
}

In this example, the loop variable `i` is initialized to 1, the condition is `i <= 5`, and `i` is incremented by 1 after every iteration. The loop will execute 5 times, and each time it will print the value of `i`.

Understanding Variable Scope in Go

In Go, the scope of a variable refers to the portion of the code where the variable is visible and accessible. Variables declared within a function are usually considered to have a local scope, meaning they can only be accessed within that function. However, variables declared outside of a function can have a package or global scope, making them accessible to any function within the same package or even across different packages.

It's important to note that variables with the same name declared in different scopes are considered distinct and do not interact with each other. Additionally, the order in which variables are declared within a scope can affect their accessibility within nested scopes. Therefore, it's crucial to understand the scope rules in Go to avoid naming conflicts and ensure code operates as intended.

Understanding Goroutines in Go

A goroutine is a lightweight thread of execution in Go programming language. It is used to run multiple functions concurrently without interrupting the flow of execution. Goroutines make it possible to write highly concurrent and efficient programs in Go. They are similar to threads in other programming languages, but they have a smaller memory footprint and are easier to manage. Goroutines are created using the keyword "go" followed by a function call.

Example:

func main() {
    go printNumbers() // create a new goroutine
    printLetters()
}

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func printLetters() {
    for i := 'a'; i < 'e'; i++ {
        fmt.Printf("%c ", i)
    }
}

In the above example, two functions `printNumbers()` and `printLetters()` are defined. The `printNumbers()` function prints integers from 1 to 5, while the `printLetters()` function prints alphabets from 'a' to 'd'. The `printNumbers()` function is called as a goroutine using the `go` keyword. As a result, `printLetters()` executes first in the main goroutine, followed by `printNumbers()` in a separate goroutine. When both functions complete their execution, the main goroutine exits. Goroutines are an essential feature of Go that enables the creation of highly concurrent and scalable programs.

Is it Possible to Return Multiple Values from a Function in Go?

Yes, it is possible to return multiple values from a function in Go. This is one of the convenient features of Go. You can return as many values as you want, and they can be of different types.

Here's an example:

func getInfo() (string, int) {
   return "John Doe", 28
}

func main() {
   name, age := getInfo()
   fmt.Println(name, age)
}

In this example, the function "getInfo" returns two values of different types - a string and an integer. In the main function, we store these values in "name" and "age" variables respectively and then print them.

So, this is how you can return multiple values from a function in Go.

Declaring Multiple Variables of Different Types in a Single Line of Code in Golang

Yes, it is possible to declare variables of different types in a single line of code in Golang.

Code:

var (
    name string = "John"
    age int = 25
    salary float64 = 2500.50
)

In the above code, we can see that we have declared three variables `name`, `age`, and `salary` of different types `string`, `int`, and `float64`, respectively, in a single line of code.

It is also important to note that we have used the `var` keyword to declare variables and assigned initial values to them using the `=` operator.

This method of declaring variables in Golang is known as the *multiple-variable declaration syntax* and is commonly used in Go programming.

Explanation of "Slice" in Go Language

In the Go programming language, a "slice" is a dynamically-sized sequence. A slice is created by specifying elements separated by commas and enclosing them within square brackets. The built-in function "make" is used to allocate a new slice, with the specified type and length.

Here is an example of creating a slice of strings:

fruits := []string{"apple", "banana", "orange"}

We can also create an empty slice of a specified length and capacity using the make function as follows:

numbers := make([]int, 3, 5)

In this example, numbers is a slice of integers, with a length of 3 and a capacity of 5. The difference between length and capacity is that length represents the number of elements currently in the slice, while capacity represents the maximum number of elements the slice can hold.

Slices can be manipulated using various built-in functions such as "append" and "copy". The "append" function is used to add elements to the end of a slice, while the "copy" function is used to copy elements from one slice to another.

In summary, a slice in Go is a flexible and powerful tool for working with sequences of data.

Introduction to Go Interfaces

In Go, interfaces define a set of methods that a type must implement. They are similar to Java interfaces. By defining interfaces, we can write functions that can work with any type that implements the same methods as specified in the interface. This is one way to achieve polymorphism in Go.

Why is Go fast compared to other programming languages?

Go, also known as Golang, is considered faster than many other programming languages due to its unique features and design choices. Here are a few reasons why Go is fast:

1. Concurrency: Go is designed to make it easy to write code that can run simultaneously across multiple CPUs, also known as concurrency. This allows programs written in Go to take advantage of modern multi-core processors, making them faster than programs written in languages that lack built-in concurrency support.
2. Garbage collection: Go uses an efficient garbage collector (GC) that minimizes the amount of CPU time required for memory management, which in turn improves overall program performance.
3. Compiled language: Go is a compiled language, which means that its code is translated directly into machine code that the computer can execute, rather than interpreted at runtime. This results in faster program execution, as there is no overhead associated with interpreting code.
4. Simplicity: Go is designed to be a simple language with a minimalistic syntax, making it easy for developers to understand and write efficient code without unnecessary complexity.

Overall, Go's design choices and features make it a fast and efficient programming language that is especially well-suited for building scalable, highly concurrent applications and systems.

Checking if a Key is Present in the Go Map

To check if a key exists in a Go map, we use the following syntax:

go
value, exists := myMap[key]

If the key exists in the map, the 'value' variable will contain the associated value and the second boolean variable 'exists' will be set to 'true'. Otherwise, the 'value' will be set to the zero value of its type and 'exists' will be set to 'false'.

Here's an example:

go
package main

import "fmt"

func main() {
   // Creating a map
   myMap := map[string]int{"foo": 1, "bar": 2, "baz": 3}

   // Check if "foo" key is present in the map
   if _, ok := myMap["foo"]; ok {
      fmt.Println("The key 'foo' exists in the map.")
   } else {
      fmt.Println("The key 'foo' does not exist in the map.")
   }

   // Check if "qux" key is present in the map
   if _, ok := myMap["qux"]; ok {
      fmt.Println("The key 'qux' exists in the map.")
   } else {
      fmt.Println("The key 'qux' does not exist in the map.")
   }
}

Output:

The key 'foo' exists in the map.
The key 'qux' does not exist in the map.

Understanding Go Channels and Their Usage

In Go language, channels provide a way for goroutines to communicate with each other. A channel is essentially a conduit that allows data to flow between goroutines.

Channels are created using the `make` keyword along with the `chan` keyword, which specifies the type of data that the channel will transmit. For example, to create a channel that only transmits integers, you would use the following syntax:

ch := make(chan int)

Channels have a send and receive operation, which are denoted by the `<-` operator. The `send` operation sends a value through the channel to a receiving goroutine, whereas the `receive` operation waits for a value to be sent. Here's an example:

ch := make(chan int)

go func() {
    ch <- 42 // Sends the integer 42 through the channel
}()

result := <-ch // Waits for a value to be sent through the channel and assigns it to the variable result
fmt.Println(result) // Outputs: 42

In this example, the `go` keyword creates a new goroutine and sends the integer 42 through the channel `ch`. The main goroutine then waits for a value to be sent through the `ch` channel and assigns it to the variable `result`, which is then printed to the console.

Channels can also be used to broadcast messages to multiple goroutines by creating a buffered channel and sending the same value to multiple receivers.

Overall, channels are a powerful tool in Go language for allowing safe and efficient communication between goroutines.

Golang Interview Question

Can you explain the purpose of each function in the following code?

func DemoFunc(a, b int) int {
   return a + b
}

func DemoFunc(a, b, c int) int {
   return a + b + c
}

func DemoFunc(str string) string {
   return "Hello " + str
}

Formatting a String without Printing in Python

Yes, you can format a string without printing it in Python by using the `format()` method. This method takes the value passed to it and formats it as a string using a given set of rules.

For example:

python
name = "John"
age = 30
formatted_string = "My name is {} and I am {} years old".format(name, age)

In this code, we create two variables `name` and `age` which are used to format the string using the `format()` method. The resulting formatted string is stored in the `formatted_string` variable.

We can also use f-strings in Python 3.6 and above to format a string without printing it.

python
name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old"

Here, we use the `f` character before the string to indicate that it is an f-string. The variables `name` and `age` are then used within curly braces `{}` to format the string. The resulting formatted string is again stored in the `formatted_string` variable.

Understanding Type Assertion in Go

Type assertion in Go is a way to check the type of an interface variable and retrieve its value in a specified type. It is a powerful feature that allows programmers to write code that can handle different types dynamically, without knowing the type at the compile time. It is used to convert an interface type to a specified type so that functions may be called on the real value.

Here's an example of type assertion in Go:

var x interface{} = "Hello, World!"
s := x.(string) // type assertion
fmt.Println(s)

In the code above, we have an empty interface `x` that contains a string value. We then use type assertion to retrieve the string value and store it in the variable `s`. The `.(string)` syntax tells Go that we expect `x` to contain a string value. If `x` contained a different type (such as an integer or a boolean), the program would panic at runtime.

Type assertion can also return two values, the second value is called "ok" and is a boolean that indicates whether the assertion succeeded or not.

var x interface{} = 5
n, ok := x.(int)
if ok {
    fmt.Printf("x is an int: %d\n", n)
} else {
    fmt.Printf("x is not an int\n")
}

In the code above, we have an empty interface `x` that contains an integer value. We use type assertion with the `.(int)` syntax to retrieve the integer value and store it in the variable `n`. We also use the boolean value `ok` to check whether the assertion succeeded or not. If it succeeded, we print a message that says `x is an int` and the value of `n`. If it didn't succeed, we print a message that says `x is not an int`.

Overall, type assertion is a very useful tool in Go that allows programmers to write more flexible and dynamic code.

Checking variable type at runtime in Go

In Go, we can use the built-in function `fmt.Printf()` along with the `%T` verb to get the type of a variable at runtime. Here's an example:

go
package main

import "fmt"

func main() {
    var num int = 42
    var str string = "Hello, World!"

    fmt.Printf("num is of type %T\n", num)   // Output: num is of type int
    fmt.Printf("str is of type %T\n", str)   // Output: str is of type string
}

In the above code, we have two variables `num` and `str`, and we use the `%T` verb along with `fmt.Printf()` to get their types at runtime. The output of the code will be:

num is of type int
str is of type string

This can be useful, for example, when debugging or when working with interfaces, where we need to check the type of a value dynamically.

Is it recommended to use global variables in programs that implement goroutines?

In general, it is not recommended to use global variables in programs that implement goroutines because it can lead to issues with race conditions and make it difficult to reason about the state of the program. Instead, it is recommended to use channels or other synchronization mechanisms to communicate between goroutines and avoid conflicting access to shared resources. By following best practices for concurrent programming, you can ensure that your program is safe and performs well.

Uses of an Empty Struct

An empty struct in programming serves as a way to define a data type with zero storage requirements. Despite being empty, it can still have practical uses, such as serving as a placeholder or marker for grouping related variables or as a dummy type for enforcing type safety in a complex program.

How to Copy a Slice and a Map in Go?

In Go, we can copy a slice using the built-in `copy()` function. It takes two arguments, the destination slice and the source slice. The destination slice must have enough capacity to hold all the elements that we want to copy.

Example:

go
package main

import "fmt"

func main() {
    sourceSlice := []string{"apple", "banana", "orange"}
    destinationSlice := make([]string, len(sourceSlice))
    copy(destinationSlice, sourceSlice)
    fmt.Println(destinationSlice) // Output: [apple banana orange]
}

Similarly, we can copy a map by iterating over its key-value pairs. We then create a new map and add the key-value pairs from the original map to the new map.

Example:

go
package main

import "fmt"

func main() {
    originalMap := map[string]int{"apple": 1, "banana": 2, "orange": 3}
    newMap := make(map[string]int)

    for key, value := range originalMap {
        newMap[key] = value
    }

    fmt.Println(newMap) // Output: map[apple:1 banana:2 orange:3]
}

How is the GOPATH Variable Different from the GOROOT Variable in Go?

In Go, both the GOPATH and GOROOT variables are used for locating package files, but they serve different purposes.

The GOROOT variable specifies the location of the Go installation directory. It includes standard packages like fmt, os, and others that are essential to run Go programs. It is set when Go is installed, and it should not be modified.

On the other hand, the GOPATH variable specifies the location of your Go workspace. It contains your own packages, as well as third-party packages installed via the go get command. It should contain three subdirectories: bin, pkg, and src. You can modify this variable according to your needs.

It is important to keep these variables distinct to avoid any confusion or potential conflicts.

Good Error Handling Practices in Go

When it comes to error handling in Go, there are several best practices to keep in mind.

Firstly, it's important to make use of the built-in error type. This allows for consistent error handling across functions and packages.

Additionally, Go uses the idiom of returning multiple values, with the second value being an error. This makes it easy to handle errors using if statements and ensures that the error is not ignored.

It's also recommended to wrap errors with context to provide additional information about where in the code the error occurred. The Go standard library provides the "errors" package for this purpose.

Lastly, it's important to handle errors at the appropriate level in the application. In general, this means handling errors at the highest level possible while still maintaining proper functionality.

By following these practices, error handling in Go can be both effective and easy to manage.

Which is Safer for Concurrent Data Access: Channels or Maps?

In terms of safety and concurrency, using channels is generally considered safer than using maps. This is because channels have built-in synchronization, which ensures that data is accessed and modified by only one goroutine at a time. Maps, on the other hand, do not have this built-in synchronization, which can lead to race conditions and other concurrency issues if not properly managed through techniques like locks or the sync package. Therefore, when dealing with concurrent data access, it is recommended to use channels for optimal safety and efficiency.H3. Sorting a slice of custom structs in Go

To sort a slice of custom structs in Go, you can use the `sort` package in combination with the `sort.Slice()` function. Here's an example:

Code:

go
package main

import (
	"fmt"
	"sort"
)

type Person struct {
	Name string
	Age  int
}

// Define a slice of persons
var people = []Person{
	{"John", 25},
	{"Alice", 30},
	{"Bob", 20},
}

// Custom sorting function for sorting by age
func sortByAge(slice []Person) {
	sort.Slice(slice, func(i, j int) bool {
		return slice[i].Age < slice[j].Age
	})
}

func main() {
	// Print the unsorted slice
	fmt.Println("Unsorted slice: ", people)

	// Sort the slice by age using the custom sorting function
	sortByAge(people)

	// Print the sorted slice
	fmt.Println("Sorted slice: ", people)
}

In this example, we create a custom `Person` struct with the fields `Name` and `Age`. We then define a slice of persons called `people`.

Next, we define a custom sorting function called `sortByAge` that sorts the slice by age using the `sort.Slice()` function and a lambda function.

Finally, we call the `sortByAge` function to sort the `people` slice by age, and then we print the unsorted and sorted slices to the console.

Output:

Unsorted slice:  [{John 25} {Alice 30} {Bob 20}]
Sorted slice:  [{Bob 20} {John 25} {Alice 30}]

As you can see, the slice is sorted in ascending order by age according to the custom sorting function. You can modify the sorting function to sort the slice based on different criteria, such as name, ID, or any other field in the custom struct.

Understanding Shadowing in Go Programming Language

Shadowing in Go refers to a situation where a variable declared within a nested block of code has the same name as a variable declared in an outer block of code. In such a scenario, the inner variable is said to "shadow" or hide the outer variable. This means that any references to the variable name within the nested block of code will refer to the inner variable, rather than the outer one. Once the nested block of code is exited, the outer variable becomes visible again.

Here is an example of shadowing in Go:

package main

import "fmt"

func main() {
    var x int = 10
    fmt.Println("Outer x:", x) // prints "Outer x: 10"

    // Declare a nested block of code
    {
        var x int = 20
        fmt.Println("Inner x:", x) // prints "Inner x: 20"
    }

    fmt.Println("Outer x:", x) // prints "Outer x: 10" again
}

In the example above, the variable `x` is declared twice - once in the outer block of code with a value of 10, and again in the inner block of code with a value of 20. When the print statements are executed within the nested block of code, they refer to the inner value of `x`, which is 20. However, when the print statement is executed outside of the nested block of code, it refers to the outer value of `x`, which is 10.

Understanding Variadic Functions in Go

Variadic functions in Go are functions that can be called with a variable number of arguments. These functions are declared with an ellipsis (...) before the type of the last parameter of the function. The ellipsis indicates that the function can receive any number of arguments of the specified type.

For example, the following function calculates the sum of any number of integers passed as arguments:

func sum(nums ...int) int {
    sum := 0
    for _, num := range nums {
        sum += num
    }
    return sum
}

This function can be called with one or more integers, like this:

sum(1, 2, 3) // returns 6

The variadic function can also receive a slice of integers. In this case, the function receives a single argument of type []int:

nums := []int{1, 2, 3, 4}
sum(nums...) // returns 10

Using variadic functions can help simplify your code and make it more flexible.

Understanding the Byte and Rune Data Types in Go

In Go, a byte is a data type that represents a sequence of 8 bits. It is commonly used in Go for handling streams of data and for working with raw data. A byte can hold any value between 0 and 255.

Rune, on the other hand, is a data type that represents a Unicode code point. It can hold any Unicode code point, which can be from 0 to 1,114,111. In Go, strings are made up of runes.

Both byte and rune types can be represented using a single literal character or a sequence of them. However, the way that these types are represented can differ depending on the context. For example, a byte can be represented as a single unsigned integer, or it can be represented as a sequence of ASCII characters.

In summary, the byte and rune data types in Go are essential in handling raw data and Unicode characters, respectively. Understanding how they are represented is crucial in effectively working with them in your code.

Go Program to Swap Variables in a List

Here's an example Go program that swaps two variables in a list:

package main

import "fmt"

func main() { // Declare a list of variables var list = []int{5, 10, 15, 20}

// Display the original list fmt.Println("Original list:", list)

// Swap the second and third variables list[1], list[2] = list[2], list[1]

// Display the modified list fmt.Println("Modified list:", list) }

In the above program, we first declare a list of integers and display it using the fmt.Println() function. Then we swap the second and third variables in the list using a simple assignment statement, and display the modified list again.

This program can be useful in situations where we need to reorder the elements in a list, or swap the positions of specific elements.

GO Program to Find Factorial of a Given Number

package main

import (
	"fmt"
)

func factorial(n int) int {
	// base case
	if n == 0 {
		return 1
	}
	// recursive case
	return n * factorial(n-1)
}

func main() {
	var num int
	fmt.Print("Enter a number: ")
	fmt.Scan(&num)

	fmt.Printf("Factorial of %d is %d\n", num, factorial(num))
}

This GO program takes a number as an input from the user and recursively calculates its factorial. The function

factorial()

takes an integer input

n

and calculates its factorial by first checking the base case where

n = 0

. If

n = 0

, then it returns 1 as the factorial of 0 is always 1. If the base case is not met, then the function enters the recursive case and multiplies

n

by the factorial of

n-1

. This process continues until the base case is met.

Then in the main function, the user is prompted to enter a number using

fmt.Scan()

function. The input is read and stored in the variable

num

. Then the function

factorial()

is called with

num

as an argument and its output is printed using

fmt.Printf()

function.

Finding the Nth Fibonacci Number in Go

package main

import "fmt"

func main() {
    // Taking input from user for Nth Fibonacci Number
    var n int
    fmt.Print("Enter the value of n: ")
    fmt.Scan(&n)

    // Compute the Nth Fibonacci Number
    result := fibonacci(n)

    // Display the output
    fmt.Printf("The %dth Fibonacci Number is %d", n, result)
}

func fibonacci(n int) int {
    // Initializing the first two Fibonacci numbers
    n1, n2 := 0, 1

    // Computing Fibonacci Number for n
    for i := 2; i <= n; i++ {
        n1, n2 = n2, n1+n2
    }

    return n2
}

This Go program prompts the user to enter a number "n" to find the Nth Fibonacci Number. The program then calls the "fibonacci" function, which calculates the Nth Fibonacci Number using loop and returns the output, which is then displayed on the console using the Printf function.

Golang Code for Checking If the Given Characters are Present in a String

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "Hello, World!"
	
	// check if "H" and "W" are present in the string
	if strings.ContainsAny(str, "HW") {
		fmt.Println("Found")
	} else {
		fmt.Println("Not Found")
	}
}

This code uses the

strings.ContainsAny()

function to check if the given characters "H" and "W" are present in the string "Hello, World!". If the function returns true, the code prints "Found". Otherwise, it prints "Not Found". You can modify the string and characters to test this code.

Comparing two byte slices in Go

func compareSlices(a, b []byte) bool {
	if len(a) != len(b) { // if different length => not equal
		return false
    }
	
	for i := range a {
		if a[i] != b[i] { // if different element => not equal
			return false
		}
	}
	
	return true // all elements are equal => slices are equal
}

To use the function, you can pass in two slices of bytes and it will return true if they have the same length and all of their elements are equal:

a := []byte{1,2,3}
b := []byte{1,2,4}

fmt.Println(compareSlices(a, b)) // false

c := []byte{1,2,3}
d := []byte{1,2,3}

fmt.Println(compareSlices(c, d)) // true