String Basics and Memory Representation in DSA Typescript

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.

"H" -> "e" -> "l" -> "l" -> "o" -> null
↑
start

Dry Run Walkthrough

Input: string: "Hi!"

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

Step 1: Store 'H' at the first memory position

"H" -> null
↑
start

Why: We begin by placing the first character at the start of the string

Step 2: Store 'i' at the next memory position

"H" -> "i" -> null
↑
start

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

Step 3: Store '!' at the next memory position

"H" -> "i" -> "!" -> null
↑
start

Why: Continue storing characters sequentially until the string ends

Step 4: Add a special end marker (null) to show string ends

"H" -> "i" -> "!" -> null
↑
start

Why: The null marks the end so we know where the string stops

Result:

"H" -> "i" -> "!" -> null
String stored in order with an end marker

Annotated Code

DSA Typescript

class StringMemory {
  private chars: string[] = [];

  constructor(input: string) {
    for (const ch of input) {
      this.chars.push(ch); // store each character in order
    }
    this.chars.push('\0'); // add null terminator to mark end
  }

  print(): void {
    let output = '';
    for (const ch of this.chars) {
      if (ch === '\0') {
        output += 'null'; // show end marker
        break;
      }
      output += `"${ch}" -> `; // show each character with arrow
    }
    console.log(output);
  }
}

// Driver code
const myString = new StringMemory("Hi!");
myString.print();

this.chars.push(ch); // store each character in order

store characters sequentially in memory array

this.chars.push('\0'); // add null terminator to mark end

append special end marker to indicate string end

if (ch === '\0') { output += 'null'; break; }

detect end marker to stop printing characters

Output

"H" -> "i" -> "!" -> null

Complexity Analysis

Time: O(n) because we process each character once to store and print

Space: O(n) because we store each character plus one end marker

vs Alternative: Compared to storing characters separately without order, this sequential storage allows easy reading and traversal with minimal overhead

Edge Cases

empty string ""

stores only the null terminator to mark empty string

DSA Typescript

this.chars.push('\0'); // add null terminator to mark end

string with one character "A"

stores 'A' followed by null terminator correctly

DSA Typescript

this.chars.push(ch); // store each character in order

When to Use This Pattern

When you see problems about storing or accessing text character by character, think of strings as sequences in memory with an end marker to know where they stop.

Common Mistakes

Mistake: Forgetting to add the null terminator at the end of the string
Fix: Always add a special end marker (like '\0') to mark where the string ends

Mistake: Trying to access characters beyond the string length without checking the end
Fix: Stop reading when you reach the null terminator to avoid errors

Summary

A string is a sequence of characters stored one after another in memory with a special end marker.

Use this when you need to store or process text data character by character in order.

Remember the key insight: the null terminator marks the end so you know where the string stops.

Practice

1. What does the term immutable mean when talking about strings in TypeScript?

easy

A. Once created, the string cannot be changed.

B. The string can be changed anytime.

C. The string is stored in a mutable array.

D. The string is stored as a number.

Solution

1. Step 1: Understand string immutability

   Strings in TypeScript cannot be changed after creation. Any modification creates a new string.

2. Step 2: Compare options with definition

   Only Once created, the string cannot be changed. correctly states that strings cannot be changed once created.

3. Final Answer:

   Once created, the string cannot be changed. -> Option A

4. Quick Check:

   Immutable means unchangeable = A [OK]

Hint: Remember: strings can't be changed after creation [OK]

Common Mistakes:

• Thinking strings can be changed like arrays
• Confusing mutable and immutable
• Assuming strings are stored as numbers

2. Which of the following is the correct way to declare a string variable in TypeScript?

easy

A. let name: number = 'Alice';

B. let name = 123;

C. let name: string = 'Alice';

D. let name: string = 123;

Solution

1. Step 1: Check variable declaration syntax

   TypeScript uses let variableName: type = value; syntax.

2. Step 2: Match type and value

   let name: string = 'Alice'; declares a string variable with a string value correctly.

3. Final Answer:

   let name: string = 'Alice'; -> Option C

4. Quick Check:

   Correct string declaration = A [OK]

Hint: Match variable type with value type exactly [OK]

Common Mistakes:

• Assigning number to string type
• Missing type annotation
• Using wrong syntax for declaration

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

let greeting = 'Hello';
greeting[0] = 'Y';
console.log(greeting);

medium

A. Yello

B. undefined

C. Error: Cannot assign to string index

D. Hello

Solution

1. Step 1: Understand string immutability in TypeScript

   Strings cannot be changed by index assignment; such operations do not modify the string.

2. Step 2: Analyze the code behavior

   Assigning greeting[0] = 'Y' does nothing; greeting remains 'Hello'.

3. Final Answer:

   Hello -> Option D

4. Quick Check:

   Strings immutable, no change = Hello [OK]

Hint: Strings can't be changed by index assignment [OK]

Common Mistakes:

• Expecting first letter to change
• Thinking string is mutable like array
• Assuming error will be thrown

4. What best describes the result of the following TypeScript code snippet:

let str: string = 'Test';
str[1] = 'a';
console.log(str);

medium

A. No error, output is 'Test'

B. TypeError: Cannot assign to string index

C. SyntaxError: Invalid assignment

D. ReferenceError: str is not defined

Solution

1. Step 1: Check string mutability rules

   Strings are immutable; assigning to an index does nothing.

2. Step 2: Analyze the code behavior

   str[1] = 'a' does nothing; str remains 'Test', console.log outputs 'Test'. No error.

3. Final Answer:

   No error, output is 'Test' -> Option A

4. Quick Check:

   Strings immutable, index assignment ignored = 'Test' [OK]

Hint: Strings cannot be changed by index assignment [OK]

Common Mistakes:

• Assuming no error and string changes
• Confusing syntax error with runtime error
• Expecting ReferenceError

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

let s1 = 'abc';
let s2 = s1 + 'd';
console.log(s1);
console.log(s2);

Choose the correct output considering string immutability and memory representation.

hard

A. abcabc

B. abcabcd

C. abcdabcd

D. Error at runtime

Solution

1. Step 1: Understand string concatenation and immutability

   Concatenating strings creates a new string; original strings remain unchanged.

2. Step 2: Trace variable values after operations

   s1 remains 'abc'; s2 becomes 'abcd'.

3. Final Answer:

   abc
   abcd -> Option B

4. Quick Check:

   Original unchanged, new string created = abc and abcd [OK]

Hint: Concatenation creates new string; originals stay same [OK]

Common Mistakes:

• Expecting s1 to change after concatenation
• Thinking concatenation modifies original string
• Assuming runtime error on concatenation