String Reversal Approaches in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the simplest way to reverse a string in Go using built-in functions?

Convert the string to a slice of runes, reverse the slice, then convert it back to a string. This handles multi-byte characters correctly.

beginner

Why should you convert a string to a rune slice before reversing in Go?

Because Go strings are UTF-8 encoded, and characters can be multiple bytes. Reversing bytes directly can break characters. Runes represent Unicode code points safely.

intermediate

Explain the two-pointer approach to reverse a string.

Use two pointers: one at the start and one at the end of the rune slice. Swap the runes at these pointers and move them towards the center until they meet or cross.

beginner

What is a common mistake when reversing strings in languages like Go?

Reversing the string byte-by-byte without considering multi-byte characters, which can corrupt Unicode characters.

intermediate

How can recursion be used to reverse a string?

Recursively call the function with the substring excluding the first character, then append the first character at the end until the base case (empty string) is reached.

In Go, what type should you convert a string to before reversing to handle Unicode correctly?

A []byte

B []int

C []rune

D string

Converting to []rune ensures each Unicode character is treated as a single element, avoiding corruption.

What does the two-pointer technique do when reversing a string?

A Swaps characters from start and end moving inward

B Uses recursion to reverse the string

C Converts string to bytes and reverses

D Appends characters to a new string in order

Two pointers start at opposite ends and swap characters moving towards the center.

Why is reversing a string byte-by-byte in Go risky?

A It only works for ASCII

B It is slower than rune reversal

C It uses more memory

D It can break multi-byte Unicode characters

UTF-8 characters can be multiple bytes; reversing bytes can corrupt characters.

Which approach is NOT commonly used to reverse strings?

A Two-pointer swapping

B Sorting characters

C Using built-in reverse functions

D Recursion

Sorting changes order based on character value, not reversal.

What is the base case in recursive string reversal?

A String is empty

B String length is 1

C String length is even

D String contains only ASCII

An empty string means no more characters to reverse.

Describe step-by-step how to reverse a string in Go safely considering Unicode characters.

Think about how Go handles strings and Unicode.

Explain why reversing a string byte-by-byte can cause problems in Go and how to avoid it.

Consider how characters are stored internally.

Practice

1. What does the strings.Reverse function do in Go if it existed? (Assume it reverses the string.)

easy

A. It converts the string to uppercase.

B. It returns the input string with characters in reverse order.

C. It removes all vowels from the string.

D. It splits the string into words.

Solution

1. Step 1: Understand the function name and purpose

   The function name Reverse suggests it changes the order of characters.

2. Step 2: Interpret the expected behavior

   Reversing a string means the last character becomes first, and so on.

3. Final Answer:

   It returns the input string with characters in reverse order. -> Option B

4. Quick Check:

   Reverse means flip order [OK]

Hint: Reverse means flip the order of characters [OK]

Common Mistakes:

• Confusing reverse with uppercase conversion
• Thinking reverse removes characters
• Assuming reverse splits words

2. Which of the following Go code snippets correctly reverses a string s?

easy

A. var reversed string
for i := len(s)-1; i >= 0; i-- {
reversed += string(s[i])
}

B. for i := 0; i < len(s); i++ {
reversed += string(s[i])
}

C. reversed := strings.ToUpper(s)

D. reversed := strings.Split(s, " ")

Solution

1. Step 1: Analyze the loop direction

   var reversed string for i := len(s)-1; i >= 0; i-- { reversed += string(s[i]) } loops from the last character to the first, building reversed string.

2. Step 2: Check other options

   for i := 0; i < len(s); i++ { reversed += string(s[i]) } loops forward, so no reversal. reversed := strings.ToUpper(s) changes case, reversed := strings.Split(s, " ") splits words.

3. Final Answer:

   Option A correctly reverses the string. -> Option A

4. Quick Check:

   Loop backward to reverse [OK]

Hint: Loop backward from end to start to reverse [OK]

Common Mistakes:

• Looping forward instead of backward
• Using string functions that don't reverse
• Confusing splitting with reversing

3. What is the output of this Go code?

func main() {
  s := "hello"
  reversed := ""
  for i := len(s) - 1; i >= 0; i-- {
    reversed += string(s[i])
  }
  fmt.Println(reversed)
}

medium

A. olleh

B. hello

C. h

D. error

Solution

1. Step 1: Trace the loop from end to start

   The loop starts at index 4 ('o') and goes to 0 ('h'), appending characters in reverse order.

2. Step 2: Build the reversed string

   Characters appended: 'o', 'l', 'l', 'e', 'h' forming "olleh".

3. Final Answer:

   olleh -> Option A

4. Quick Check:

   Reverse of "hello" is "olleh" [OK]

Hint: Reverse string by appending chars from end to start [OK]

Common Mistakes:

• Reading string forward instead of backward
• Printing original string by mistake
• Expecting error due to string indexing

4. Find the error in this Go code that tries to reverse a string s:

func reverse(s string) string {
  var reversed string
  for i := 0; i <= len(s); i++ {
    reversed += string(s[len(s)-i])
  }
  return reversed
}

medium

A. The function should return reversed as a byte slice.

B. The string concatenation should use +=.

C. The loop condition should be i < len(s), not <=.

D. The loop should start from len(s) and go down to 0.

Solution

1. Step 1: Check loop bounds

   The loop runs from 0 to len(s) inclusive, but string indices go from 0 to len(s)-1.

2. Step 2: Identify out-of-range index

   Accessing s[len(s)-i] when i=0 is s[len(s)], which is out of range and causes runtime error.

3. Final Answer:

   The loop condition should be i < len(s), not <=. -> Option C

4. Quick Check:

   Index must be within 0 to len(s)-1 [OK]

Hint: Loop index must stay inside string length bounds [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Accessing index len(s) which is invalid
• Confusing string and byte slice types

5. Given a string with Unicode characters like "Go语言", which approach correctly reverses it preserving characters properly in Go?

hard

A. Split string by spaces and reverse the words.

B. Use a byte slice and reverse bytes directly.

C. Use strings.ToUpper and then reverse.

D. Convert string to []rune, reverse the rune slice, then convert back to string.

Solution

1. Step 1: Understand Unicode in Go strings

   Go strings are byte sequences; Unicode characters may be multiple bytes.

2. Step 2: Use rune slice to handle Unicode characters

   Converting to []rune treats each Unicode character as one element, safe to reverse.

3. Step 3: Reverse rune slice and convert back

   Reversing []rune reverses characters correctly, then convert back to string.

4. Final Answer:

   Convert string to []rune, reverse runes, then back to string. -> Option D

5. Quick Check:

   Use runes for Unicode-safe reversal [OK]

Hint: Use []rune to reverse Unicode strings safely [OK]

Common Mistakes:

• Reversing bytes breaks Unicode characters
• Using uppercase conversion instead of reversing
• Reversing words instead of characters