String Traversal and Character Access in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does string traversal mean?

String traversal means going through each character in a string one by one, from start to end.

beginner

How do you access the first character of a string in Go?

You can access the first character by using index 0, like this: s[0]. It gives the byte value of the character.

intermediate

Why should you be careful when accessing characters in a string with non-ASCII characters in Go?

Because Go strings are byte slices, accessing by index gives bytes, not characters. Non-ASCII characters may use multiple bytes, so direct indexing can break characters.

beginner

What Go language feature helps safely traverse Unicode characters in a string?

Using a for-range loop on a string lets you safely traverse Unicode characters (runes) one by one.

intermediate

What is the difference between a byte and a rune in Go strings?

A byte is 8 bits and represents raw data. A rune is an alias for int32 and represents a Unicode code point (a character).

In Go, what does s[0] return when s is a string?

A The first Unicode character (rune)

B The length of the string

C The first byte of the string

D An error

s[0] returns the first byte, not necessarily the first character if the string contains multi-byte Unicode characters.

Which Go loop safely iterates over Unicode characters in a string?

A for _, r := range s

B do-while loop

C while loop

D for i := 0; i < len(s); i++

The for-range loop (for _, r := range s) iterates over runes, handling multi-byte characters correctly.

What type is used in Go to represent a Unicode character?

A rune

B int

C byte

D string

A rune is an alias for int32 and represents a Unicode code point.

What happens if you access a multi-byte character in a string by index in Go?

A You get the full character

B You get the first byte of that character

C You get an error

D The program crashes

Indexing returns a byte, so for multi-byte characters you get only the first byte, which may not represent the full character.

How can you convert a rune to a string in Go?

A byte(runeValue)

B int(runeValue)

C runeValue.toString()

D string(runeValue)

Casting a rune to string converts the Unicode code point to a string.

Explain how to safely traverse a string with Unicode characters in Go and why direct indexing might be unsafe.

Think about how Go stores strings and how for-range helps.

Describe the difference between accessing a string character by index and using a for-range loop in Go.

Consider what each method returns and how it affects Unicode characters.

Practice

1. What does the expression len(s) return when s is a string in Go?

easy

A. The first character of the string

B. The number of characters (runes) in the string

C. The last character of the string

D. The number of bytes in the string

Solution

1. Step 1: Understand what len does on strings in Go

   In Go, len(s) returns the number of bytes, not characters, because strings are byte slices.

2. Step 2: Differentiate bytes and characters

   Characters (runes) can be multiple bytes, so len counts bytes, not runes.

3. Final Answer:

   The number of bytes in the string -> Option D

4. Quick Check:

   len(s) = bytes count [OK]

Hint: Remember: len counts bytes, not characters in Go strings [OK]

Common Mistakes:

• Thinking len counts characters (runes)
• Confusing bytes with characters
• Assuming len returns a character

2. Which of the following is the correct way to access the third character of a string s in Go?

easy

A. s[3]

B. s[2]

C. s.charAt(2)

D. s.get(2)

Solution

1. Step 1: Recall Go string indexing

   Go strings can be indexed like byte slices, starting at 0, so the third character is at index 2.

2. Step 2: Check syntax options

   Only s[2] is valid Go syntax for accessing a byte at index 2.

3. Final Answer:

   s[2] -> Option B

4. Quick Check:

   Indexing starts at 0, third char = s[2] [OK]

Hint: Indexing starts at 0; third char is s[2] in Go [OK]

Common Mistakes:

• Using 1-based indexing like s[3]
• Using methods like charAt or get which don't exist in Go
• Confusing bytes with runes

3. What is the output of the following Go code?

package main
import "fmt"
func main() {
  s := "GoLang"
  fmt.Println(string(s[1]))
}

medium

A. o

B. G

C. 1

D. Syntax error

Solution

1. Step 1: Identify the character at index 1

   String "GoLang" indexed at 1 is byte for 'o'.

2. Step 2: Convert byte to string for printing

   Using string(s[1]) converts byte 'o' to string "o".

3. Final Answer:

   o -> Option A

4. Quick Check:

   s[1] = 'o' printed as string [OK]

Hint: s[index] gives byte; convert to string to print char [OK]

Common Mistakes:

• Printing byte as number instead of string
• Confusing index 1 with 0
• Expecting syntax error

4. What is wrong with this Go code snippet?

package main
import "fmt"
func main() {
  s := "hello"
  for i := 0; i <= len(s); i++ {
    fmt.Printf("%c", s[i])
  }
}

medium

A. Loop condition causes index out of range error

B. fmt.Printf format specifier is incorrect

C. String s is not initialized properly

D. for loop syntax is invalid

Solution

1. Step 1: Analyze loop range

   The loop runs from i=0 to i=len(s) inclusive, but valid indices are 0 to len(s)-1.

2. Step 2: Identify error cause

   At i=len(s), s[i] causes index out of range runtime error.

3. Final Answer:

   Loop condition causes index out of range error -> Option A

4. Quick Check:

   Index must be less than len(s) [OK]

Hint: Loop index must be < len(s), not <= len(s) [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Ignoring runtime index out of range error
• Misunderstanding string indexing

5. Given a string s containing Unicode characters, which Go code snippet correctly prints each character (rune) on a new line?

hard

A. for i := 0; i < len(s); i++ { fmt.Println(string(s[i])) }

B. for i := range s { fmt.Println(s[i]) }

C. for _, r := range s { fmt.Println(string(r)) }

D. for i := 0; i <= len(s); i++ { fmt.Println(s[i]) }

Solution

1. Step 1: Understand Unicode handling in Go strings

   Go strings are byte slices; indexing gives bytes, not runes. To get runes, use range loop.

2. Step 2: Check each option

   for _, r := range s { fmt.Println(string(r)) } uses for _, r := range s which iterates runes correctly and prints each rune as string.

3. Final Answer:

   for _, r := range s { fmt.Println(string(r)) } -> Option C

4. Quick Check:

   Use range to iterate runes in string [OK]

Hint: Use range loop to get runes, not byte indexing [OK]

Common Mistakes:

• Using byte indexing for Unicode characters
• Looping with <= len(s)
• Printing bytes directly without conversion