Function execution flow in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program?

Consider the following Go code. What will it print when run?

Go

package main
import "fmt"

func foo() int {
    fmt.Println("foo start")
    defer fmt.Println("foo defer")
    fmt.Println("foo end")
    return 1
}

func main() {
    fmt.Println("main start")
    result := foo()
    fmt.Println("result:", result)
    fmt.Println("main end")
}

A

main start
foo start
foo defer
foo end
result: 1
main end

B

main start
foo start
foo end
foo defer
result: 1
main end

C

main start
foo start
foo end
result: 1
foo defer
main end

D

main start
foo start
foo defer
result: 1
foo end
main end

💡 Hint

Remember that deferred functions run after the surrounding function returns but before it fully exits.

The function foo prints "foo start", then "foo end", then returns 1. The deferred print "foo defer" runs after the return statement but before foo fully exits. So the order inside foo is: start, end, defer. The main function prints before and after calling foo.

❓ Predict Output

intermediate

What is the output of this recursive function?

What will this Go program print?

Go

package main
import "fmt"

func countdown(n int) {
    if n == 0 {
        fmt.Println("Blastoff!")
        return
    }
    fmt.Println(n)
    countdown(n - 1)
}

func main() {
    countdown(3)
}

A

3
2
1
0
Blastoff!

B

3
2
1

C

Blastoff!
1
2
3

D

3
2
1
Blastoff!

💡 Hint

Think about the order of prints and when the function returns.

The function prints the current number, then calls itself with one less. When it reaches zero, it prints "Blastoff!" and returns. So the numbers print in descending order, then "Blastoff!".

🔧 Debug

advanced

Why does this Go program cause a runtime panic?

Examine the code below. Why does it panic at runtime?

Go

package main
import "fmt"

func main() {
    var f func()
    f()
    fmt.Println("Done")
}

A Because the function variable f is nil and calling it causes a panic.

B Because the function f is declared but never defined, causing a compile error.

C Because fmt.Println is called after f(), which is invalid syntax.

D Because main function must return a value in Go.

💡 Hint

Think about what happens when you call a function variable that has not been assigned.

The variable f is declared as a function type but is not assigned any function. Calling f() tries to call a nil function pointer, which causes a runtime panic.

📝 Syntax

advanced

Which option correctly defines and calls an anonymous function in Go?

Which code snippet correctly defines and immediately calls an anonymous function that prints "Hello"?

A func() { fmt.Println("Hello") }

B func { fmt.Println("Hello") }()

C func() { fmt.Println("Hello") }()

D func() => { fmt.Println("Hello") }()

💡 Hint

Anonymous functions need parentheses after their definition to be called immediately.

Option C correctly defines an anonymous function and immediately calls it with (). Option C is missing parentheses after func. Option C defines the function but does not call it. Option C uses invalid syntax.

🚀 Application

expert

What is the final value of x after this function call sequence?

Given the code below, what is the value of x after modify(&x) is called?

Go

package main
import "fmt"

func modify(p *int) {
    *p += 10
    defer func() {
        *p *= 2
    }()
    *p += 5
}

func main() {
    x := 5
    modify(&x)
    fmt.Println(x)
}

A 40

B 30

C 20

D 25

💡 Hint

Remember that deferred functions run after the surrounding function returns.

Inside modify, *p starts at 5. Then *p += 10 makes it 15. Then *p += 5 makes it 20. The deferred function runs after modify returns and doubles *p to 40.