String Basics and Memory Representation in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a string in computer memory?

A string is a sequence of characters stored in contiguous memory locations, often ending with a special marker or length information to know where it ends.

intermediate

How does Go represent strings internally?

Go represents strings as a read-only slice of bytes with a length. It stores a pointer to the data and the length, but the data itself is immutable.

intermediate

Why are strings immutable in many languages like Go?

Strings are immutable to avoid accidental changes, enable safe sharing between parts of a program, and allow optimizations like string interning.

beginner

What is the difference between a string and a byte slice in Go?

A string is immutable and stores text data, while a byte slice is mutable and can be changed. Byte slices are used for binary data or when you need to modify the content.

intermediate

How is the length of a string stored in Go?

Go stores the length of a string as part of its internal structure alongside the pointer to the data, so length can be accessed in constant time without scanning the string.

In Go, what does a string internally store?

A Pointer to data and length

B Only pointer to data

C Only length of string

D Pointer to data, length, and capacity

Go strings store a pointer to the data and the length, but not capacity since strings are immutable.

Why are strings immutable in Go?

A To allow safe sharing and optimization

B Because Go does not support mutable data

C To save memory by sharing capacity

D To allow strings to grow dynamically

Immutability allows safe sharing of string data and enables optimizations like interning.

What is the main difference between a string and a byte slice in Go?

A Strings store numbers; byte slices store text

B Strings are immutable; byte slices are mutable

C Strings have capacity; byte slices do not

D Strings are mutable; byte slices are immutable

Strings cannot be changed after creation, but byte slices can be modified.

How does Go know the length of a string quickly?

A It stores capacity instead of length

B It counts characters each time

C It uses a null terminator

D Length is stored alongside the pointer

Go stores the length with the pointer, so length access is fast.

Which of these is true about Go strings?

A They store UTF-16 encoded characters

B They can be resized dynamically

C They are read-only sequences of bytes

D They are mutable slices

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

Explain how strings are stored in memory in Go and why immutability is important.

Think about what parts make up a Go string and benefits of not changing strings.

Compare and contrast strings and byte slices in Go in terms of mutability and use cases.

Focus on when you would use each type and how they behave differently.

Practice

1. What does a string represent in Go language?
var s string = "hello"

easy

A. A sequence of bytes representing characters

B. A mutable array of characters

C. A pointer to an integer

D. A floating-point number

Solution

1. Step 1: Understand Go string type

   In Go, a string is a sequence of bytes that represent characters, usually UTF-8 encoded.

2. Step 2: Check mutability and type

   Strings in Go are immutable, so they cannot be changed after creation. They are not arrays or pointers to integers.

3. Final Answer:

   A sequence of bytes representing characters -> Option A

4. Quick Check:

   Go strings = immutable byte sequences [OK]

Hint: Remember: Go strings are immutable byte sequences [OK]

Common Mistakes:

• Thinking strings are mutable arrays
• Confusing strings with pointers
• Assuming strings store integers

2. Which of the following is the correct way to declare and initialize a string in Go?

easy

A. var s string = 'hello'

B. var s string = "hello"

C. var s = hello

D. string s = "hello"

Solution

1. Step 1: Check string literal syntax in Go

   Go uses double quotes "" for string literals, single quotes '' are for rune (character) literals.

2. Step 2: Validate declaration syntax

   Correct declaration uses var keyword, type string, and double quotes for value.

3. Final Answer:

   var s string = "hello" -> Option B

4. Quick Check:

   Use double quotes for strings in Go [OK]

Hint: Use double quotes "" for strings, single quotes '' for runes [OK]

Common Mistakes:

• Using single quotes for strings
• Omitting quotes around string value
• Using incorrect variable declaration syntax

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

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

medium

A. 6

B. 7

C. 5

D. Error

Solution

1. Step 1: Understand the string value

   The string "GoLang" has 6 characters: G, o, L, a, n, g.

2. Step 2: Use len function on string

   len(s) returns the number of bytes in the string. Since all characters are ASCII, length is 6.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   len("GoLang") = 6 [OK]

Hint: len() returns byte count for ASCII strings [OK]

Common Mistakes:

• Counting characters incorrectly
• Expecting len() to count runes instead of bytes
• Assuming error due to missing imports

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

package main
import "fmt"
func main() {
    s := "hello"
    s[0] = 'H'
    fmt.Println(s)
}

medium

A. No error; code runs fine

B. Missing import for fmt package

C. Incorrect string declaration syntax

D. Strings are immutable; cannot assign to s[0]

Solution

1. Step 1: Check string mutability in Go

   Strings in Go are immutable, so you cannot change individual bytes like s[0].

2. Step 2: Analyze the assignment statement

   Attempting s[0] = 'H' causes a compile-time error because strings cannot be modified.

3. Final Answer:

   Strings are immutable; cannot assign to s[0] -> Option D

4. Quick Check:

   Strings immutable = no s[0] assignment [OK]

Hint: Remember: Go strings cannot be changed after creation [OK]

Common Mistakes:

• Trying to modify string bytes directly
• Ignoring immutability errors
• Confusing strings with byte slices

5. Given the string s := "Go😊Lang", what will len(s) return and why?

hard

A. 7, because len counts characters

B. 8, because emoji counts as two bytes

C. 10, because emoji is 4 bytes plus other characters

D. 6, because emoji is ignored

Solution

1. Step 1: Analyze string content and encoding

   The string "Go😊Lang" has 7 characters: G, o, 😊, L, a, n, g. The emoji 😊 is a Unicode character encoded in UTF-8 using 4 bytes.

2. Step 2: Calculate total byte length

   Characters G, o, L, a, n, g are 1 byte each (6 bytes). The emoji is 4 bytes. Total bytes = 6 + 4 = 10 bytes.

3. Step 3: Verify len(s) output

   len(s) returns the number of bytes, so it returns 10, not the number of characters.

4. Final Answer:

   10, because emoji is 4 bytes plus other characters -> Option C

5. Quick Check:

   len counts bytes, emoji uses multiple bytes [OK]

Hint: len() counts bytes, not characters; emojis use multiple bytes [OK]

Common Mistakes:

• Assuming len counts characters, not bytes
• Ignoring multi-byte encoding of emojis
• Thinking emoji counts as one byte