Relational operators in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if a is less than b.

Go

package main
import "fmt"
func main() {
    a := 5
    b := 10
    if a [1] b {
        fmt.Println("a is less than b")
    }
}

Drag options to blanks, or click blank then click option'

A==

B>

C!=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of < will check equality, not less than.

The < operator checks if the left value is less than the right value.

2fill in blank

medium

Complete the code to check if x is not equal to y.

Go

package main
import "fmt"
func main() {
    x := 7
    y := 3
    if x [1] y {
        fmt.Println("x is not equal to y")
    }
}

Drag options to blanks, or click blank then click option'

A!=

B==

C<=

D>=

Attempts:

3 left

💡 Hint

Common Mistakes

Using == will check if values are equal, not different.

The != operator checks if two values are not equal.

3fill in blank

hard

Fix the error in the code to check if num is greater than or equal to 100.

Go

package main
import "fmt"
func main() {
    num := 150
    if num [1] 100 {
        fmt.Println("num is at least 100")
    }
}

Drag options to blanks, or click blank then click option'

A<

B>=

C==

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using > alone misses the 'equal to' part.

The >= operator checks if the left value is greater than or equal to the right value.

4fill in blank

hard

Fill both blanks to create a map of words to their lengths, including only words longer than 3 characters.

Go

package main
import "fmt"
func main() {
    words := []string{"go", "code", "fun", "learn"}
    lengths := map[string]int{}
    for _, word := range words {
        if len(word) > 3 {
            lengths[[1]] = len([2])
        }
    }
    fmt.Println(lengths)
}

Drag options to blanks, or click blank then click option'

Aword

Bwords

Clen

Dwordlen

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'words' instead of 'word' causes errors because 'words' is the whole list.

We use the variable 'word' as the key and inside len() to get the length of each word.

5fill in blank

hard

Fill all three blanks to create a map of uppercase words to their lengths, including only words longer than 3 characters.

Go

package main
import (
    "fmt"
    "strings"
)
func main() {
    words := []string{"go", "code", "fun", "learn"}
    lengths := map[string]int{}
    for _, word := range words {
        if len(word) [3] 3 {
            lengths[[1]] = [2]
        }
    }
    fmt.Println(lengths)
}

Drag options to blanks, or click blank then click option'

Astrings.ToUpper(word)

Blen(word)

C>

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'word' instead of uppercase word as key.

Using < instead of > in the condition.

The key is the uppercase word, the value is the length, and the condition checks if length is greater than 3.

Practice

1. Which of the following relational operators in Go checks if two values are equal?

easy

A. >

B. !=

C. ==

D. <=

Solution

1. Step 1: Understand the meaning of relational operators

   Relational operators compare two values and return true or false based on the comparison.

2. Step 2: Identify the operator for equality

   The operator '==' checks if two values are equal in Go.

3. Final Answer:

   == -> Option C

4. Quick Check:

   Equality operator = == [OK]

Hint: Remember: double equals (==) means equal in Go [OK]

Common Mistakes:

• Confusing '=' (assignment) with '==' (equality)
• Using '!=' for equality check
• Thinking '>' means equal

2. Which of the following is the correct syntax to check if variable a is not equal to variable b in Go?

easy

A. a !== b

B. a <> b

C. a =! b

D. a != b

Solution

1. Step 1: Recall Go syntax for not equal operator

   In Go, the not equal operator is written as '!='.

2. Step 2: Match the syntax with the options

   a != b uses 'a != b', which is correct syntax for not equal in Go.

3. Final Answer:

   a != b -> Option D

4. Quick Check:

   Not equal operator = != [OK]

Hint: Not equal in Go is always '!=' not '<>' or '!==' [OK]

Common Mistakes:

• Using '<>' which is not valid in Go
• Swapping '=' and '!' to '=!'
• Using JavaScript style '!==' which is invalid in Go

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

package main
import "fmt"
func main() {
    x := 10
    y := 20
    fmt.Println(x > y)
}

medium

A. false

B. 10

C. true

D. Compilation error

Solution

1. Step 1: Understand the comparison x > y

   Variable x is 10 and y is 20. The expression checks if 10 is greater than 20.

2. Step 2: Evaluate the expression

   Since 10 is not greater than 20, the expression evaluates to false.

3. Final Answer:

   false -> Option A

4. Quick Check:

   10 > 20 = false [OK]

Hint: Compare values carefully; 10 > 20 is false [OK]

Common Mistakes:

• Assuming 10 > 20 is true
• Confusing output with variable values
• Expecting a number instead of boolean

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

package main
import "fmt"
func main() {
    a := 5
    b := 10
    if a = b {
        fmt.Println("Equal")
    }
}

medium

A. Variables 'a' and 'b' are not declared properly

B. The '=' operator is used instead of '==' in the if condition

C. Missing parentheses around the if condition

D. fmt.Println syntax is incorrect

Solution

1. Step 1: Check the if condition syntax

   The condition uses 'a = b' which is an assignment, not a comparison.

2. Step 2: Correct the operator for comparison

   To compare values, '==' must be used instead of '='.

3. Final Answer:

   The '=' operator is used instead of '==' in the if condition -> Option B

4. Quick Check:

   Use '==' for comparison, not '=' [OK]

Hint: Use '==' to compare, '=' only assigns [OK]

Common Mistakes:

• Using '=' instead of '==' in conditions
• Thinking parentheses are mandatory in Go if
• Assuming fmt.Println syntax is wrong

5. Given the following Go code, what will be the output?

package main
import "fmt"
func main() {
    a := 15
    b := 15
    c := 20
    result := (a == b) && (c > b)
    fmt.Println(result)
}

hard

A. true

B. false

C. Compilation error

D. 15

Solution

1. Step 1: Evaluate the first comparison (a == b)

   Both a and b are 15, so (a == b) is true.

2. Step 2: Evaluate the second comparison (c > b)

   c is 20 and b is 15, so (c > b) is true.

3. Step 3: Combine with logical AND

   Both conditions are true, so true && true is true.

4. Final Answer:

   true -> Option A

5. Quick Check:

   (15 == 15) && (20 > 15) = true [OK]

Hint: Both conditions true? Result is true [OK]

Common Mistakes:

• Confusing && with || operator
• Thinking one true means overall false
• Expecting numeric output instead of boolean