Relational operators in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of chained relational operators in Go

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
    a := 5
    b := 10
    c := 15
    fmt.Println(a < b && b < c)
    fmt.Println(a > b || b < c)
    fmt.Println(!(a == 5))
}

A

true
true
false

B

false
true
true

C

true
false
false

D

false
false
true

💡 Hint

Remember && means AND, || means OR, and ! means NOT.

The first line checks if 5 is less than 10 AND 10 is less than 15, both true, so true.

The second line checks if 5 is greater than 10 OR 10 is less than 15, second is true, so true.

The third line negates if 5 equals 5, which is true, so negation is false.

❓ Predict Output

intermediate

Comparing strings with relational operators

What is the output of this Go code snippet?

Go

package main
import "fmt"
func main() {
    s1 := "apple"
    s2 := "banana"
    fmt.Println(s1 < s2)
    fmt.Println(s1 == s2)
    fmt.Println(s1 > s2)
}

A

true
false
false

B

false
true
false

C

false
false
true

D

true
true
false

💡 Hint

Strings are compared lexicographically (dictionary order).

"apple" is lexicographically less than "banana", so first is true.

They are not equal, so second is false.

"apple" is not greater than "banana", so third is false.

❓ Predict Output

advanced

Output of relational operators with mixed types

What error or output does this Go program produce?

Go

package main
import "fmt"
func main() {
    var x int = 10
    var y float64 = 10.0
    fmt.Println(x == y)
}

A true

B false

C cannot use y (type float64) as type int in comparison

D compilation error: mismatched types int and float64

💡 Hint

Go is strict about comparing different types.

Go does not allow direct comparison between int and float64 types, causing a compilation error.

❓ Predict Output

advanced

Relational operators with structs

What happens when you run this Go code?

Go

package main
import "fmt"
func main() {
    type Point struct { x, y int }
    p1 := Point{1, 2}
    p2 := Point{1, 2}
    fmt.Println(p1 == p2)
    fmt.Println(p1 != p2)
}

A

false
true

B compilation error: invalid operation: p1 == p2 (struct containing uncomparable fields)

C

true
false

D runtime panic

💡 Hint

Structs can be compared if all their fields are comparable.

Both p1 and p2 have the same values, so p1 == p2 is true and p1 != p2 is false.

🧠 Conceptual

expert

Relational operator behavior with nil interfaces

What is the output of this Go program?

Go

package main
import "fmt"
func main() {
    var p *int = nil
    var i interface{} = p
    fmt.Println(i == nil)
    fmt.Println(p == nil)
}

A

true
true

B

false
true

C

false
false

D

true
false

💡 Hint

An interface holding a nil pointer is not itself nil.

The interface i holds a nil value but is not itself nil, so i == nil is false.

The pointer p is nil, so p == nil is true.