How Strings Work Differently Across Languages in DSA Go - Revision Summary

Recall & Review

beginner

What is a string in Go?

A string in Go is a read-only slice of bytes that represents UTF-8 encoded text. It is immutable, meaning once created, it cannot be changed.

intermediate

How does Go handle string immutability compared to languages like Python or Java?

Like Python and Java, Go strings are immutable. However, Go strings are byte slices under the hood, while Python strings are sequences of Unicode characters and Java strings are UTF-16 encoded sequences.

intermediate

How are Unicode characters represented in Go strings?

Go strings store text as UTF-8 encoded bytes. Each Unicode character (rune) can be one or more bytes. Go uses the 'rune' type to represent Unicode code points explicitly.

intermediate

Why might string length differ when measured in bytes vs characters in Go?

Because Go strings are UTF-8 encoded, some characters use multiple bytes. The length of a string in bytes may be larger than the number of characters (runes). Use 'len()' for bytes and 'utf8.RuneCountInString()' for characters.

advanced

How do strings differ in memory usage between Go and C?

In C, strings are mutable arrays of bytes ending with a null byte, while in Go, strings are immutable slices of bytes with length stored separately. Go strings avoid null termination and are safer to use.

What type does Go use to represent a Unicode code point?

A char

B rune

C byte

D string

Go uses the 'rune' type to represent Unicode code points explicitly.

Which of the following is true about Go strings?

A They are immutable UTF-8 encoded byte slices

B They are UTF-16 encoded like Java strings

C They are mutable byte slices

D They end with a null byte like C strings

Go strings are immutable and store UTF-8 encoded bytes.

Why might len(s) in Go not equal the number of characters in string s?

A Because len counts characters, not bytes

B Because Go strings are UTF-16 encoded

C Because Go strings are mutable

D Because len counts bytes, not Unicode characters

len(s) returns the number of bytes, which can be more than characters for multi-byte UTF-8 characters.

How do Go strings differ from C strings in memory layout?

A Go strings are null-terminated, C strings are not

B Go strings use UTF-16 encoding, C strings use UTF-8

C Go strings store length separately, C strings end with null byte

D Both are mutable arrays of bytes

Go strings store length separately and are immutable; C strings end with a null byte.

Which function counts the number of Unicode characters in a Go string?

A utf8.RuneCountInString()

B len()

C strings.Count()

D unicode.Count()

utf8.RuneCountInString() counts Unicode code points (characters) in a UTF-8 string.

Explain how Go strings store text and how this differs from C strings.

Think about encoding, mutability, and how length is tracked.

Describe why the length of a Go string in bytes might not match the number of characters it contains.

Consider how Unicode characters are encoded in UTF-8.

Practice

1. In Go, what is the type of a string internally?
var s = "hello"

easy

A. A sequence of bytes representing UTF-8 encoded characters

B. An array of Unicode code points (runes)

C. A linked list of characters

D. A pointer to a null-terminated character array

Solution

1. Step 1: Understand Go string representation

   Go strings are immutable sequences of bytes, typically UTF-8 encoded.

2. Step 2: Compare with other languages

   Unlike some languages that use arrays of Unicode code points, Go uses bytes internally.

3. Final Answer:

   A sequence of bytes representing UTF-8 encoded characters -> Option A

4. Quick Check:

   Go strings = UTF-8 bytes [OK]

Hint: Remember Go strings are byte sequences, not rune arrays [OK]

Common Mistakes:

• Thinking Go strings store runes directly
• Assuming null-terminated strings like C
• Confusing with linked list or array types

2. Which of the following is the correct way to get the length of a string in Go?
s := "hello"

easy

A. length(s)

B. s.length()

C. len(s)

D. s.len

Solution

1. Step 1: Recall Go built-in function for length

   Go uses the built-in function len() to get the length of strings and slices.

2. Step 2: Check other options

   Methods like s.length() or s.len do not exist in Go; length(s) is not valid syntax.

3. Final Answer:

   len(s) -> Option C

4. Quick Check:

   Use len() for string length in Go [OK]

Hint: Use len() function to get string length in Go [OK]

Common Mistakes:

• Using method calls like s.length() from other languages
• Trying to access length as a property
• Using undefined functions like length()

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

package main
import "fmt"
func main() {
  s := "Go😊"
  fmt.Println(len(s))
}

medium

A. 3

B. 6

C. 4

D. 5

Solution

1. Step 1: Analyze string content and encoding

   The string "Go😊" has 'G' and 'o' as 1 byte each, and the emoji '😊' is a 4-byte UTF-8 character.

2. Step 2: Calculate total byte length

   Total bytes = 1 (G) + 1 (o) + 4 (😊) = 6 bytes.

3. Step 3: Check len() output

   len(s) returns the number of bytes, so output is 6.

4. Final Answer:

   6 -> Option B

5. Quick Check:

   len() counts bytes, not characters [OK]

Hint: len() returns bytes count, not character count [OK]

Common Mistakes:

• Assuming len() returns number of characters
• Ignoring multi-byte UTF-8 characters
• Confusing bytes with runes

4. Identify the error in this Go code that tries to print each character of a string:

package main
import "fmt"
func main() {
  s := "Go"
  for i := 0; i < len(s); i++ {
    fmt.Println(s[i])
  }
}

medium

A. It prints byte values, not characters

B. Syntax error in for loop

C. s[i] is invalid syntax

D. Missing import for fmt

Solution

1. Step 1: Understand s[i] in Go strings

   Accessing s[i] returns the byte at index i, not a character or string.

2. Step 2: Check output of fmt.Println(s[i])

   It prints the numeric byte value (ASCII code), not the character itself.

3. Final Answer:

   It prints byte values, not characters -> Option A

4. Quick Check:

   s[i] = byte, prints number [OK]

Hint: s[i] gives byte, convert to rune or string to print char [OK]

Common Mistakes:

• Expecting s[i] to print characters directly
• Ignoring byte vs rune difference
• Assuming syntax error where none exists

5. How can you correctly iterate over each Unicode character in a Go string to print them?
Choose the correct code snippet.

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 i, c := range s { fmt.Println(s[i]) }

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

Solution

1. Step 1: Understand iteration over strings in Go

   Using 'for _, r := range s' iterates over runes (Unicode code points), not bytes.

2. Step 2: Check printing each character

   Converting rune 'r' to string prints the actual character correctly.

3. Step 3: Analyze other options

   for i := 0; i < len(s); i++ { fmt.Println(string(s[i])) } prints bytes as strings, which may break multi-byte chars; C and D print bytes, not runes.

4. Final Answer:

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

5. Quick Check:

   Use range to get runes for correct Unicode iteration [OK]

Hint: Use 'for _, r := range s' to iterate Unicode chars [OK]

Common Mistakes:

• Iterating by byte index instead of runes
• Printing bytes as characters causing errors
• Confusing index and rune variables