Table of Contents
Questions on Golang Basics1. What are the benefits of using Go compared to other languages?2. What are string literals?3. What data types does Golang use?4. What are packages in a Go program?5. What form of type conversion does Go support? Convert an integer to a float.6. What is a goroutine? How do you stop it?7. How do you check a variable type at runtime?8. How do you concatenate strings?Intermediate Golang Questions9. Explain the steps of testing with Golang.10. What are function closures?11. How do we perform inheritance with Golang?12. Explain Go interfaces. What are they and how do they work?13. What are Lvalue and Rvalue in Golang?14. What are the looping constructs in Go?15. Can you return multiple values from a function?Goroutines, channels, and concurrency in GoUnderstanding goroutinesBasic goroutine exampleMultiple goroutinesWhy does time.Sleep() appear?Understanding channelsBasic channel exampleWhat's happening?Buffered vs unbuffered channelsUnbuffered channelBuffered channelUnbuffered exampleBuffered exampleUsing select statementsBasic select exampleTimeout patternWhy is this useful?Synchronizing goroutines with WaitGroupsExampleHow it worksCommon Golang concurrency interview questionsWhat is a goroutine?Goroutines vs threadsBuffered vs unbuffered channelsWhat causes deadlocks?What is a race condition?How does select work?How do you synchronize goroutines?Common concurrency mistakes in GoDeadlocksGoroutine leaksRace conditionsShared memory issuesForgetting to close channelsReal-world concurrency use casesWeb serversBackground workersAPI request aggregationDistributed systemsStreaming pipelinesBest practices for Go concurrencyWhy Go concurrency is popularVisual diagram ideaCoding challenges with Golang16. Implement a Stack (LIFO)17. Print all permutations of a slice characters or string18. Swap the values of two variables without a temporary variable19. Implement min and max behavior20. Reverse the order of a slice21. What is the easiest way to check if a slice is empty?22. Format a string without printing itGolang Concurrency Questions23. Explain the difference between concurrent and parallelism in Golang24. Merge Sort25. Sum of Squares25 More Golang QuestionsNext steps for your learningContinue reading about Golang
Home/
Blog/
Interview Prep/
Crack the top 50 Golang interview questions

Crack the top 50 Golang interview questions

15 mins read
Jun 09, 2026
Share
editor-page-cover

The Go programming language, or Golang, is an open-source programming language similar to C but is optimized for quick compiling, seamless concurrency, and developer ease of use.

This language was created and adopted by Google but has been gaining popularity in other companies in recent years as the demand for concurrent, networked programs is increasing.

Whether you’re preparing for a Google job interview or just want to remain a cutting edge developer, Go is the right choice for you. Today, we’ll help you practice your Go skills with 50 of the most important Go questions and answers.

Cover
Grokking the Coding Interview Patterns in Go

With thousands of potential questions to account for, preparing for the coding interview can feel like an impossible challenge. Yet with a strategic approach, coding interview prep doesn’t have to take more than a few weeks. Stop drilling endless sets of practice problems, and prepare more efficiently by learning coding interview patterns. This course teaches you the underlying patterns behind common coding interview questions. By learning these essential patterns, you will be able to unpack and answer any problem the right way — just by assessing the problem statement. This approach was created by FAANG hiring managers to help you prepare for the typical rounds of interviews at major tech companies like Apple, Google, Meta, Microsoft, and Amazon. Before long, you will have the skills you need to unlock even the most challenging questions, grok the coding interview, and level up your career with confidence. This course is also available in JavaScript, C++, Java, and Python — with more coming soon!

85hrs
Intermediate
579 Challenges
582 Quizzes

Questions on Golang Basics#

1. What are the benefits of using Go compared to other languages?#

  • Unlike other languages which started as academic experiments, Go code is pragmatically designed. Every feature and syntax decision is engineered to make life easier for the programmer.

  • Golang is optimized for concurrency and works well at scale.

  • Golang is often considered more readable than other languages due to a single standard code format.

  • Automatic garbage collection is notably more efficient than Java or Python because it executes concurrently alongside the program.

2. What are string literals?#

A string literal is a string constant formed by concatenating characters. The two forms of string literal are raw and interpreted string literals.

Raw string literals are written within backticks (foo) and are filled with uninterpreted UTF-8 characters. Interpreted string literals are what we commonly think of as strings, written within double quotes and containing any character except newline and unfinished double quotes.

3. What data types does Golang use?#

Golang uses the following types:

  • Method
  • Boolean
  • Numeric
  • String
  • Array
  • Slice
  • Struct
  • Pointer
  • Function
  • Interface
  • Map
  • Channel

4. What are packages in a Go program?#

Packages (pkg) are directories within your Go workspace that contain Go source files or other packages. Every function, variable, and type from your source files are stored in the linked package. Every Go source file belongs to a package, which is declared at the top of the file using:

package <packagename>

You can import and export packages to reuse exported functions or types using:

import <packagename>

Golang’s standard package is fmt, which contains formatting and printing functionalities like Println().

5. What form of type conversion does Go support? Convert an integer to a float.#

Go supports explicit type conversion to satisfy its strict typing requirements.

i := 55      //int

j := 67.8    //float64

sum := i + int(j) //j is converted to int

6. What is a goroutine? How do you stop it?#

A goroutine is a function or method that executes concurrently alongside any other goroutines using a special goroutine thread. Goroutine threads are more lightweight than standard threads, with most Golang programs using thousands of goroutines at once.

To create a goroutine, add the go keyword before the function declaration.

go f(x, y, z)

You can stop a goroutine by sending it a signal channel. Goroutines can only respond to signals if told to check, so you’ll need to include checks in logical places such as at the top of your for loop.

Go (1.6.2)
package main
func main() {
  quit := make(chan bool)
  go func() {
    for {
        select {
        case <-quit:
            return
        default:
            // …
        }
  }
}()
// …
quit <- true
}

Enjoying the article? Scroll down to sign up for our free, bi-monthly newsletter.

7. How do you check a variable type at runtime?#

The Type Switch is the best way to check a variable’s type at runtime. The Type Switch evaluates variables by type rather than value. Each Switch contains at least one case, which acts as a conditional statement, and a default case, which executes if none of the cases are true.

For example, you could create a Type Switch that checks if interface value i contains the type int or string:

Go (1.6.2)
package main
import "fmt"
func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Double %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know  type %T!\n", v)
	}
}
func main() {
	do(21)
	do("hello")
	do(true)
}

8. How do you concatenate strings?#

The easiest way to concatenate strings is to use the concatenation operator (+), which allows you to add strings as you would numerical values.

Go (1.6.2)
package main
import "fmt"
  
func main() { 
  
    // Creating and initializing strings 
    // using var keyword 
    var str1 string 
    str1 = "Hello "
  
    var str2 string 
    str2 = "Reader!"
  
    // Concatenating strings 
    // Using + operator 
    fmt.Println("New string 1: ", str1+str2) 
  
    // Creating and initializing strings 
    // Using shorthand declaration 
    str3 := "Welcome"
    str4 := "Educative.io"
  
    // Concatenating strings 
    // Using + operator 
    result := str3 + " to " + str4 
  
    fmt.Println("New string 2: ", result) 
  
}

Intermediate Golang Questions#

9. Explain the steps of testing with Golang.#

Golang supports automated testing of packages with custom testing suites.

To create a new suite, create a file that ends with _test.go and includes a TestXxx function, where Xxx is replaced with the name of the feature you’re testing. For example, a function that tests login capabilities would be called TestLogin.

You then place the testing suite file in the same package as the file you wish to test. The test file will be skipped on regular execution but will run when you enter the go test command.

10. What are function closures?#

Function closures is a function value that references variables from outside its body. The function may access and assign values to the referenced variables.

For example: adder() returns a closure, which is each bound to its own referenced sum variable.

Go (1.6.2)
package main
import "fmt"
func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}
func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}

11. How do we perform inheritance with Golang?#

This is a bit of a trick question: there is no inheritance in Golang because it does not support classes.

However, you can mimic inheritance behavior using composition to use an existing struct object to define a starting behavior of a new object. Once the new object is created, functionality can be extended beyond the original struct.

type Animal struct {
	// …
}

func (a *Animal) Eat()   { … }
func (a *Animal) Sleep() { … }
func (a *Animal) Run() { … }

type Dog struct {
	Animal
	// …
}

The Animal struct contains Eat(), Sleep(), and Run() functions. These functions are embedded into the child struct Dog by simply listing the struct at the top of the implementation of Dog.

12. Explain Go interfaces. What are they and how do they work?#

Interfaces are a special type in Go that define a set of method signatures but do not provide implementations. Values of interface type can hold any value that implements those methods.

Interfaces essentially act as placeholders for methods that will have multiple implementations based on what object is using it.

For example, you could implement a geometry interface that defines that all shapes that use this interface must have an implementation of area() and perim().

type geometry interface {
    area() float64
    perim() float64
}

13. What are Lvalue and Rvalue in Golang?#

Lvalue

  • Refers to a memory location

  • Represents a variable identifier

  • Mutable

  • May appear on the left or right side of the = operator

For example: In the statement x =20, x is an lvalue and 20 is an rvalue.

Rvalue

  • Represents a data value stored in memory

  • Represents a constant value

  • Always appears on the = operator’s right side.

For example, The statement 10 = 20 is invalid because there is an rvalue (10) left of the = operator.

14. What are the looping constructs in Go?#

Go has only one looping construct: the for loop. The for loop has 3 components separated by semicolons:

  • The Init statement, which is executed before the loop begins. It’s often a variable declaration only visible within the scope of the for loop.

  • The condition expression, which is evaluated as a Boolean before each iteration to determine if the loop should continue.

  • The post statement, which is executed at the end of each iteration.

Go (1.6.2)
package main
import "fmt"
func main() {
    sum := 0
    for i := 0; i < 10; i++ {
        sum += i
    }
    fmt.Println(sum)
}

15. Can you return multiple values from a function?#

Yes. A Go function can return multiple values, each separated by commas in the return statement.

Go (1.6.2)
package main
import "fmt"
func foo() (string, string) {
   return "two", "values"
}
func main() {
   fmt.Println(foo())
}
Cover
Grokking the Coding Interview Patterns in Go

With thousands of potential questions to account for, preparing for the coding interview can feel like an impossible challenge. Yet with a strategic approach, coding interview prep doesn’t have to take more than a few weeks. Stop drilling endless sets of practice problems, and prepare more efficiently by learning coding interview patterns. This course teaches you the underlying patterns behind common coding interview questions. By learning these essential patterns, you will be able to unpack and answer any problem the right way — just by assessing the problem statement. This approach was created by FAANG hiring managers to help you prepare for the typical rounds of interviews at major tech companies like Apple, Google, Meta, Microsoft, and Amazon. Before long, you will have the skills you need to unlock even the most challenging questions, grok the coding interview, and level up your career with confidence. This course is also available in JavaScript, C++, Java, and Python — with more coming soon!

85hrs
Intermediate
579 Challenges
582 Quizzes

Goroutines, channels, and concurrency in Go#

Concurrency is one of Go’s biggest strengths and one of the most frequently tested topics in Golang interviews. Go makes it easy to write concurrent programs using goroutines and channels, allowing applications to handle thousands of tasks efficiently without the complexity often associated with threads.

If you're preparing for backend, cloud, distributed systems, or Kubernetes-related roles, mastering Go concurrency is essential.

Understanding goroutines#

A goroutine is a lightweight concurrent function managed by the Go runtime. You create one simply by using the go keyword before a function call.

Unlike operating system threads, goroutines are extremely lightweight and can be created in large numbers with minimal overhead.

Basic goroutine example#

package mainimport ("fmt""time")func printMessage(msg string) {fmt.Println(msg)}func main() {go printMessage("Hello from goroutine")time.Sleep(time.Second)fmt.Println("Main function completed")}

Multiple goroutines#

package mainimport ("fmt""time")func worker(id int) {fmt.Printf("Worker %d running\n", id)}func main() {for i := 1; i <= 3; i++ {go worker(i)}time.Sleep(time.Second)}

Why does time.Sleep() appear?#

Every Go program starts with a main goroutine.

When the main() function exits:

  • The program terminates

  • All running goroutines are stopped

Without synchronization, your program may exit before goroutines finish executing.

Understanding channels#

Channels provide a safe way for goroutines to communicate.

Instead of sharing memory directly, Go encourages:

"Don't communicate by sharing memory; share memory by communicating."

Channels are typed and support:

  • Sending values

  • Receiving values

  • Synchronization between goroutines

Basic channel example#

package mainimport "fmt"func main() {ch := make(chan string)go func() {ch <- "Hello from channel"}()message := <-chfmt.Println(message)}

What's happening?#

  1. Goroutine sends data into the channel

  2. Main goroutine waits for data

  3. Channel synchronizes execution automatically

Buffered vs unbuffered channels#

Unbuffered channel#

ch := make(chan int)

Buffered channel#

ch := make(chan int, 3)

Feature

Buffered channels

Unbuffered channels

Capacity

Stores multiple values

No storage

Send operation

Blocks only when buffer is full

Blocks until receiver is ready

Receive operation

Blocks when buffer is empty

Blocks until sender provides value

Synchronization

Looser coupling

Strong synchronization

Throughput

Higher

Lower

Typical use case

Worker queues, pipelines

Coordination and synchronization

Unbuffered example#

ch := make(chan int)go func() {ch <- 42}()fmt.Println(<-ch)

The sender waits until a receiver is ready.

Buffered example#

ch := make(chan int, 2)ch <- 1ch <- 2fmt.Println(<-ch)fmt.Println(<-ch)

The sender can place values into the buffer without waiting immediately.

Using select statements#

The select statement allows a goroutine to wait on multiple channel operations simultaneously.

It's similar to a switch, but for channels.

Basic select example#

select {case msg := <-ch1:fmt.Println(msg)case msg := <-ch2:fmt.Println(msg)}

Timeout pattern#

One of the most common interview examples:

package mainimport ("fmt""time")func main() {ch := make(chan string)select {case msg := <-ch:fmt.Println(msg)case <-time.After(2 * time.Second):fmt.Println("Timeout occurred")}}

Why is this useful?#

Timeouts prevent:

  • Deadlocks

  • Infinite waiting

  • Stuck network requests

This pattern appears frequently in production systems.

Synchronizing goroutines with WaitGroups#

sync.WaitGroup lets you wait for multiple goroutines to finish.

Example#

package mainimport ("fmt""sync")func worker(id int, wg *sync.WaitGroup) {defer wg.Done()fmt.Printf("Worker %d completed\n", id)}func main() {var wg sync.WaitGroupfor i := 1; i <= 3; i++ {wg.Add(1)go worker(i, &wg)}wg.Wait()fmt.Println("All workers finished")}

How it works#

  • Add() increases the counter

  • Done() decreases the counter

  • Wait() blocks until counter reaches zero

This is one of the most common concurrency interview questions.

Common Golang concurrency interview questions#

What is a goroutine?#

A goroutine is a lightweight concurrent function managed by the Go runtime. It requires significantly less memory than an OS thread and can be created in large numbers.

Goroutines vs threads#

Threads are managed by the operating system. Goroutines are managed by the Go runtime and are much lighter, allowing thousands or even millions of concurrent tasks.

Buffered vs unbuffered channels#

Unbuffered channels require sender and receiver synchronization. Buffered channels allow values to be stored temporarily before being received.

What causes deadlocks?#

Deadlocks occur when goroutines wait indefinitely for operations that can never complete, such as sending on a channel without a receiver.

What is a race condition?#

A race condition happens when multiple goroutines access shared data simultaneously and at least one modifies it without proper synchronization.

How does select work?#

select waits on multiple channel operations and executes whichever becomes available first.

How do you synchronize goroutines?#

Common approaches include:

  • Channels

  • WaitGroups

  • Mutexes

  • Context cancellation

Common concurrency mistakes in Go#

Deadlocks#

ch := make(chan int)ch <- 1 // Blocks forever

Why it happens: No receiver exists.

How to avoid it: Ensure every send has a matching receive.

Goroutine leaks#

go func() {for {<-ch}}()

Why it happens: Goroutine waits forever.

How to avoid it: Use context cancellation and proper shutdown mechanisms.

Race conditions#

counter++

Multiple goroutines modifying shared variables simultaneously can produce unpredictable results.

Solution: Use mutexes or channels.

Shared memory issues#

Sharing mutable state increases complexity and bugs.

Solution: Prefer message passing through channels.

Forgetting to close channels#

close(ch)

If receivers expect more data indefinitely, they may block forever.

Always close channels when no more values will be sent.

Real-world concurrency use cases#

Web servers#

Each incoming request can be processed in its own goroutine.

Background workers#

Concurrent workers process jobs from queues efficiently.

API request aggregation#

Multiple APIs can be called concurrently to reduce response time.

Distributed systems#

Microservices frequently use goroutines for networking and communication.

Streaming pipelines#

Channels naturally model data flowing through processing stages.

Best practices for Go concurrency#

  • Prefer channels over shared memory

  • Keep goroutines lightweight

  • Use context.Context for cancellation

  • Avoid creating unlimited goroutines

  • Use buffered channels carefully

  • Use sync.WaitGroup for coordination

  • Run the race detector during development

go test -race

This can catch subtle concurrency bugs before production.

Go's concurrency model is popular because it provides a simple way to build highly concurrent applications without the complexity of traditional thread management.

This makes Go a natural fit for:

  • Cloud-native applications

  • Kubernetes components

  • Microservices

  • API gateways

  • Distributed systems

  • High-performance backend services

The combination of goroutines, channels, and runtime scheduling allows developers to write scalable concurrent programs with relatively little code.

Visual diagram idea#

flowchart LRClientRequests --> Worker1[Goroutine Worker 1]ClientRequests --> Worker2[Goroutine Worker 2]ClientRequests --> Worker3[Goroutine Worker 3]Worker1 --> Channel[(Jobs Channel)]Worker2 --> ChannelWorker3 --> ChannelChannel --> Results[(Results Channel)]Results --> Database[(Database)]Results --> API[(External API)]
widget

This worker-pool pattern is one of the most common concurrency architectures you'll encounter in both Go interviews and production systems.

Coding challenges with Golang#

16. Implement a Stack (LIFO)#

Implement a stack structure with pop, append, and print top functionalities.

Solution

You can implement a stack using a slice object.

Go (1.6.2)
package main
import "fmt"
func main() {
// Create
var stack []string
// Push
stack = append(stack, "world!")
stack = append(stack, "Hello ")
for len(stack) > 0 {
        // Print top
        n := len(stack) - 1
        fmt.Print(stack[n])
        // Pop
        stack = stack[:n]
}
// Output: Hello world!
}

First, we use the built-in append() function to implement the append behavior. Then we use len(stack)-1 to select the top of the stack and print.

For pop, we set the new length of the stack to the position of the printed top value, len(stack)-1.

17. Print all permutations of a slice characters or string#

Implement the perm() function that accepts a slice or string and prints all possible combinations of characters.

Solution

Go (1.6.2)
package main
import "fmt"
// Perm calls f with each permutation of a.
func Perm(a []rune, f func([]rune)) {
        perm(a, f, 0)
}
// Permute the values at index i to len(a)-1.
func perm(a []rune, f func([]rune), i int) {
        if i > len(a) {
                f(a)
                return
        }
        perm(a, f, i+1)
        for j := i + 1; j < len(a); j++ {
                a[i], a[j] = a[j], a[i]
                perm(a, f, i+1)
                a[i], a[j] = a[j], a[i]
        }
}
func main() {
Perm([]rune("abc"), func(a []rune) {
        fmt.Println(string(a))
})
}

We use rune types to handle both slices and strings. Runes are Unicode code points and can therefore parse strings and slices equally.

18. Swap the values of two variables without a temporary variable#

Implement swap() which swaps the value of two variables without using a third variable.

Solution

Go (1.6.2)
package main
import "fmt"
func main() {
   fmt.Println(swap())
}
func swap() []int {
      a, b := 15, 10
   b, a = a, b
   return []int{a, b}
}

While this may be tricky in other languages, Go makes it easy.

We can simply include the statement b, a = a, b, what data the variable references without engaging with either value.

19. Implement min and max behavior#

Implement Min(x, y int) and Max(x, y int) functions that take two integers and return the lesser or greater value, respectively.

Solution

By default, Go only supports min and max for floats using math.min and math.max. You’ll have to create your own implementations to make it work for integers.

Go (1.6.2)
package main
import "fmt"
// Min returns the smaller of x or y.
func Min(x, y int) int {
        if x > y {
                return y
        }
        return x
}
// Max returns the larger of x or y.
func Max(x, y int) int {
        if x < y {
                return y
        }
        return x
}
func main() { 
    fmt.Println(Min(5,10))
    fmt.Println(Max(5,10))
}

20. Reverse the order of a slice#

Implement function reverse that takes a slice of integers and reverses the slice in place without using a temporary slice.

Solution

Go (1.6.2)
package main
import "fmt"
func reverse(sw []int) {
        for a, b := 0, len(sw)-1; a < b; a, b = a+1, b-1 {
                sw[a], sw[b] = sw[b], sw[a]
        } 
}
func main() { 
    x := []int{3, 2, 1} 
    reverse(x)
    fmt.Println(x)
}

Our for loop swaps the values of each element in the slice will slide from left to right. Eventually, all elements will be reversed.

21. What is the easiest way to check if a slice is empty?#

Create a program that checks if a slice is empty. Find the simplest solution.

Solution

The easiest way to check if a slice is empty is to use the built-in len() function, which returns the length of a slice. If len(slice) == 0, then you know the slice is empty.

For example:

Go (1.6.2)
package main
import "fmt"
func main() {
  r := [3]int{1, 2, 3}
  if len(r) == 0 {
    fmt.Println("Empty!")
    
  } else {
    fmt.Println("Not Empty!")
  }
}

22. Format a string without printing it#

Find the easiest way to format a string with variables without printing the value.

Solution

The easiest way to format without printing is to use the fmt.Sprintf(), which returns a string without printing it.

For example:

Go (1.6.2)
package main
import "fmt"
func main() {
  s := fmt.Sprintf("Size: %d MB.", 85)
  fmt.Println(s)
}

Golang Concurrency Questions#

23. Explain the difference between concurrent and parallelism in Golang#

Concurrency is when your program can handle multiple tasks at once while parallelism is when your program can execute multiple tasks at once using multiple processors.

In other words, concurrency is a property of a program that allows you to have multiple tasks in progress at the same time, but not necessarily executing at the same time. Parallelism is a runtime property where two or more tasks are executed at the same time.

Parallelism can therefore be a means to achieve the property of concurrency, but it is just one of many means available to you.

The key tools for concurrency in Golang are goroutines and channels. Goroutines are concurrent lightweight threads while channels allow goroutines to communicate with each other during execution.

24. Merge Sort#

Implement a concurrent Merge Sort solution using goroutines and channels.

You can use this sequential Merge Sort implementation as a starting point:

Go (1.6.2)
package main
import "fmt"
         
func Merge(left, right [] int) [] int{
  merged := make([] int, 0, len(left) + len(right))
  for len(left) > 0 || len(right) > 0{
    if len(left) == 0 {
      return append(merged,right...)
    }else if len(right) == 0 {
      return append(merged,left...)
    }else if left[0] < right[0] {
      merged = append(merged, left[0])
      left = left[1:]
    }else{
      merged = append(merged, right [0])
      right = right[1:]
    }
  }
  return merged
}
func MergeSort(data [] int) [] int {
  if len(data) <= 1 {
    return data
  }
  mid := len(data)/2
  left := MergeSort(data[:mid])
  right := MergeSort(data[mid:])
  return Merge(left,right)
}
func main(){
  data := [] int{9,4,3,6,1,2,10,5,7,8}
  fmt.Printf("%v\n%v\n", data, MergeSort(data))
}

Solution

Go (1.6.2)
package main
import "fmt"
func Merge(left, right [] int) [] int{
  merged := make([] int, 0, len(left) + len(right))
  for len(left) > 0 || len(right) > 0{
    if len(left) == 0 {
      return append(merged,right...)
    }else if len(right) == 0 {
      return append(merged,left...)
    }else if left[0] < right[0] {
      merged = append(merged, left[0])
      left = left[1:]
    }else{
      merged = append(merged, right [0])
      right = right[1:]
    }
  }
  return merged
}
func MergeSort(data [] int) [] int {
  if len(data) <= 1 {
    return data
  }
  done := make(chan bool)
  mid := len(data)/2
  var left [] int
  go func(){
    left = MergeSort(data[:mid])
    done <- true
  }()
  right := MergeSort(data[mid:])
  <-done
  return Merge(left,right)
}
func main(){
  data := [] int{9,4,3,6,1,2,10,5,7,8}
  fmt.Printf("%v\n%v\n", data, MergeSort(data))
}

Firstly, in merge sort, we keep dividing our array recursively into the right side and the left side and call the MergeSort function on both sides from line 30 to line 34.

Now we have to make sure that Merge(left,right) is executed after we get return values from both the recursive calls, i.e. both the left and right must be updated before Merge(left,right) can be executable. Hence, we introduce a channel of type bool on line 26 and send true on it as soon as left = MergeSort(data[:mid]) is executed (line 32).

The <-done operation blocks the code on line 35 before the statement Merge(left,right) so that it does not proceed until our goroutine has finished. After the goroutine has finished and we receive true on the done channel, the code proceeds forward to Merge(left,right) statement on line 36.


25. Sum of Squares#

Implement the SumOfSquares function which takes an integer, c and returns the sum of all squares between 1 and c. You’ll need to use select statements, goroutines, and channels.

For example, entering 5 would return 55 because 12+22+32+42+52=551^2 + 2^2 + 3^2 + 4^2 + 5^2 = 55

You can use the following code as a starting point:

Go (1.6.2)
package main
import "fmt"
func SumOfSquares(c, quit chan int) {
// your code here
}
func main() {
  mychannel := make(chan int)
  quitchannel:= make(chan int)
  sum:= 0
  go func() {
    for i := 0; i < 6; i++ {
      sum += <-mychannel
    }
    fmt.Println(sum)
  }()
  SumOfSquares(mychannel, quitchannel)
}

Solution

Go (1.6.2)
package main
import "fmt"
func SumOfSquares(c, quit chan int) {
  y := 1
  for {
    select {
    case c <- (y*y):
      y++
    case <-quit:
      return
    }
  }
}
func main() {
  mychannel := make(chan int)
  quitchannel:= make(chan int)
  sum:= 0
  go func() {
    for i := 1; i <= 5; i++ {
      sum += <-mychannel
    }
    fmt.Println(sum)
    quitchannel <- 0
  }()
  SumOfSquares(mychannel, quitchannel)
}

Take a look at our SumOfSquares function. First, on line 4, we declare a variable y and then jump to the For-Select loop. We have two cases in our select statements:

  • case c <- (y*y): This is to send the square of y through the channel c, which is received in the goroutine created in the main routine.

  • case <-quit: This is to receive a message from the main routine that will return from the function.


25 More Golang Questions#

  1. What is a workspace?

  2. What is CGO? When would you want to use it?

  3. What is shadowing?

  4. What is the purpose of a GOPATH environment variable?

  5. How are pointers used in Go?

  6. What types of pointers does Go have?

  7. Why is Go often called a “Post-OOP” language?

  8. Does Go have exceptions? How does Go handle errors?

  9. When would you use a break statement in Go?

  10. How do untyped constants interact with Go’s typing system?

  11. What is the difference between = and := in Go?

  12. What is the difference between C arrays and Go slices?

  13. Does Go support method overloading?

  1. What makes Go so fast?

  2. How do you implement command-line arguments in Go?

  3. How does Go handle dependencies?

  4. What is a unique benefit of Go’s compiler?

  5. What is in the src directory?

  6. Name one Go feature that would be helpful for DevOps.

  7. What does GOROOT point to?

  8. What makes Go compile quickly?

  9. Implement a binary search tree data structure in Go.

  10. What does it mean when people say Go has a “rich standard library”?

  11. What is an advantage of Go evaluating implicit types at compile time?

  12. Describe the crypto capabilities of Go.

Next steps for your learning#

Great job on those practice questions! Go is a rising language and hands-on practice like this is the key to picking it up fast. To best prepare for interviews, you’ll want to:

  • Develop a detailed study plan
  • Practice Go problems on a whiteboard
  • Learn how to articulate your thought process aloud
  • Prepare for behavioral interviews

To help you learn even faster, Educative has created Grokking Coding Interview Patterns in Go.

This course includes in-depth explanations and practice projects to show you how to get the most out of different coding design patterns.

By the end of the course, you’ll have the practical Go experience you’ll need to pick up this language in half the time.

Happy learning!

Continue reading about Golang#

Frequently Asked Questions

What are Golang operators?

Arithmetic operators Logical operators Relational operators Bitwise operators Assignment operators Misc operators

What are the advantages of Golang?

Go is a straightforward language, which makes it efficient. It boasts faster execution, quicker compilation, effortless upkeep and assistance, and facilitates shorter software development cycles. Golang compiles straight into machine code, avoiding Virtual Machines, which amplifies its speed advantage even further.

How do I prepare for a Golang interview?

To prepare for a Golang interview, you must have a solid understanding of software development concepts like data structures, design patterns, and algorithms. Practice coding questions on LeetCode or Educative.

Written By:
Ryan Thelin
Related Courses
The Way to GoEvent-Driven Architecture in GolangAPI Development in Go Using MongoDBBuilding Practical Applications with Redis Using GoGo Brain TeasersDecode the Coding Interview in Go: Real-World ExamplesWrite Professional Command-line Programs in GoAn Introduction to Programming in GoData Structures & Algorithms In GoWeb Development with Golang and BeegoExploring and Mastering the Full Go FeaturesetConcurrency in Go
Related Blogs
Uber’s interview process & questions in 2026What LeetCode Blind 75 doesn’t teach you about real interviewsHow to get hired as a software engineer in 2026

Free Resources

blog

Uber’s interview process & questions in 2026

blog

What LeetCode Blind 75 doesn’t teach you about real interviews

blog

How to get hired as a software engineer in 2026