Named return values in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of function with named return values and naked return

What is the output of this Go program?

Go

package main
import "fmt"

func calculate() (sum int, product int) {
	sum = 3 + 4
	product = 3 * 4
	return
}

func main() {
	s, p := calculate()
	fmt.Println(s, p)
}

A 0 0

B 7 12

C 7 0

D Compilation error

💡 Hint

Named return values can be set inside the function and returned with a naked return.

The function calculate() uses named return values sum and product. They are assigned values inside the function. The naked return returns these values. So the output is '7 12'.

❓ Predict Output

intermediate

Effect of modifying named return values before return

What will this Go program print?

Go

package main
import "fmt"

func getValues() (x int, y int) {
	x = 5
	y = 10
	x += 2
	return
}

func main() {
	a, b := getValues()
	fmt.Println(a, b)
}

A 7 10

B 0 0

C 5 10

D Compilation error

💡 Hint

Named return values can be changed before the naked return statement.

The function sets x=5 and y=10, then increments x by 2 making x=7. The naked return returns x=7 and y=10.

🔧 Debug

advanced

Why does this function return zero values?

This Go function is intended to return the sum and difference of two integers using named return values. Why does it always return zero for both values? func compute(a, b int) (sum int, diff int) { return sum, diff }

Go

func compute(a, b int) (sum int, diff int) {
	return sum, diff
}

A It returns zero because named return values are ignored when explicit return values are given.

B It returns zero because the function has no return statement.

C It returns zero because the function does not assign values to sum and diff.

D It returns zero because the return statement is missing parentheses.

💡 Hint

Check how named return values interact with explicit return values.

Named return values `sum` and `diff` are zero-initialized. The function does not assign values to them before explicitly returning `sum, diff`, so zero values are returned.

📝 Syntax

advanced

Identify the syntax error with named return values

Which option contains a syntax error in this Go function with named return values?

Go

func example() (a int, b int) {
	a = 1
	b = 2
	return
}

A func example() (a int, b int) { a := 1; b := 2; return }

B func example() (a int, b int) { a = 1; b = 2; return }

C func example() (a int, b int) { a, b = 1, 2; return }

D func example() (a int, b int) { a = 1; b = 2; return a, b }

💡 Hint

Check variable declaration and assignment rules with named return values.

Option A uses ':=' to declare a and b inside the function, but a and b are already declared as named return values. Using ':=' redeclares them locally, which is not allowed here and causes a syntax error.

🚀 Application

expert

How many items are in the returned map from this function?

Consider this Go function that returns a map using named return values. How many key-value pairs does the returned map contain?

Go

func createMap() (result map[string]int) {
	result = make(map[string]int)
	for i := 0; i < 3; i++ {
		result[string('a'+i)] = i
	}
	return
}

A Compilation error

B 0

C 1

D 3

💡 Hint

The loop adds keys 'a', 'b', 'c' with values 0,1,2 to the map.

The function initializes an empty map and adds three entries with keys 'a', 'b', 'c' and values 0,1,2. So the map contains 3 key-value pairs.

Practice

1. What is the main benefit of using named return values in Go functions?

easy

A. They prevent the function from returning any value.

B. They allow returning multiple values without specifying types.

C. They automatically convert return types to strings.

D. They make the function's return values easier to understand and use.

Solution

1. Step 1: Understand named return values

   Named return values give explicit names to the outputs of a function, making it clear what each returned value represents.

2. Step 2: Identify the benefit

   Because the return values are named, the code becomes easier to read and understand, especially when returning multiple values.

3. Final Answer:

   They make the function's return values easier to understand and use. -> Option D

4. Quick Check:

   Named return values improve readability = D [OK]

Hint: Named returns clarify output meaning quickly [OK]

Common Mistakes:

• Thinking named returns change return types
• Believing named returns prevent returning values
• Confusing named returns with automatic type conversion

2. Which of the following Go function signatures correctly uses named return values?

easy

A. func add(a, b int) (int sum) { return a + b }

B. func add(a, b int) int sum { return a + b }

C. func add(a, b int) (sum int) { return a + b }

D. func add(a, b int) sum int { return a + b }

Solution

1. Step 1: Check syntax for named return values

   Named return values are declared inside parentheses with the type after the name, like (sum int).

2. Step 2: Identify correct syntax

   func add(a, b int) (sum int) { return a + b } uses (sum int) correctly. Options B, C, and D have incorrect syntax for named returns.

3. Final Answer:

   func add(a, b int) (sum int) { return a + b } -> Option C

4. Quick Check:

   Named returns syntax = (name type) [OK]

Hint: Named returns use (name type) inside parentheses [OK]

Common Mistakes:

• Placing type before name in return signature
• Omitting parentheses around return values
• Using invalid order like 'int sum'

3. What will be the output of this Go program?

package main
import "fmt"
func divide(a, b int) (result int, err string) {
    if b == 0 {
        err = "division by zero"
        return
    }
    result = a / b
    return
}
func main() {
    r, e := divide(10, 0)
    fmt.Println(r, e)
}

medium

A. 10 division by zero

B. 0 division by zero

C. 0

D. Runtime error

Solution

1. Step 1: Analyze divide function behavior

   If b is zero, err is set to "division by zero" and function returns immediately. result is not set, so defaults to zero.

2. Step 2: Check main function output

   Calling divide(10, 0) returns result=0 and err="division by zero". fmt.Println prints both separated by space.

3. Final Answer:

   0 division by zero -> Option B

4. Quick Check:

   Named returns default zero + error string = A [OK]

Hint: Named returns default zero values if not set [OK]

Common Mistakes:

• Expecting result to be 10 when dividing by zero
• Assuming runtime error instead of handled error string
• Forgetting named returns default zero values

4. Which of the following best improves this Go function using named return values:

func multiply(a, b int) (product int) {
    product = a * b
    return product
}

medium

A. The return statement should be just 'return' without specifying 'product'.

B. The function must return two values, not one.

C. Named return values cannot be assigned inside the function.

D. The function should not have a return statement.

Solution

1. Step 1: Understand named return values usage

   When using named return values, you can simply use 'return' without arguments to return the named variables.

2. Step 2: Identify the improvement in return statement

   Here, 'return product' is allowed but redundant. The idiomatic way is just 'return' to return named values.

3. Final Answer:

   The return statement should be just 'return' without specifying 'product'. -> Option A

4. Quick Check:

   Named returns allow bare 'return' [OK]

Hint: Use bare 'return' with named return values [OK]

Common Mistakes:

• Returning named variable explicitly instead of bare return
• Thinking named returns require multiple return values
• Believing assignment to named returns is disallowed

5. Given this Go function with named return values, what will be the output?

package main
import "fmt"
func stats(nums []int) (sum, count int) {
    for _, n := range nums {
        if n > 0 {
            sum += n
            count++
        }
    }
    return
}
func main() {
    s, c := stats([]int{3, -1, 0, 4, 5})
    fmt.Printf("Sum: %d, Count: %d\n", s, c)
}

hard

A. Sum: 12, Count: 3

B. Sum: 12, Count: 5

C. Sum: 0, Count: 0

D. Sum: 3, Count: 1

Solution

1. Step 1: Analyze the loop filtering positive numbers

   The function loops over nums and adds only positive numbers to sum and increments count.

2. Step 2: Calculate sum and count for given slice

   Positive numbers are 3, 4, 5. Sum = 3+4+5=12, Count = 3.

3. Final Answer:

   Sum: 12, Count: 3 -> Option A

4. Quick Check:

   Sum positive nums = 12, Count positive nums = 3 [OK]

Hint: Named returns can be returned bare after assignment [OK]

Common Mistakes:

• Including zero or negative numbers in sum and count
• Forgetting to return named values
• Miscounting positive numbers in slice