Struct usage patterns in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of embedded struct field access

What is the output of this Go program?

Go

package main
import "fmt"
type Address struct {
    City string
}
type Person struct {
    Name string
    Address
}
func main() {
    p := Person{Name: "Alice", Address: Address{City: "Paris"}}
    fmt.Println(p.City)
}

A Paris

B Compilation error: ambiguous selector

C Runtime panic

D Empty string

💡 Hint

Embedded structs allow direct access to their fields.

In Go, embedding a struct allows you to access its fields directly from the outer struct. Here, p.City accesses Address.City.

❓ Predict Output

intermediate

Output of struct pointer modification

What will be printed by this Go program?

Go

package main
import "fmt"
type Counter struct {
    Count int
}
func (c *Counter) Increment() {
    c.Count++
}
func main() {
    c := Counter{Count: 5}
    c.Increment()
    fmt.Println(c.Count)
}

A Compilation error: cannot call pointer method on value

B 5

C 6

D Runtime panic

💡 Hint

Pointer receiver methods can be called on values; Go handles the address automatically.

Go automatically takes the address of c to call the pointer receiver method Increment, which increments Count from 5 to 6.

🔧 Debug

advanced

Identify the cause of compilation error

This Go code fails to compile. What is the cause?

Go

package main
import "fmt"
type Data struct {
    value int
}
func main() {
    d := Data{value: 10}
    fmt.Println(d.Value)
}

A Missing import for fmt package

B Variable d is not initialized

C Cannot print struct field directly

D Field 'Value' does not exist; Go is case-sensitive

💡 Hint

Check the exact spelling and capitalization of struct fields.

Go is case-sensitive. The struct field is named 'value' (lowercase), but the code tries to access 'Value' (uppercase), causing a compilation error.

🧠 Conceptual

advanced

Effect of struct value vs pointer receiver on method behavior

Consider a struct with two methods: one with a value receiver and one with a pointer receiver. Which statement is true about their behavior when called on a struct value?

A Both methods modify the original struct

B The pointer receiver method can modify the original struct; the value receiver method works on a copy

C Neither method can modify the original struct

D Value receiver methods require explicit pointer conversion to be called

💡 Hint

Think about how Go passes the struct to each method type.

Value receiver methods get a copy of the struct, so changes do not affect the original. Pointer receiver methods get the address and can modify the original struct.

❓ Predict Output

expert

Output of struct embedding with method overriding

What is the output of this Go program?

Go

package main
import "fmt"
type Animal struct {}
func (a Animal) Speak() string {
    return "..."
}
type Dog struct {
    Animal
}
func (d Dog) Speak() string {
    return "Woof!"
}
func main() {
    var a Animal = Dog{}
    fmt.Println(a.Speak())
}

A ...

B Woof!

C Compilation error: cannot assign Dog to Animal

D Runtime panic

💡 Hint

Consider how method sets and interface assignments work in Go.

The variable 'a' is of type Animal, not an interface. Assigning Dog{} to Animal slices off the Dog part, so calling Speak calls Animal's method, printing "...".

Practice

1. What is the primary purpose of using a struct in Go?

easy

A. To group related data with named fields

B. To perform arithmetic operations

C. To create loops

D. To handle errors

Solution

1. Step 1: Understand the role of structs

   Structs are used to group related data together in one unit with named fields.

2. Step 2: Compare with other options

   Arithmetic, loops, and error handling are not the main purposes of structs.

3. Final Answer:

   To group related data with named fields -> Option A

4. Quick Check:

   Structs = Group related data [OK]

Hint: Structs group data fields logically [OK]

Common Mistakes:

• Thinking structs are for control flow
• Confusing structs with functions
• Assuming structs handle errors

2. Which of the following is the correct way to declare a struct type named Person with fields Name (string) and Age (int)?

easy

A. Person := struct { Name string; Age int }

B. struct Person { Name string; Age int }

C. var Person struct Name string; Age int

D. type Person struct { Name string; Age int }

Solution

1. Step 1: Recall Go struct declaration syntax

   In Go, a struct type is declared with the keyword type, followed by the name, then struct and fields inside braces.

2. Step 2: Check each option

   type Person struct { Name string; Age int } matches the correct syntax. struct Person { Name string; Age int } misses type. Person := struct { Name string; Age int } uses := which is for variables, not type declaration. var Person struct Name string; Age int is invalid syntax.

3. Final Answer:

   type Person struct { Name string; Age int } -> Option D

4. Quick Check:

   Struct declaration uses 'type Name struct { fields }' [OK]

Hint: Use 'type Name struct { fields }' to declare structs [OK]

Common Mistakes:

• Omitting 'type' keyword
• Using := for type declaration
• Incorrect field syntax

3. What will be the output of the following Go code?

type Point struct {
  X int
  Y int
}

func main() {
  p := Point{X: 3, Y: 4}
  p.X = 10
  fmt.Println(p.X, p.Y)
}

medium

A. 10 4

B. 3 4

C. 10 0

D. 0 4

Solution

1. Step 1: Understand struct initialization and modification

   The struct Point is initialized with X=3 and Y=4. Then p.X is changed to 10.

2. Step 2: Determine printed values

   After modification, p.X is 10 and p.Y remains 4. So printing p.X and p.Y outputs '10 4'.

3. Final Answer:

   10 4 -> Option A

4. Quick Check:

   Modified field prints updated value [OK]

Hint: Changing struct fields updates their values [OK]

Common Mistakes:

• Assuming original values stay after assignment
• Confusing field names
• Forgetting to import fmt (not shown here)

4. Identify the error in the following Go code snippet:

type Car struct {
  Brand string
  Year  int
}

func main() {
  c := Car{Brand: "Toyota", Year: "2020"}
  fmt.Println(c)
}

medium

A. Missing semicolon after struct declaration

B. Year field assigned a string instead of int

C. Incorrect struct name capitalization

D. fmt.Println cannot print structs

Solution

1. Step 1: Check field types in struct literal

   The struct Car has Year as int, but the code assigns "2020" (a string) to Year.

2. Step 2: Verify other options

   Semicolons are optional in Go. Struct name capitalization is fine. fmt.Println can print structs.

3. Final Answer:

   Year field assigned a string instead of int -> Option B

4. Quick Check:

   Field types must match assigned values [OK]

Hint: Match struct field types exactly when assigning [OK]

Common Mistakes:

• Assigning wrong data types to fields
• Thinking semicolons are mandatory
• Assuming fmt.Println can't print structs

5. Given a struct type Employee with fields Name (string), Salary (int), and Active (bool), which code snippet correctly creates a slice of active employees with salary over 50000 from a given slice emps?

hard

A. filtered := make([]Employee, 0)
for _, e := range emps {
if e.Active || e.Salary > 50000 {
filtered = append(filtered, e)
}
}

B. filtered := []Employee{}
for i := 0; i < len(emps); i++ {
if emps[i].Salary > 50000 {
filtered = append(filtered, emps[i])
}
}

C. var filtered []Employee
for _, e := range emps {
if e.Active && e.Salary > 50000 {
filtered = append(filtered, e)
}
}

D. filtered := []Employee{}
for _, e := range emps {
if e.Active && e.Salary < 50000 {
filtered = append(filtered, e)
}
}

Solution

1. Step 1: Understand filtering conditions

   We want employees who are active AND have salary greater than 50000.

2. Step 2: Analyze each option's condition

   var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } uses correct AND condition. filtered := []Employee{} for i := 0; i < len(emps); i++ { if emps[i].Salary > 50000 { filtered = append(filtered, emps[i]) } } misses Active check. filtered := make([]Employee, 0) for _, e := range emps { if e.Active || e.Salary > 50000 { filtered = append(filtered, e) } } uses OR instead of AND. filtered := []Employee{} for _, e := range emps { if e.Active && e.Salary < 50000 { filtered = append(filtered, e) } } uses salary less than 50000, which is wrong.

3. Final Answer:

   var filtered []Employee for _, e := range emps { if e.Active && e.Salary > 50000 { filtered = append(filtered, e) } } -> Option C

4. Quick Check:

   Use AND (&&) for combined conditions [OK]

Hint: Use && to combine multiple filter conditions [OK]

Common Mistakes:

• Using || instead of && for filtering
• Ignoring one of the filter conditions
• Filtering with wrong comparison operators