String Basics and Memory Representation in DSA C#

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 necklace holds all letters in order, and you can read them one by one.

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

Dry Run Walkthrough

Input: string: "Hello"

Goal: Understand how each character is stored in memory and accessed by index

Step 1: Store 'H' at index 0

[0:'H'] -> null

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

Step 2: Store 'e' at index 1

[0:'H'] -> [1:'e'] -> null

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

Step 3: Store 'l' at index 2

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

Why: Continue storing characters sequentially

Step 4: Store 'l' at index 3

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

Why: Each character is stored in the next memory slot

Step 5: Store 'o' at index 4

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

Why: Final character completes the string sequence

Result:

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

Annotated Code

DSA C#

using System;

class StringMemoryRepresentation
{
    static void Main()
    {
        string s = "Hello";
        // Print each character with its index to show memory order
        for (int i = 0; i < s.Length; i++)
        {
            Console.WriteLine($"Index {i}: '{s[i]}'");
        }
    }
}

for (int i = 0; i < s.Length; i++)

loop through each character index in the string

Console.WriteLine($"Index {i}: '{s[i]}'");

access and print character at current index to show sequential storage

Output

Index 0: 'H'

Index 1: 'e'

Index 2: 'l'

Index 3: 'l'

Index 4: 'o'

Complexity Analysis

Time: O(n) because we access each character once to print

Space: O(n) because the string stores n characters in contiguous memory

vs Alternative: Compared to linked storage, contiguous memory allows faster index access but fixed size

Edge Cases

empty string ""

loop does not run, no characters to print

DSA C#

for (int i = 0; i < s.Length; i++)

string with one character "A"

prints single character at index 0

DSA C#

for (int i = 0; i < s.Length; i++)

When to Use This Pattern

When you need to understand how characters are stored and accessed by index in a string, think about contiguous memory layout.

Common Mistakes

Mistake: Trying to modify a character in a string directly (strings are immutable)
Fix: Create a new string or use a character array to modify characters

Mistake: Assuming string characters are stored non-contiguously like linked nodes
Fix: Remember strings are stored in contiguous memory for fast index access

Summary

A string stores characters one after another in contiguous memory locations.

Use this when you want fast access to characters by their position in the string.

The key insight is that each character has a fixed position, like beads on a necklace, making access simple and fast.

Practice

1. What does the string type in C# represent in memory?

easy

A. A list of integers representing ASCII codes

B. A sequence of characters stored as Unicode values

C. A mutable array of bytes

D. A pointer to a memory address without data

Solution

1. Step 1: Understand string storage in C#

   C# strings store characters as Unicode, allowing international text.

2. Step 2: Compare options with string behavior

   Only A sequence of characters stored as Unicode values correctly describes strings as sequences of Unicode characters.

3. Final Answer:

   A sequence of characters stored as Unicode values -> Option B

4. Quick Check:

   string = Unicode characters [OK]

Hint: Remember C# strings are Unicode sequences, not byte arrays [OK]

Common Mistakes:

• Thinking strings are mutable arrays
• Confusing ASCII with Unicode
• Assuming strings are just pointers

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

easy

A. string s = "hello";

B. string s = hello;

C. string s = 'hello';

D. string s = "hello";
char[] arr = s;

Solution

1. Step 1: Check string literal syntax

   In C#, string literals use double quotes, so "hello" is correct.

2. Step 2: Validate each option

   string s = 'hello'; uses single quotes (for chars), B misses quotes, D tries to assign string to char array directly (invalid).

3. Final Answer:

   string s = "hello"; -> Option A

4. Quick Check:

   Strings use double quotes in C# [OK]

Hint: Use double quotes for strings, single quotes for chars [OK]

Common Mistakes:

• Using single quotes for strings
• Forgetting quotes around text
• Assigning string directly to char array

3. What will be the output of the following C# code?

string s1 = "hello";
string s2 = "hello";
Console.WriteLine(object.ReferenceEquals(s1, s2));

medium

A. true

B. false

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand string interning in C#

   String literals with same content are interned and share the same reference.

2. Step 2: Check ReferenceEquals for s1 and s2

   Since both are "hello" literals, ReferenceEquals returns true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   String literals share references = true [OK]

Hint: String literals with same text share references [OK]

Common Mistakes:

• Assuming ReferenceEquals returns false for equal strings
• Confusing value equality with reference equality
• Expecting runtime errors

4. Identify the error in the following C# code snippet:

string s = "test";
s[0] = 'T';
Console.WriteLine(s);

medium

A. Runtime error: index out of range

B. Syntax error: missing semicolon

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

D. No error; output is "Test"

Solution

1. Step 1: Check string mutability in C#

   Strings are immutable; individual characters cannot be changed by index.

2. Step 2: Analyze assignment to s[0]

   Assigning to s[0] causes a compile-time error because strings cannot be modified this way.

3. Final Answer:

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

4. Quick Check:

   Strings immutable = assignment error [OK]

Hint: Remember strings cannot be changed character-by-character [OK]

Common Mistakes:

• Trying to modify string characters directly
• Expecting runtime error instead of compile error
• Assuming strings behave like char arrays

5. Given the following code, what will be the output?

string s = "hello";
string t = s + " world";
Console.WriteLine(s);
Console.WriteLine(t);

Choose the correct output representation.

hard

A. hello world
hello

B. hello world
hello world

C. hello
world

D. hello
hello world

Solution

1. Step 1: Understand string concatenation and immutability

   Concatenation creates a new string; original string s remains unchanged.

2. Step 2: Trace the output statements

   Console.WriteLine(s) prints hello; Console.WriteLine(t) prints hello world.

3. Final Answer:

   hello hello world -> Option D

4. Quick Check:

   Original string unchanged, new string created [OK]

Hint: Concatenation creates new string; original stays same [OK]

Common Mistakes:

• Assuming original string changes after concatenation
• Mixing order of printed strings
• Confusing string references with values