30 Go (Golang) Challenges for Junior to Senior Developers

The traditional first program to verify a working setup.

package main
import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

A basic test of loops and slice manipulation.

func SumSlice(numbers []int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}

Demonstrates handling of runes for proper Unicode character reversal.

func ReverseString(s string) string {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i 

A fundamental algorithm using a simple loop.

func FindMax(numbers []int) (int, error) {
    if len(numbers) == 0 {
        return 0, fmt.Errorf("slice is empty")
    }
    max := numbers[0]
    for _, number := range numbers {
        if number > max {
            max = number
        }
    }
    return max, nil
}

Tests string manipulation and comparison logic.

func IsPalindrome(s string) bool {
    runes := []rune(s)
    for i, j := 0, len(runes)-1; i 

The classic test of basic conditional logic and loops.

func FizzBuzz(n int) {
    for i := 1; i 

Introduces custom types and data organization.

type Person struct {
    Name string
    Age  int
}

func NewPerson(name string, age int) Person {
    return Person{Name: name, Age: age}
}

Shows how to return and check for errors, a core Go concept.

import "strconv"

func ToInt(s string) (int, error) {
    return strconv.Atoi(s)
}
// Usage: if val, err := ToInt("42"); err == nil { ... }

A classic introduction to recursion in Go.

func Factorial(n uint) uint {
    if n 

Demonstrates the "comma ok" idiom for map lookups.

func MapContainsKey(m map[string]int, key string) bool {
    _, ok := m[key]
    return ok
}

Use a map to count the frequency of words in a text.

import "strings"

func WordCount(text string) map[string]int {
    counts := make(map[string]int)
    for _, word := range strings.Fields(text) {
        counts[strings.ToLower(word)]++
    }
    return counts
}

Implement the `sort.Interface` to sort custom types.

import "sort"
type Person struct { Name string; Age int }
type ByAge []Person

func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age 

Use goroutines and channels to fetch data from multiple sources concurrently.

func FetchData(urls []string) map[string]string {
    ch := make(chan struct{url, body string})
    for _, url := range urls {
        go func(u string) {
            // Assume http.Get(u) returns body
            ch 

Convert Go structs to and from JSON.

import "encoding/json"
type User struct { ID int `json:"id"`; Name string `json:"name"` }

// Marshal: json.Marshal(User{...})
// Unmarshal: json.Unmarshal(data, &user)

Use the `net/http` package to create a server with a basic handler.

import "net/http"
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Gopher!")
}

func StartServer() {
    http.HandleFunc("/", helloHandler)
    http.ListenAndServe(":8080", nil)
}

Create a pool of goroutines to process jobs from a channel.

func WorkerPool(numWorkers int, jobs 

Use a map to create a simple Set type with Add, Has, and Remove methods.

type Set map[interface{}]struct{}

func (s Set) Add(v interface{}) { s[v] = struct{}{} }
func (s Set) Has(v interface{}) bool { _, ok := s[v]; return ok }
func (s Set) Remove(v interface{}) { delete(s, v) }

Implement a method that modifies the state of a struct.

type Counter struct { count int }

func (c *Counter) Increment() {
    c.count++
}

A recursive algorithm that validates the properties of a Binary Search Tree.

type TreeNode struct { Val int; Left, Right *TreeNode }

func IsValidBST(root *TreeNode) bool {
    return isValid(root, nil, nil)
}

func isValid(node, min, max *TreeNode) bool {
    if node == nil { return true }
    if min != nil && node.Val = max.Val { return false }
    return isValid(node.Left, min, node) && isValid(node.Right, node, max)
}

Use the `os` package for basic file I/O operations.

import "os"
// Write
// err := os.WriteFile("test.txt", []byte("Hello"), 0644)
// Read
// data, err := os.ReadFile("test.txt")

Build a map that is safe for concurrent read/write operations.

import "sync"
type ConcurrentMap struct {
    mu sync.RWMutex
    items map[string]interface{}
}

func (cm *ConcurrentMap) Set(key string, value interface{}) {
    cm.mu.Lock()
    defer cm.mu.Unlock()
    cm.items[key] = value
}

func (cm *ConcurrentMap) Get(key string) (interface{}, bool) {
    cm.mu.RLock()
    defer cm.mu.RUnlock()
    value, ok := cm.items[key]
    return value, ok
}

Use `context` and channels to allow a server to finish active requests before shutting down.

import "os/signal"
// ...
server := &http.Server{Addr: ":8080"}
go func() {
    if err := server.ListenAndServe(); err != http.ErrServerClosed {
        log.Fatalf("ListenAndServe(): %v", err)
    }
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

Use a ticker and a channel to limit the rate of events.

func RateLimiter(requests 

A system design problem requiring a map and a doubly linked list for efficiency.

import "container/list"
type LRUCache struct {
    capacity int
    cache    map[int]*list.Element
    ll       *list.List
}
// ... methods for Get and Put would manipulate the map and linked list ...

Write a function that accepts a `context.Context` and can be cancelled.

func LongRunningTask(ctx context.Context) error {
    for {
        select {
        case 

Use the `reflect` package to dynamically read struct tags and values.

import "reflect"
func InspectStruct(s interface{}) {
    val := reflect.ValueOf(s).Elem()
    for i := 0; i 

Create a logging middleware for an `http.Handler`.

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Request: %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}
// Usage: http.Handle("/", LoggingMiddleware(myHandler))

A pattern for distributing work and then merging the results.

func FanIn(inputs ...

A classic concurrency problem to demonstrate deadlock avoidance.

// The solution involves giving each philosopher two forks (mutexes)
// and ensuring they pick them up in a consistent order (e.g., lowest
// index first) to prevent circular waits and deadlock.
// The implementation requires a struct for philosophers, a slice
// of mutexes for forks, and a main loop for eating/thinking.

A design pattern to prevent repeated calls to a failing external service.

// The implementation would involve a struct that tracks the state
// (Closed, Open, Half-Open), failure counts, and timers. A method
// like Execute(fn) would wrap the external call, checking the state
// before proceeding and updating counts on success or failure.