Go for Coding Interviews

Go interview basics and runner contracts#

Keep the function signature and types the prompt gives you. Go makes zero values useful, but nil slices, empty slices, missing map keys, and zero values are not interchangeable in every API contract.

func TwoSum(nums []int, target int) []int {
	position := make(map[int]int)
	for index, value := range nums {
		if prior, ok := position[target-value]; ok {
			return []int{prior, index}
		}
		position[value] = index
	}
	return nil
}

• Use short declarations when they clarify ownership, but do not accidentally shadow a result or error in an inner block.
• Multiple assignment makes swaps direct: left, right = right, left.
• A nil slice has length zero and can be ranged over or appended to; confirm whether the caller distinguishes nil from an allocated empty slice in serialized output or equality checks.

Arrays, slices, append, and mutation#

An array value has its length in its type. A slice is a descriptor over a backing array, so subslices can alias each other and append may either reuse that array or allocate a new one depending on capacity.

base := []int{1, 2, 3, 4}
view := base[1:3]       // [2, 3], shares base
view[0] = 9             // base is now [1, 9, 3, 4]

independent := make([]int, len(view))
copy(independent, view)
independent[0] = 7      // base remains unchanged

• append returns the resulting slice header; assign its return value.
• Use copy or append([]T(nil), source...) when the output must not share mutable storage with the input.
• A tiny subslice can retain a large backing array. Copy the live portion when a long-lived result should release the larger storage.

Maps, sets, comma-ok, and equality#

Map lookup returns the value type's zero value when the key is absent. Use the comma-ok form whenever an absent key must differ from a present key storing zero.

type Cell struct {
	Row int
	Col int
}

distance := map[Cell]int{{Row: 0, Col: 0}: 0}
value, present := distance[Cell{Row: 0, Col: 1}]

seen := make(map[Cell]struct{})
seen[Cell{Row: 2, Col: 3}] = struct{}{}
_, visited := seen[Cell{Row: 2, Col: 3}]
_, _, _ = value, present, visited

• Comparable types can be map keys. Slices, maps, and functions are not comparable except to nil; an array or struct key is valid only when all of its components are comparable.
• Use map[T]struct{} for a set when only membership matters.
• Map iteration order is unspecified. Collect and sort keys when output or tie-breaking order is observable.
• Slices require element-by-element comparison or slices.Equal; == is not available for two slices.

Stacks and queues with slices#

A slice supports a stack directly. For FIFO work, keep a head index instead of repeatedly deleting index zero and shifting elements.

queue := []*Node{start}
for head := 0; head < len(queue); head++ {
	node := queue[head]
	queue[head] = nil // release the consumed reference
	for _, next := range node.Neighbors {
		queue = append(queue, next)
	}
}

// In a long-lived queue, compact after a meaningful consumed prefix:
// queue = append([]*Node(nil), queue[head:]...); head = 0

• Popping a stack uses value := stack[len(stack)-1] followed by stack = stack[:len(stack)-1]. Guard the empty case first.
• A head index gives O(1) dequeue work and O(n) total traversal; occasional proportional compaction remains amortized efficient.
• For pointer-containing elements, clear consumed slots before a long-lived backing array retains them unnecessarily.

Strings, bytes, runes, and Unicode assumptions#

A Go string is a read-only byte sequence that conventionally contains UTF-8. len(text) counts bytes, indexing returns one byte, and range decodes runes while reporting each rune's starting byte offset.

text := "aé"
fmt.Println(len(text))         // 3 bytes
fmt.Println(len([]rune(text))) // 2 Unicode code points

for byteOffset, r := range text {
	fmt.Printf("%d %U
", byteOffset, r)
}

• Use []byte when the contract is ASCII or raw bytes and state that assumption.
• Use []rune when indexing or reversing Unicode code points; this still does not implement grapheme-cluster segmentation or normalization.
• Strings can contain arbitrary bytes. range replaces invalid UTF-8 encodings with RuneError while advancing according to the decoder rules.
• Use strings.Builder or a byte/rune buffer for repeated construction instead of repeated immutable concatenation in a loop.

Sorting, search, comparisons, and ties#

Use the standard sort or slices packages and express the full ordering contract. A deterministic secondary key is required when equal primary keys can change the observable answer.

slices.SortFunc(items, func(a, b Item) int {
	if byPriority := cmp.Compare(a.Priority, b.Priority); byPriority != 0 {
		return byPriority
	}
	return cmp.Compare(a.Sequence, b.Sequence)
})

index := sort.Search(len(nums), func(i int) bool {
	return nums[i] >= target
})

• slices.SortFunc and cmp.Compare are available in the Go 1.22+ compatibility target.
• sort.Search expects a monotonic predicate: false values followed by true values. State that proof before using it.
• Use slices.SortStableFunc or sort.SliceStable only when preserving original order for equal keys is part of the contract.

Integer width and arithmetic#

int is either 32 or 64 bits depending on the implementation. Use int for valid indices and sizes, but choose int64 when the prompt's sums, products, distances, or counts require an explicit 64-bit range.

sum := int64(a) + int64(b)
product := int64(width) * int64(height)

mid := left + (right-left)/2

const MaxInt64 = int64(^uint64(0) >> 1)
_ = []int64{sum, product, int64(mid), MaxInt64}

• Converting after an overflowing int operation is too late; widen each operand before addition or multiplication.
• Integer overflow follows Go's defined integer-operation semantics but almost always violates an interview algorithm's mathematical contract.
• Keep index arithmetic in int when indexing slices, and convert deliberately at the numeric boundary rather than scattering casts.

Priority queues with container/heap#

container/heap supplies heap algorithms over a type that implements sort.Interface plus Push and Pop. Call heap.Init once for existing data, then use heap.Push and heap.Pop so swaps restore the invariant.

type Entry struct {
	Priority int
	Sequence int
	Value    string
}

type EntryHeap []Entry

func (h EntryHeap) Len() int { return len(h) }
func (h EntryHeap) Less(i, j int) bool {
	if h[i].Priority != h[j].Priority {
		return h[i].Priority < h[j].Priority
	}
	return h[i].Sequence < h[j].Sequence
}
func (h EntryHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }
func (h *EntryHeap) Push(x any) { *h = append(*h, x.(Entry)) }
func (h *EntryHeap) Pop() any {
	old := *h
	last := old[len(old)-1]
	old[len(old)-1] = Entry{}
	*h = old[:len(old)-1]
	return last
}

h := &EntryHeap{}
heap.Init(h)
heap.Push(h, Entry{Priority: 2, Sequence: 0, Value: "task"})
next := heap.Pop(h).(Entry)