Type inference in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go code using type inference?

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

Go

package main
import "fmt"
func main() {
    x := 10
    y := 3.5
    z := x + int(y)
    fmt.Println(z)
}

A Error: cannot add int and float64

B 13.5

C 10

D 13

💡 Hint

Remember Go requires explicit conversion between int and float64 types.

In Go, you cannot add int and float64 directly. The float64 y is converted to int before addition, so 3.5 becomes 3, and 10 + 3 = 13.

❓ Predict Output

intermediate

What is the type of variable 'a' inferred by Go?

Look at this Go code snippet. What is the inferred type of variable 'a'?

Go

package main
func main() {
    a := 'G'
}

A rune

B string

C int

D byte

💡 Hint

Single quotes in Go denote a rune literal.

In Go, single quotes denote a rune literal, which is an alias for int32. So 'G' is of type rune.

🔧 Debug

advanced

Why does this Go code cause a compilation error?

Examine the code below. Why does it fail to compile?

Go

package main
func main() {
    var x = 5
    x = "hello"
}

A Variable x is not declared

B Missing semicolon after variable declaration

C Cannot assign string to variable x of inferred type int

D Cannot assign int to string variable

💡 Hint

Check the type inferred for x and what value is assigned later.

Variable x is inferred as int from the initial value 5. Assigning a string "hello" to it later causes a type mismatch error.

❓ Predict Output

advanced

What is the output of this Go code using type inference with constants?

What will this Go program print?

Go

package main
import "fmt"
func main() {
    const pi = 3.14
    radius := 5
    area := pi * float64(radius) * float64(radius)
    fmt.Printf("%.2f", area)
}

A 78.50

B 78

C Error: cannot convert radius to float64

D 15.7

💡 Hint

Look at how radius is converted before multiplication.

radius is int, converted to float64 for multiplication with pi (a constant float64). The area is 3.14 * 5 * 5 = 78.5, printed with two decimals.

🧠 Conceptual

expert

Which statement about Go's type inference is true?

Select the correct statement about how Go infers types for variables declared with ':='.

A Go allows the variable type to change dynamically at runtime based on assigned values.

B Go infers the variable type from the right-hand side expression at compile time and it cannot change later.

C Go infers the variable type as interface{} by default when using ':='.

D Go requires explicit type annotations even when using ':='.

💡 Hint

Think about static typing and how ':=' works in Go.

Go is statically typed. When using ':=', the compiler infers the type from the initial value and the variable's type cannot change later.

Practice

1. What does type inference mean in Go when you write x := 10 inside a function?

easy

A. You must tell Go the type of x explicitly.

B. Go automatically figures out that x is an int.

C. Go treats x as a string by default.

D. The variable x has no type.

Solution

1. Step 1: Understand the := operator in Go

   The := operator declares a variable and assigns a value, letting Go guess the type.

2. Step 2: Check the assigned value type

   Since 10 is an integer, Go infers the type of x as int automatically.

3. Final Answer:

   Go automatically figures out that x is an int. -> Option B

4. Quick Check:

   Type inference means Go guesses type from value [OK]

Hint: := means declare and infer type from value [OK]

Common Mistakes:

• Thinking you must always write the type explicitly
• Assuming variables have no type
• Believing Go defaults to string type

2. Which of the following is the correct way to declare and assign a variable with type inference inside a function in Go?

easy

A. x := 5

B. x = 5

C. var x int = 5

D. int x = 5

Solution

1. Step 1: Recall Go syntax for type inference

   Inside functions, := declares and assigns a variable with inferred type.

2. Step 2: Check each option

   var x int = 5 declares with explicit type, not inference. x = 5 misses declaration. int x = 5 is invalid Go syntax.

3. Final Answer:

   x := 5 -> Option A

4. Quick Check:

   Use := to declare and infer type [OK]

Hint: Use := inside functions for type inference [OK]

Common Mistakes:

• Using C or D which are invalid Go syntax
• Forgetting to declare variable before assignment
• Confusing var declaration with :=

3. What is the output of this Go program?

package main
import "fmt"
func main() {
    x := 3.14
    fmt.Printf("%T", x)
}

medium

A. float64

B. float32

C. int

D. string

Solution

1. Step 1: Identify the type inferred for 3.14

   In Go, untyped floating-point constants default to float64 when assigned with :=.

2. Step 2: Understand fmt.Printf with %T

   The %T verb prints the type of the variable, so it will print "float64".

3. Final Answer:

   float64 -> Option A

4. Quick Check:

   Float literals default to float64 [OK]

Hint: Float literals default to float64 type [OK]

Common Mistakes:

• Assuming float32 is default
• Thinking 3.14 is int
• Confusing %T output with value

4. What is wrong with this Go code snippet?

func main() {
    var x := 10
    fmt.Println(x)
}

medium

A. The value 10 is not a valid integer.

B. x is not declared before use.

C. You cannot use := with var keyword.

D. fmt.Println is not imported.

Solution

1. Step 1: Understand variable declaration syntax

   In Go, := is shorthand for declaration and assignment without var keyword.

2. Step 2: Identify the syntax error

   Using var and := together is invalid syntax; you must use either var x = 10 or x := 10.

3. Final Answer:

   You cannot use := with var keyword. -> Option C

4. Quick Check:

   var and := cannot be combined [OK]

Hint: Don't combine var and := in one statement [OK]

Common Mistakes:

• Mixing var and := together
• Ignoring import errors (not shown here)
• Thinking := works outside functions

5. Given this Go code, what is the type of result after execution?

func main() {
    a := 5
    b := 2.0
    result := a * int(b)
    fmt.Printf("%T", result)
}

hard

A. float64

B. string

C. float32

D. int

Solution

1. Step 1: Analyze variable types and conversion

   a is int, b is float64 (default for 2.0). The expression converts b to int before multiplication.

2. Step 2: Determine result type

   Multiplying int (a) by int (converted b) results in int type for result.

3. Final Answer:

   int -> Option D

4. Quick Check:

   int * int = int type [OK]

Hint: Type conversion affects result type [OK]

Common Mistakes:

• Assuming result is float64 without conversion
• Forgetting to convert float to int
• Confusing multiplication type rules