String Basics and Memory Representation in DSA Go

Mental Model

A string is a sequence of characters stored one after another in memory, like beads on a string.

Analogy: Imagine a necklace where each bead is a letter. The beads are lined up in order, and you can read the message by looking at each bead one by one.

Index:  [0] -> [1] -> [2] -> [3] -> [4]
Value:  'H' -> 'e' -> 'l' -> 'l' -> 'o'

Dry Run Walkthrough

Input: string: "Hello"

Goal: Understand how the string "Hello" is stored in memory as a sequence of characters.

Step 1: Store character 'H' at index 0

Index:  [0]
Value:  'H'

Why: We start storing the first character at the beginning of the string memory.

Step 2: Store character 'e' at index 1

Index:  [0] -> [1]
Value:  'H' -> 'e'

Why: Next character goes right after the first, keeping order.

Step 3: Store character 'l' at index 2

Index:  [0] -> [1] -> [2]
Value:  'H' -> 'e' -> 'l'

Why: Continue placing characters sequentially.

Step 4: Store character 'l' at index 3

Index:  [0] -> [1] -> [2] -> [3]
Value:  'H' -> 'e' -> 'l' -> 'l'

Why: Keep the order intact for repeated characters.

Step 5: Store character 'o' at index 4

Index:  [0] -> [1] -> [2] -> [3] -> [4]
Value:  'H' -> 'e' -> 'l' -> 'l' -> 'o'

Why: Finish storing all characters in order.

Result:

Index:  [0] -> [1] -> [2] -> [3] -> [4]
Value:  'H' -> 'e' -> 'l' -> 'l' -> 'o'

Annotated Code

DSA Go

package main

import "fmt"

func main() {
    // The string to store
    s := "Hello"

    // Print each character with its index to show memory order
    for i, ch := range s {
        fmt.Printf("Index: [%d], Character: '%c'\n", i, ch)
    }

    // Show the full string
    fmt.Println("Full string:", s)
}

for i, ch := range s {

Iterate over each character in the string by index to show order

fmt.Printf("Index: [%d], Character: '%c'\n", i, ch)

Print character and its position to visualize memory layout

Output

Index: [0], Character: 'H'

Index: [1], Character: 'e'

Index: [2], Character: 'l'

Index: [3], Character: 'l'

Index: [4], Character: 'o'

Full string: Hello

Complexity Analysis

Time: O(n) because we look at each character once to show its position

Space: O(n) because the string stores all characters in a sequence

vs Alternative: Compared to storing characters separately (like separate variables), this sequential memory layout is efficient and easy to access by index

Edge Cases

Empty string ""

No characters to store, so loop does not run. Only 'Full string: ' is printed.

DSA Go

for i, ch := range s {

String with one character "A"

Stores single character at index 0 and prints it

DSA Go

for i, ch := range s {

String with repeated characters "aaa"

Stores each 'a' in order at indexes 0,1,2 and prints all

DSA Go

for i, ch := range s {

When to Use This Pattern

When you need to understand how text is stored or accessed by position, think of strings as sequences of characters stored one after another in memory.

Common Mistakes

Mistake: Thinking strings are stored as separate disconnected characters without order
Fix: Remember strings are stored as a continuous sequence, so order and index matter

Summary

A string is a sequence of characters stored one after another in memory.

Use this when you want to access or manipulate text by position or character.

The key insight is that each character has a fixed position in a continuous block of memory.

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