Why Arrays Exist and What Problem They Solve in DSA Typescript - Why This Pattern

Mental Model

Arrays let us store many items in order, so we can find any item quickly by its position.

Analogy: Imagine a row of mailboxes where each mailbox has a number. You can quickly open mailbox 5 without checking all before it.

Index: 0   1   2   3   4
Value: [ ] [ ] [ ] [ ] [ ]

Dry Run Walkthrough

Input: Store 5 numbers: 10, 20, 30, 40, 50 and find the number at position 3

Goal: Show how arrays let us quickly get the item at position 3 without checking all items

Step 1: Store 10 at position 0

Index: 0   1   2   3   4
Value: [10] [ ] [ ] [ ] [ ]

Why: We put the first number in the first slot

Step 2: Store 20 at position 1

Index: 0   1   2   3   4
Value: [10] [20] [ ] [ ] [ ]

Why: Next number goes in the next slot

Step 3: Store 30 at position 2

Index: 0   1   2   3   4
Value: [10] [20] [30] [ ] [ ]

Why: Continue filling slots in order

Step 4: Store 40 at position 3

Index: 0   1   2   3   4
Value: [10] [20] [30] [40] [ ]

Why: Put the fourth number in the fourth slot

Step 5: Store 50 at position 4

Index: 0   1   2   3   4
Value: [10] [20] [30] [40] [50]

Why: Fill the last slot with the last number

Step 6: Access the number at position 3 directly

Index: 0   1   2   3   4
Value: [10] [20] [30] [40↑] [50]

Why: Arrays let us jump straight to position 3 without checking others

Result:

Index: 0   1   2   3   4
Value: [10] [20] [30] [40] [50]
Answer: 40

Annotated Code

DSA Typescript

class ArrayExample {
  private data: number[];

  constructor(size: number) {
    this.data = new Array(size);
  }

  store(index: number, value: number): void {
    this.data[index] = value; // store value at given index
  }

  access(index: number): number {
    return this.data[index]; // directly access value at index
  }
}

// Driver code
const arr = new ArrayExample(5);
arr.store(0, 10);
arr.store(1, 20);
arr.store(2, 30);
arr.store(3, 40);
arr.store(4, 50);
const result = arr.access(3);
console.log(result);

this.data[index] = value; // store value at given index

store value directly at the given position

return this.data[index]; // directly access value at index

access value directly by index without searching

Output

40

Complexity Analysis

Time: O(1) for access because we jump directly to the position without checking others

Space: O(n) because we store n items in a fixed-size container

vs Alternative: Compared to linked lists, arrays allow instant access by position but need fixed size and contiguous memory

Edge Cases

Accessing index outside array bounds

Returns undefined or error depending on language, must avoid invalid indexes

DSA Typescript

if (index >= 0 && index < this.data.length) { this.data[index] = value; }

Empty array of size 0

No storage possible, access will fail

DSA Typescript

constructor(size: number) {
    this.data = new Array(size);
  }

When to Use This Pattern

When you need to store many items and access them quickly by position, arrays are the go-to structure because they let you jump directly to any item.

Common Mistakes

Mistake: Trying to find an item by checking each one instead of using direct index access
Fix: Use the index to jump directly to the item in the array

Mistake: Assuming arrays can grow automatically without resizing
Fix: Remember arrays have fixed size; use dynamic arrays or lists if you need flexible size

Summary

Arrays store items in order and let you find any item quickly by its position.

Use arrays when you want fast access to items by their index and know the number of items in advance.

The key insight is that arrays let you jump straight to any position without checking others.

Practice

1. Why do arrays exist in programming languages like TypeScript?

easy

A. To store multiple values in a single, ordered collection

B. To perform mathematical calculations automatically

C. To replace all other data structures like trees and graphs

D. To store only one value at a time

Solution

1. Step 1: Understand the purpose of arrays

   Arrays are designed to hold many values together in one place, keeping them in order.

2. Step 2: Compare with other options

   Options A, B, and D do not describe arrays correctly. Arrays do not perform calculations automatically, do not replace all data structures, and can hold more than one value.

3. Final Answer:

   To store multiple values in a single, ordered collection -> Option A

4. Quick Check:

   Arrays store many values in order = C [OK]

Hint: Arrays hold many values together in order [OK]

Common Mistakes:

• Thinking arrays store only one value
• Confusing arrays with calculation tools
• Believing arrays replace all data structures

2. Which of the following is the correct way to declare an array of numbers in TypeScript?

easy

A. let nums: number[] = [1, 2, 3];

B. let nums = (1, 2, 3);

C. let nums: number = [1, 2, 3];

D. let nums: array = 1, 2, 3;

Solution

1. Step 1: Check TypeScript array syntax

   In TypeScript, arrays are declared with type followed by square brackets, e.g., number[].

2. Step 2: Validate each option

   let nums: number[] = [1, 2, 3]; uses correct syntax. Options B, C, and D have syntax errors or wrong type declarations.

3. Final Answer:

   let nums: number[] = [1, 2, 3]; -> Option A

4. Quick Check:

   Correct array syntax = A [OK]

Hint: Use type[] to declare arrays in TypeScript [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Assigning array to a single number type
• Incorrect type keyword usage

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

const arr = [10, 20, 30];
arr.push(40);
console.log(arr);

medium

A. [10, 20, 30]

B. [10, 20, 30, 40]

C. [40, 10, 20, 30]

D. Error: push is not a function

Solution

1. Step 1: Understand the push method

   The push method adds a new element to the end of the array.

2. Step 2: Apply push to the array

   Starting with [10, 20, 30], pushing 40 results in [10, 20, 30, 40].

3. Final Answer:

   [10, 20, 30, 40] -> Option B

4. Quick Check:

   push adds element at end = D [OK]

Hint: push adds element to array end [OK]

Common Mistakes:

• Thinking push adds element at start
• Expecting original array unchanged
• Confusing push with pop

4. Identify the error in this TypeScript code that tries to create an array and add an element:

let numbers = 5;
numbers.push(10);

medium

A. Array must be declared with 'const' keyword

B. push method requires two arguments

C. Variable 'numbers' is not an array, so push method is invalid

D. Numbers cannot be stored in arrays

Solution

1. Step 1: Check variable type

   Variable 'numbers' is assigned a single number, not an array.

2. Step 2: Understand push method usage

   push is a method for arrays only, so calling it on a number causes an error.

3. Final Answer:

   Variable 'numbers' is not an array, so push method is invalid -> Option C

4. Quick Check:

   push only works on arrays = A [OK]

Hint: push works only on arrays, not single values [OK]

Common Mistakes:

• Assuming push works on numbers
• Thinking push needs multiple arguments
• Believing arrays must be const

5. You want to store daily temperatures for a week and quickly access any day's temperature by its position. Which data structure solves this problem best and why?

hard

A. Linked list, because it uses less memory than arrays

B. Stack, because it stores data in last-in-first-out order

C. Set, because it automatically removes duplicate temperatures

D. Array, because it stores values in order and allows fast access by index

Solution

1. Step 1: Identify the need for ordered storage and fast access

   Storing temperatures by day means order matters and quick access by position is needed.

2. Step 2: Compare data structures

   Arrays keep order and allow direct access by index, making them ideal. Linked lists have slower access, sets remove duplicates (not needed), stacks use LIFO order which is not suitable.

3. Final Answer:

   Array, because it stores values in order and allows fast access by index -> Option D

4. Quick Check:

   Ordered fast access = Array = B [OK]

Hint: Use arrays for ordered data with fast index access [OK]

Common Mistakes:

• Choosing linked list for fast access
• Using set which removes duplicates unnecessarily
• Selecting stack which reverses order