Binary Search is one of the most important searching techniques for sorted data. Instead of checking every element one by one, it repeatedly divides the search space into half.

Today, I solved 5 LeetCode problems:

1. Binary Search

2. Search Insert Position

3. Find First and Last Position of Element in Sorted Array

4. Search in Rotated Sorted Array

5. First Bad Version

These problems helped me understand that Binary Search is not only about finding an exact value. The same idea can also be used to find positions, boundaries, and the first/last occurrence of something.

Problems Solved

What is Binary Search?

Binary Search works on a sorted search space.

Instead of checking every element:

1 → 2 → 3 → 4 → 5 → ...

we check the middle.

If the target is smaller than the middle:

Search left half

If the target is larger:

Search right half

So every step removes approximately half of the remaining search space.

Example

nums = [1,3,5,7,9,11,13]
target = 11

Start:

left = 0
right = 6
mid = 3

nums[mid] = 7

Since:

11 > 7

we ignore the left half.

Now:

left = 4
right = 6

Continue until the target is found.

1. Binary Search

LeetCode: 704

Solve Binary Search on LeetCode

Problem

Given a sorted array of integers and a target value, return the index of the target.

If the target does not exist, return -1.

Example

Input:
nums = [-1,0,3,5,9,12]
target = 9

Output:
4

Approach

Maintain two pointers:

left
right

Find the middle:

let middleIndex = Math.floor((leftIndex + rightIndex) / 2);

Then compare the target with the middle element.

If target is found

Return the middle index.

If target is smaller

Search the left half:

right = mid - 1;

If target is larger

Search the right half:

left = mid + 1;

Code

var search = function(nums, target) {
    let leftIndex = 0;
    let rightIndex = nums.length - 1;

    while (leftIndex <= rightIndex) {
        let middleIndex =
            Math.floor((leftIndex + rightIndex) / 2);

        if (target === nums[middleIndex]) {
            return middleIndex;
        }

        if (target < nums[middleIndex]) {
            rightIndex = middleIndex - 1;
        } else {
            leftIndex = middleIndex + 1;
        }
    }

    return -1;
};

How It Works

For:

[-1,0,3,5,9,12]

Target:

9

First:

mid = 2
nums[mid] = 3

Since:

9 > 3

move right.

Then:

mid = 4
nums[mid] = 9

Target found.

Return:

4

Complexity

Time:  O(log n)
Space: O(1)

2. Search Insert Position

LeetCode: 35

Solve Search Insert Position on LeetCode

Problem

Given a sorted array and a target, return the index if the target exists.

If it doesn't exist, return the position where it should be inserted.

Example

Input:
nums = [1,3,5,6]
target = 2

Output:
1

Because 2 should be inserted between:

1 and 3

Approach

This looks similar to normal Binary Search.

The important difference is what happens when the target is not found.

When the loop finishes, left represents the correct insertion position.

Code

var searchInsert = function(nums, target) {
    let left = 0;
    let right = nums.length - 1;

    while (right >= left) {
        let mid = Math.floor((left + right) / 2);

        if (target === nums[mid]) {
            return mid;
        } else if (target < nums[mid]) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return left;
};

How It Works

Example:

nums = [1,3,5,6]
target = 2

Eventually the search space becomes empty.

At that point:

left = 1

Index 1 is exactly where 2 should be inserted.

Therefore:

[1,2,3,5,6]
   ↑
 index 1

Key Idea

In this problem:

left

is not just a search pointer.

After the search finishes, it represents the first valid position where the target can be placed.

Complexity

Time:  O(log n)
Space: O(1)

3. Find First and Last Position of Element in Sorted Array

LeetCode: 34

Solve Find First and Last Position of Element in Sorted Array on LeetCode

Problem

Given a sorted array that may contain duplicate values, find the first and last position of a target.

Example

Input:
nums = [5,7,7,8,8,10]
target = 8

Output:
[3,4]

The first 8 is at index 3.

The last 8 is at index 4.

Approach

A normal Binary Search can find an occurrence of the target.

But here we need:

First occurrence
+
Last occurrence

So we perform Binary Search twice.

First Search

Find the leftmost occurrence.

When:

nums[mid] >= target

we continue searching toward the left.

Second Search

Find the rightmost occurrence.

When:

nums[mid] <= target

we continue searching toward the right.

Code

var searchRange = function(nums, target) {
    let l = 0;
    let r = nums.length - 1;
    let ans = [-1, -1];

    // Find first occurrence
    while (l < r) {
        let m = l + Math.floor((r - l) / 2);

        if (nums[m] < target) {
            l = m + 1;
        } else {
            r = m;
        }
    }

    if (nums[l] === target) {
        ans[0] = l;
    }

    // Find last occurrence
    l = 0;
    r = nums.length - 1;

    while (l < r) {
        let m = l + Math.ceil((r - l) / 2);

        if (nums[m] > target) {
            r = m - 1;
        } else {
            l = m;
        }
    }

    if (nums[l] === target) {
        ans[1] = l;
    }

    return ans;
};

Why Are floor and ceil Different?

For the first search, we want to move toward the left boundary, so we use:

Math.floor((r - l) / 2)

For the second search, we want to move toward the right boundary, so we use:

Math.ceil((r - l) / 2)

This helps prevent the pointers from getting stuck when only two elements remain.

How It Works

For:

[5,7,7,8,8,10]

and:

target = 8

First Binary Search finds:

3

Second Binary Search finds:

4

Therefore:

[3,4]

Complexity

We perform Binary Search twice:

Time:  O(log n)
Space: O(1)

4. Search in Rotated Sorted Array

LeetCode: 33

Solve Search in Rotated Sorted Array on LeetCode

Problem

A sorted array has been rotated at an unknown position.

Find the index of the target.

Example

Input:
nums = [4,5,6,7,0,1,2]
target = 0

Output:
4

The original sorted array was:

[0,1,2,4,5,6,7]

After rotation:

[4,5,6,7,0,1,2]

Challenge

The entire array is no longer sorted.

However, at every Binary Search step, at least one half is still sorted.

That is the key observation.

Approach

Calculate the middle.

Then check:

if (nums[left] <= nums[mid])

This means the left half is sorted.

Otherwise:

right half is sorted

Then check whether the target belongs inside the sorted half.

If it does, search there.

Otherwise, search the other half.

Code

var search = function(nums, target) {
    let l = 0;
    let r = nums.length - 1;

    while (l <= r) {
        let m = l + Math.floor((r - l) / 2);

        if (target === nums[m]) {
            return m;
        }

        // Left half is sorted
        if (nums[l] <= nums[m]) {
            if (target < nums[m] && target >= nums[l]) {
                r = m - 1;
            } else {
                l = m + 1;
            }
        }

        // Right half is sorted
        else {
            if (target > nums[m] && target <= nums[r]) {
                l = m + 1;
            } else {
                r = m - 1;
            }
        }
    }

    return -1;
};

How It Works

Consider:

[4,5,6,7,0,1,2]

Suppose:

mid = 3
nums[mid] = 7

The left half:

[4,5,6,7]

is sorted.

If the target is inside this range, search left.

Otherwise:

search right

At every step, we eliminate approximately half of the remaining search space.

Complexity

Time:  O(log n)
Space: O(1)

Pattern

Modified Binary Search

The key pattern is:

Find which half is sorted
        ↓
Check whether target belongs there
        ↓
Choose the correct half

5. First Bad Version

LeetCode: 278

Solve First Bad Version on LeetCode

Problem

There are versions:

1, 2, 3, 4, 5, ...

At some point, a version becomes bad.

Once a version is bad, all versions after it are also bad.

Find the first bad version.

Example

n = 5
first bad version = 4

The versions look like:

1  2  3  4  5
G  G  G  B  B

We need to find the first B.

Approach

This is another Binary Search problem.

But instead of searching for an exact value, we are searching for a boundary.

The pattern is:

Good Good Good Bad Bad Bad
                  ↑
            first bad version

If the middle version is good:

!isBadVersion(mid)

the first bad version must be after it.

So:

left = mid + 1;

If the middle version is bad:

isBadVersion(mid)

it could be the first bad version, so we keep it in the search space:

right = mid;

Code

var solution = function(isBadVersion) {
    /**
     * @param {integer} n Total versions
     * @return {integer} The first bad version
     */

    return function(n) {
        let l = 1;
        let r = n;

        while (l < r) {
            let m = l + Math.floor((r - l) / 2);

            if (!isBadVersion(m)) {
                l = m + 1;
            } else {
                r = m;
            }
        }

        return r;
    };
};

How It Works

Suppose:

n = 5

and:

1  2  3  4  5
G  G  G  B  B

Binary Search checks the middle version.

If it finds:

Good

we know the answer must be to the right.

If it finds:

Bad

we know the answer is at the middle or somewhere to the left.

Eventually:

left === right

That position is the first bad version.

Complexity

Time:  O(log n)
Space: O(1)

Binary Search Patterns I Learned

Today's problems show that Binary Search has several variations.

1. Exact Search

Example:

Binary Search

Find:

target

2. Insertion Position

Example:

Search Insert Position

Find:

where target should be placed

3. Boundary Search

Example:

Find First and Last Position
First Bad Version

Find:

first occurrence
last occurrence
first bad position

4. Modified Binary Search

Example:

Search in Rotated Sorted Array

Find which half remains sorted and continue searching there.

Binary Search Pattern Recognition

When looking at a new problem, I can ask:

Question 1

Is the data sorted?

Yes → Binary Search may be possible

Question 2

Can I eliminate half of the search space after each comparison?

Yes → Binary Search is a strong candidate

Question 3

Am I looking for a boundary?

For example:

First
Last
Minimum valid
Maximum valid
First bad
Insertion position

Then I should think about Boundary Binary Search.

Question 4

Is the array rotated but still has a sorted half?

Then think about:

Modified Binary Search

Time Complexity Comparison

One reason Binary Search is powerful is the difference in time complexity.

For a large array:

Linear Search
O(n)

Binary Search:

O(log n)

For example, with around one million elements, Binary Search needs only around 20 halving steps to narrow the search to a single position.

The important idea is not simply "Binary Search is faster."

It is:

Each step removes about half of the remaining possibilities.

What I Learned Today

Today I learned that Binary Search is more than:

Find target in sorted array

It can also be used to find:

• An exact value

• An insertion position

• First occurrence

• Last occurrence

• A boundary

• First bad version

• A target in a rotated sorted array

The most important concept for me is learning to identify the search space and understand how each condition can reduce that search space.

Day 9 Summary

Today I solved:

704 → Binary Search
35  → Search Insert Position
34  → Find First and Last Position
33  → Search in Rotated Sorted Array
278 → First Bad Version

Main patterns:

Binary Search
      ↓
Boundary Search
      ↓
Modified Binary Search

Key Takeaway

Binary Search is not just about finding a target. It is a general technique for repeatedly cutting a sorted or monotonic search space in half.

Day 9 complete.

Sliding Window is useful when a problem asks us to find something inside a continuous part of an array or string, such as:

• Longest substring

• Shortest substring

• Fixed-size substring

• Permutation

• Anagram

• Maximum/minimum value inside a window

• Number of valid subarrays/substrings

For Day 8, I practiced three important LeetCode problems:

1. LeetCode 424 — Longest Repeating Character Replacement

2. LeetCode 567 — Permutation in String

3. LeetCode 438 — Find All Anagrams in a String

The main idea is:

Instead of repeatedly checking the entire substring, maintain information about the current window and update it when the window moves.

1. LeetCode 424 — Longest Repeating Character Replacement

Problem

LeetCode 424 — Longest Repeating Character Replacement

You are given a string s containing uppercase English letters and an integer k.

You can replace at most k characters in the string.

Find the length of the longest substring that can be made to contain only the same character after at most k replacements.

Example

Input:
s = "AABABBA"
k = 1

Output:
4

Why?

The substring:

AABA

can become:

AAAA

by replacing one B.

So the answer is:

4

Problem Understanding

Suppose our current window is:

A A B A

Counts:

A → 3
B → 1

The most frequent character is A.

If we want the entire window to contain only A, we need to replace the other characters.

Window size = 4
Most frequent count = 3

Characters to replace:
4 - 3 = 1

If:

charactersToReplace <= k

the window is valid.

So the important formula is:

window size - most frequent character count <= k

Approach

We use a variable-size sliding window.

We maintain:

i → left side of window
j → right side of window
map → frequency of characters
maxWindow → longest valid window

For every character added to the window:

1. Increase its frequency.

2. Find the most frequent character.

3. Calculate how many replacements are required.

4. If the window is valid, update the answer.

5. If the window is invalid, move the left pointer forward.

Window condition

windowSize - maxFrequency <= k

If this is true:

Valid window

Otherwise:

Invalid window → shrink it

Code

var characterReplacement = function (s, k) {
    let i = 0;
    let j = 0;

    let map = Array(26).fill(0);
    let maxWindow = 0;

    while (j < s.length) {

        ++map[s.charCodeAt(j) - 65];

        if (isValidWindow(map, k)) {
            maxWindow = Math.max(maxWindow, j - i + 1);
            ++j;
        } else {
            --map[s.charCodeAt(i) - 65];
            ++i;
        }
    }

    return maxWindow;
};

var isValidWindow = function (map, k) {
    let totalCount = 0;
    let maxCount = 0;

    for (let i = 0; i < 26; i++) {
        totalCount += map[i];
        maxCount = Math.max(maxCount, map[i]);
    }

    return totalCount - maxCount <= k;
};

How It Works

Consider:

s = "AABABBA"
k = 1

Initially:

i = 0
j = 0

Window:

A

Frequency:

A → 1

Replacement needed:

1 - 1 = 0

Valid.

Next:

AA

Frequency:

A → 2

Replacement:

2 - 2 = 0

Valid.

Next:

AAB

Frequency:

A → 2
B → 1

Most frequent:

A → 2

Replacement:

3 - 2 = 1

Since:

1 <= k

the window is valid.

Next:

AABA

Frequency:

A → 3
B → 1

Replacement:

4 - 3 = 1

Still valid.

So:

maxWindow = 4

When the window becomes invalid, we remove the character at i.

For example:

AABABB

Frequency:

A → 3
B → 3

Window size:

6

Most frequent:

3

Required replacements:

6 - 3 = 3

But:

k = 1

So the window is invalid.

We shrink it:

i++

and remove the leftmost character from the frequency array.

Pattern Recognition

When you see:

"Find the longest substring where we can modify/replace at most k elements."

Think:

Variable Sliding Window
        +
Frequency Map
        +
Longest Valid Window

The important question to ask is:

"How many characters do I need to change to make this window valid?"

Here:

windowSize - maxFrequency

Complexity

Let:

n = length of string

The sliding window moves each pointer at most n times.

isValidWindow() checks 26 characters.

Therefore:

Time: O(26 × n)
     = O(n)

Space: O(26)
      = O(1)

2. LeetCode 567 — Permutation in String

Problem

LeetCode 567 — Permutation in String

Given two strings s1 and s2, return true if s2 contains a permutation of s1.

Otherwise, return false.

Example

Input:
s1 = "ab"
s2 = "eidbaooo"

Output:
true

Because:

"ba"

is a permutation of:

"ab"

and "ba" exists inside s2.

Problem Understanding

A permutation contains exactly the same characters with exactly the same frequencies.

For:

s1 = "ab"

Possible permutations:

ab
ba

We don't actually need to generate all permutations.

Instead, we can compare character frequencies.

For:

"ab"

frequency:

a → 1
b → 1

If a window in s2 has the same frequency:

a → 1
b → 1

then that window is a permutation.

Approach

Here the window size is fixed.

If:

s1.length = 2

every window in s2 must have exactly:

2 characters

So this is a:

Fixed-Size Sliding Window

We create two frequency arrays:

mapS
mapW

Where:

mapS → frequency of s1
mapW → frequency of current window in s2

Then compare them.

Code

var checkInclusion = function (s1, s2) {
    if (s1.length > s2.length) {
        return false;
    }

    let mapS = Array(26).fill(0);
    let mapW = Array(26).fill(0);

    let windowLength = s1.length;

    // Create the initial window
    for (let i = 0; i < windowLength; i++) {
        ++mapS[s1.charCodeAt(i) - 97];
        ++mapW[s2.charCodeAt(i) - 97];
    }

    let i = 0;
    let j = windowLength - 1;

    while (j < s2.length) {

        if (isMapSame(mapS, mapW)) {
            return true;
        }

        // Remove left character
        --mapW[s2.charCodeAt(i) - 97];

        ++i;
        ++j;

        // Add new right character
        if (j < s2.length) {
            ++mapW[s2.charCodeAt(j) - 97];
        }
    }

    return false;
};

var isMapSame = function (mapS, mapW) {
    for (let i = 0; i < 26; i++) {
        if (mapS[i] !== mapW[i]) {
            return false;
        }
    }

    return true;
};

How It Works

Consider:

s1 = "ab"
s2 = "eidbaooo"

The required window size is:

2

Initial window:

ei

Frequency doesn't match:

s1:
a → 1
b → 1

window:
e → 1
i → 1

So we slide.

Next window:

id

Still doesn't match.

Next:

db

Still doesn't match.

Next:

ba

Frequency:

b → 1
a → 1

Same as s1.

Therefore:

return true

Why Sliding Window?

Without Sliding Window, we might repeatedly create substrings and count characters.

That creates unnecessary work.

Instead:

Remove one character
        ↓
Move window
        ↓
Add one character

We reuse the previous window's information.

For example:

[e i]

moves to:

[i d]

We don't recount everything.

We:

remove e
add d

This is the main advantage of Sliding Window.

Pattern Recognition

When you see:

"Does one string contain a permutation/anagram of another string?"

Think:

Fixed-Size Sliding Window
        +
Frequency Array
        +
Frequency Comparison

The key clue is:

window size = pattern length

Complexity

There are 26 possible lowercase English characters.

For each window, we compare 26 values.

Therefore:

Time: O(26 × n)
     = O(n)

Space: O(26)
      = O(1)

3. LeetCode 438 — Find All Anagrams in a String

Problem

LeetCode 438 — Find All Anagrams in a String

Given two strings s and p, return an array containing the starting indices of all anagrams of p in s.

Example

Input:

s = "cbaebabacd"
p = "abc"

Output:

[0, 6]

Because:

cba

is an anagram of:

abc

and:

bac

is also an anagram of:

abc

Their starting indices are:

0
6

Problem Understanding

Anagrams have:

1. Same characters

2. Same frequency

3. Different order is allowed

For example:

abc
bca
cab
acb
bac
cba

All are anagrams.

So we don't care about character order.

We only care about:

frequency

Approach

This problem is very similar to LeetCode 567.

The difference is:

LeetCode 567

We need to know:

Does at least one permutation exist?

So we return:

true / false

LeetCode 438

We need:

All positions where an anagram exists

So we store the starting index.

The window size is:

p.length

We maintain:

mapP → frequency of pattern
mapW → frequency of current window

Whenever:

mapP === mapW

we found an anagram.

Code

var findAnagrams = function (s, p) {
    if (p.length > s.length) {
        return [];
    }

    let mapW = Array(26).fill(0);
    let mapP = Array(26).fill(0);

    let window = p.length;

    // Create initial window
    for (let i = 0; i < window; i++) {
        ++mapW[s.charCodeAt(i) - 97];
        ++mapP[p.charCodeAt(i) - 97];
    }

    let i = 0;
    let j = window - 1;

    let res = [];

    while (j < s.length) {

        if (isAnagram(mapW, mapP)) {
            res.push(i);
        }

        // Remove left character
        --mapW[s.charCodeAt(i) - 97];

        ++i;
        ++j;

        // Add new right character
        if (j < s.length) {
            ++mapW[s.charCodeAt(j) - 97];
        }
    }

    return res;
};

var isAnagram = function (mapW, mapP) {
    for (let i = 0; i < 26; i++) {
        if (mapW[i] !== mapP[i]) {
            return false;
        }
    }

    return true;
};

How It Works

Consider:

s = "cbaebabacd"
p = "abc"

Pattern:

abc

Frequency:

a → 1
b → 1
c → 1

Initial window:

cba

Frequency:

a → 1
b → 1
c → 1

Both maps are equal.

Therefore:

res.push(0)

Now slide the window.

Current:

cba

Remove:

c

Add:

e

New window:

bae

Frequency doesn't match.

Continue sliding.

Eventually we reach:

bac

Its frequency is:

a → 1
b → 1
c → 1

Again it matches the pattern.

Starting index:

6

So:

res = [0, 6]

Pattern Recognition

When you see:

"Find all anagrams of a pattern inside a string."

Think:

Fixed-Size Sliding Window
             +
Frequency Array
             +
Compare Window With Pattern

The most important clue is:

window size = pattern length

Complexity

We compare 26 characters for every window.

Therefore:

Time: O(26 × n)
     = O(n)

Space: O(26)
      = O(1)

Fixed vs Variable Sliding Window

These three problems help identify an important difference.

Fixed-Size Window

The window size is already known.

Examples:

LeetCode 567
LeetCode 438

If:

pattern.length = 3

then every window has exactly 3 characters.

Pattern:

abc

Windows:

cba
bae
aeb
eba
...

Variable-Size Window

The window size changes depending on whether the current window is valid.

Example:

LeetCode 424

We expand:

j++

when the window is valid.

We shrink:

i++

when the window becomes invalid.

The Sliding Window Mental Model

The easiest way I understand Sliding Window is:

          j
          ↓
A B A B C A A
↑
i

i represents the left side.

j represents the right side.

The window is:

[i ........ j]

For example:

A B A B
↑     ↑
i     j

When we want to move the window:

Remove s[i]
Move i
Add s[j]
Move j

So instead of rebuilding the window again and again, we maintain it incrementally.

How to Recognize Sliding Window in Interviews

Look for these keywords:

1. "Substring"

Example:

Find the longest substring...

Possible Sliding Window problem.

2. "Subarray"

Example:

Find the smallest subarray...

Possible Sliding Window problem.

3. "Contiguous"

Example:

Find the maximum sum of a contiguous subarray...

Strong Sliding Window clue.

4. "At most K"

Example:

At most k replacements
At most k distinct characters

Usually suggests a variable-size Sliding Window.

5. "Permutation"

Example:

Does s2 contain a permutation of s1?

Think:

Fixed Window + Frequency Map

6. "Anagram"

Example:

Find all anagrams in a string

Think:

Fixed Window + Frequency Map

Day 8 Pattern Summary

The common structure is:

Sliding Window
      ↓
Maintain Frequency
      ↓
Move Window
      ↓
Check Condition
      ↓
Update Answer

One Important Improvement to My Original Code

While solving these problems, I learned that pointer movement and array access need to be handled carefully.

For example, code like this can cause a boundary problem:

++j;
++map[s.charCodeAt(j) - 65];

If j becomes:

s.length

then:

s.charCodeAt(j)

does not give a valid character.

So it is safer to:

++j;

if (j < s.length) {
    ++map[s.charCodeAt(j) - 65];
}

This small check prevents accessing outside the string.

What I Learned Today

The biggest lesson from Day 8 was that Sliding Window is not one single technique.

There are two major forms:

1. Fixed-Size Sliding Window

2. Variable-Size Sliding Window

Fixed Size

Used when the problem gives us a specific window size.

window = pattern.length

Examples:

LeetCode 567
LeetCode 438

Variable Size

Used when the window size depends on a condition.

Expand → Check → Shrink if invalid

Example:

LeetCode 424

The most important habit is to ask:

Is the window size fixed, or does it change based on a condition?

Once I identify that, the implementation becomes much easier.

Final Pattern Cheat Sheet

Substring / Subarray
        ↓
Think Sliding Window
        ↓
Is window size fixed?
        ↓
   ┌────┴────┐
   ↓         ↓
  YES        NO
   ↓         ↓
Fixed      Variable
Window     Window
   ↓         ↓
Frequency   Expand
Map         ↓
   ↓       Check
Compare     ↓
            Shrink
          if invalid

Problems practiced today

424 → Longest Repeating Character Replacement
567 → Permutation in String
438 → Find All Anagrams in a String

These three problems gave me a better understanding of how Sliding Window + Frequency Array works in JavaScript.

Day 8 completed.

But as applications become larger, managing all that code becomes difficult.

Imagine building a banking application with thousands of lines of code. You need to manage customers, accounts, transactions, loans, payments, cards, and many other things.

If everything is written using unrelated variables and functions, the code can quickly become difficult to understand and maintain.

This is where Object-Oriented Programming (OOP) becomes useful.

OOP is a programming approach where we organize our program around objects that contain both data and behavior.

Let's understand OOP step by step using simple programming examples and real-world examples.

What is OOP?

OOP stands for Object-Oriented Programming.

It is a programming paradigm that organizes software around objects rather than only functions and procedures.

An object can contain:

• Data → information about the object

• Methods → actions that the object can perform

Real-world example: Mobile Phone

Think about a mobile phone.

A phone has properties such as:

• Brand

• Model

• Price

• Storage

And it can perform actions such as:

• Call

• Send message

• Take photo

• Play video

We can represent this idea in programming using a class and objects.

class Phone {

    String brand;
    String model;

    void call() {
        System.out.println("Calling...");
    }

    void takePhoto() {
        System.out.println("Taking photo...");
    }
}

Here:

• brand and model are attributes/data

• call() and takePhoto() are methods/behaviors

So we can think of an object as:

Phone Object
│
├── Data
│   ├── brand
│   ├── model
│   └── price
│
└── Behavior
    ├── call()
    ├── takePhoto()
    └── sendMessage()

Other real-world objects

In a shopping application, objects could be:

Customer
Product
Cart
Order
Payment
Delivery

Each object can have its own data and behavior.

For example:

Order
│
├── Data
│   ├── orderId
│   ├── totalAmount
│   └── status
│
└── Behavior
    ├── placeOrder()
    ├── cancelOrder()
    └── trackOrder()

Class vs Object

One of the most important concepts in OOP is understanding the difference between a class and an object.

Class

A class is like a blueprint or template.

For example, a house blueprint describes:

• Number of rooms

• Doors

• Windows

• Structure

But the blueprint itself is not a real house.

Similarly, a class defines what an object should contain.

class Car {

    String color;

    void drive() {
        System.out.println("Car is driving");
    }
}

The Car class is a blueprint.

It describes that a car has:

• color

• drive() behavior

But we haven't created an actual car yet.

Object

An object is a real instance created from a class.

Car car1 = new Car();
Car car2 = new Car();

Here:

• Car → class

• car1 → object

• car2 → object

We can give different values to each object.

car1.color = "Red";
car2.color = "Blue";

Now we have:

Car Class
   │
   ├── car1 → Red
   │
   └── car2 → Blue

Real-world analogy

Think about a cookie cutter.

Cookie Cutter → Class
        ↓
   ┌─────────┐
   │ Cookie  │ → Object 1
   └─────────┘
   ┌─────────┐
   │ Cookie  │ → Object 2
   └─────────┘

The cookie cutter defines the shape.

Each actual cookie is an object created from that design.

Why Do We Use OOP?

OOP is useful because it helps us organize large applications.

Some important benefits are:

1. Better Organization

Related data and behavior can be kept together.

For example, instead of having:

customerName
customerEmail
customerAddress

sendEmail()
updateAddress()

scattered throughout the application, we can organize them inside a Customer class.

class Customer {

    String name;
    String email;
    String address;

    void sendEmail() {
        // send email
    }

    void updateAddress() {
        // update address
    }
}

2. Reusability

We can create a class once and create many objects from it.

For example:

Customer customer1 = new Customer();
Customer customer2 = new Customer();
Customer customer3 = new Customer();

We don't need to rewrite the customer logic for every customer.

3. Maintainability

Suppose the payment logic needs to change.

If payment-related logic is organized inside a Payment class, we can modify that class instead of searching through hundreds of unrelated functions.

4. Scalability

Large applications such as:

• Banking applications

• E-commerce platforms

• Food delivery applications

• Ride-booking applications

• Enterprise software

can contain many different objects.

OOP provides a structured way to model these entities and their interactions.

5. Security

Encapsulation allows us to control how sensitive data is accessed.

For example, a banking application should not allow users to directly modify their account balance.

Instead, operations such as:

deposit()
withdraw()

can validate the request before changing the balance.

The Four Pillars of OOP

OOP is commonly explained using four major concepts:

1. Encapsulation

2. Inheritance

3. Polymorphism

4. Abstraction

Let's understand each one using programming and real-world examples.

1. Encapsulation

Encapsulation means bundling data and the methods that operate on that data together, while controlling direct access to the data.

In simple words:

Keep data protected and provide controlled ways to access or modify it.

Real-world example: Bank Account

Consider a bank account.

You shouldn't be able to directly change your bank balance like this:

balance = -50000;

Instead, the bank should provide controlled operations such as:

deposit(5000);
withdraw(1000);

The bank can then check whether the operation is valid.

For example:

User
 │
 │ deposit(5000)
 ↓
Bank Account
 │
 ├── Check amount
 ├── Update balance
 └── Return result

Java example

class BankAccount {

    private double balance;

    public void deposit(double amount) {

        if (amount > 0) {
            balance += amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}

Here:

private double balance;

means that the balance cannot be directly accessed from outside the class.

Instead, we use methods such as:

deposit()
getBalance()

This gives us control over how the data is accessed and changed.

Another real-world example: ATM

When using an ATM, you don't directly manipulate the bank's database.

Instead, you perform controlled actions:

Insert Card
    ↓
Enter PIN
    ↓
Choose Withdraw
    ↓
Enter Amount
    ↓
Bank validates request
    ↓
Money is dispensed

The internal account data remains protected.

That is the basic idea behind encapsulation.

Why is encapsulation useful?

It helps:

• Protect data

• Prevent invalid modifications

• Control access

• Make code easier to maintain

2. Inheritance

Inheritance allows one class to acquire properties and behaviors from another class.

The existing class is commonly called the parent/superclass.

The new class is called the child/subclass.

Real-world example: Animal

Consider:

Animal
  │
  ├── Dog
  ├── Cat
  └── Bird

All these animals may have common behaviors such as:

• Eat

• Sleep

• Breathe

But each animal can also have its own behavior.

For example:

• Dog → Bark

• Cat → Meow

• Bird → Fly

Instead of writing the common functionality repeatedly, we can place it inside the parent class.

class Animal {

    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {

    void bark() {
        System.out.println("Dog is barking");
    }
}

Now:

Dog dog = new Dog();

dog.eat();
dog.bark();

The Dog object can use:

• eat() → inherited from Animal

• bark() → defined in Dog

Real-world software example

Imagine an e-commerce application.

We might have:

User
│
├── Customer
├── Seller
└── Admin

All users might share:

name
email
login()
logout()

But each type can have additional behavior.

Customer
 ├── placeOrder()
 └── addToCart()

Seller
 ├── addProduct()
 └── manageInventory()

Admin
 ├── manageUsers()
 └── generateReports()

Inheritance can help represent these shared relationships.

Important note

Inheritance should generally represent a genuine "is-a" relationship.

For example:

Dog is an Animal
Car is a Vehicle
SavingsAccount is an Account

But:

Car is an Engine

doesn't make sense.

A car has an engine, so that relationship is better modeled using composition rather than inheritance.

Types of inheritance

Common types include:

1. Single inheritance

2. Multilevel inheritance

3. Hierarchical inheritance

4. Multiple inheritance

5. Hybrid inheritance

However, the exact types supported depend on the programming language.

For example, Java does not support multiple inheritance through classes, but it can achieve multiple inheritance of type through interfaces.

3. Polymorphism

The word polymorphism comes from:

• Poly → many

• Morph → forms

So polymorphism means one interface/name can represent different forms of behavior.

In simple words:

The same method call can produce different behavior depending on the object.

There are two commonly discussed forms:

1. Compile-time polymorphism

2. Runtime polymorphism

Compile-Time Polymorphism

This is commonly achieved through method overloading.

Method overloading means having multiple methods with the same name but different parameter lists.

class Calculator {

    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

Both methods are named:

add()

But they accept different numbers of parameters.

Calculator calculator = new Calculator();

calculator.add(10, 20);

calculator.add(10, 20, 30);

The compiler determines which method should be called.

Therefore, this is called compile-time polymorphism.

Real-world example

Think about a food delivery application.

You might have a function:

calculateDeliveryFee()

But it could work differently depending on the parameters:

calculateDeliveryFee(distance)

calculateDeliveryFee(distance, peakTime)

calculateDeliveryFee(distance, peakTime, membership)

The method name remains the same, but the input parameters differ.

That's similar to method overloading.

Runtime Polymorphism

Runtime polymorphism is commonly achieved through method overriding.

A child class provides its own implementation of a method inherited from the parent class.

class Animal {

    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

Now:

Animal animal = new Dog();

animal.sound();

The reference type is Animal, but the actual object is Dog.

Therefore, the Dog implementation of sound() is executed.

This decision happens at runtime.

Real-world example: Payment system

Imagine an application supporting different payment methods:

Payment
│
├── CreditCardPayment
├── UpiPayment
└── NetBankingPayment

Each payment type can implement:

pay()

differently.

For example:

class Payment {
    void pay() {
        System.out.println("Processing payment");
    }
}

class UpiPayment extends Payment {

    @Override
    void pay() {
        System.out.println("Processing UPI payment");
    }
}

class CardPayment extends Payment {

    @Override
    void pay() {
        System.out.println("Processing card payment");
    }
}

Now:

Payment payment = new UpiPayment();

payment.pay();

The same:

payment.pay();

can produce different behavior depending on the actual object.

That's the power of runtime polymorphism.

Overloading vs Overriding

This is a very common interview question.

Easy way to remember

Overloading → Same name, different parameters

Overriding → Child changes parent's implementation

4. Abstraction

Abstraction means hiding unnecessary implementation details and exposing only the essential functionality.

Think about driving a car.

You know how to:

• Start the car

• Accelerate

• Brake

• Turn the steering wheel

But you don't need to understand every internal engine operation to drive it.

That's abstraction.

Real-world example: Food Delivery App

When you click:

"Place Order"

you don't need to know everything happening internally.

Behind the scenes, the system may:

Place Order
    ↓
Validate cart
    ↓
Calculate price
    ↓
Apply discount
    ↓
Process payment
    ↓
Create order
    ↓
Assign delivery partner
    ↓
Send notification

The user only sees:

Order Placed Successfully

The complicated implementation is hidden.

That is the basic idea of abstraction.

Abstraction in Java

Java commonly provides abstraction using:

• Abstract classes

• Interfaces

Abstract Class Example

abstract class Shape {

    abstract void draw();
}

Here, Shape defines that every shape should have a draw() method.

But it doesn't provide the actual implementation.

A child class can provide the implementation.

class Circle extends Shape {

    @Override
    void draw() {
        System.out.println("Drawing Circle");
    }
}

Now:

Shape shape = new Circle();

shape.draw();

The user only needs to know that a shape can be drawn.

The actual implementation is provided by Circle.

Real-world example: Payment

A payment system might define:

interface Payment {

    void pay();
}

Different payment methods can implement it:

class UPI implements Payment {

    public void pay() {
        System.out.println("Paying using UPI");
    }
}

class CreditCard implements Payment {

    public void pay() {
        System.out.println("Paying using Credit Card");
    }
}

The application only needs to know:

payment.pay();

It doesn't need to know all the internal details of how UPI or credit-card processing works.

Encapsulation vs Abstraction

These two concepts are often confused.

Encapsulation

Focuses on:

How do we protect and control access to data?

Example:

private double balance;

Encapsulation is about data + controlled access.

Abstraction

Focuses on:

What should the user see, and what implementation details can be hidden?

Example:

abstract void draw();

Abstraction is about exposing essential functionality while hiding unnecessary implementation details.

Easy way to remember

Encapsulation → Protect and control data

Abstraction → Hide implementation complexity

Quick Revision of the Four Pillars

A Complete Real-World Example: E-Commerce Application

Let's imagine we are building an application like Amazon or Flipkart.

Our application might contain:

E-Commerce System
│
├── User
├── Product
├── Cart
├── Order
├── Payment
└── Delivery

Now let's see how OOP concepts can be applied.

Encapsulation

A product's price should not be changed randomly.

class Product {

    private double price;

    public void setPrice(double price) {

        if (price >= 0) {
            this.price = price;
        }
    }

    public double getPrice() {
        return price;
    }
}

The price is protected and can only be changed through controlled logic.

Inheritance

Different types of users can share common functionality.

User
│
├── Customer
├── Seller
└── Admin

class User {

    void login() {
        System.out.println("User logged in");
    }
}

class Customer extends User {

    void placeOrder() {
        System.out.println("Order placed");
    }
}

Customer can reuse login() from User.

Polymorphism

Different payment methods can implement payment differently.

Payment
│
├── UPI
├── Credit Card
└── Net Banking

The application can simply call:

payment.pay();

The actual implementation depends on the payment object.

Abstraction

The user doesn't need to understand:

• Payment gateway communication

• Database transactions

• Fraud detection

• Order creation

• Inventory updates

The application can expose a simple operation:

Place Order

while hiding the complicated internal implementation.

OOP in Real Software Companies

OOP is not just an interview topic or a theoretical programming concept.

It is used to structure real software systems.

For example, an e-commerce system might contain classes such as:

User
Product
Cart
Order
Payment
Inventory
Delivery

A banking system might contain:

Customer
Account
SavingsAccount
Loan
Transaction
Payment
ATM

A ride-booking application might contain:

User
Driver
Passenger
Ride
Vehicle
Payment
Location

A hospital management system might contain:

Patient
Doctor
Appointment
Prescription
Billing
Hospital

The exact architecture depends on the company, programming language, and system design, but the idea of modeling related data and behavior using objects is widely used.

OOP in One Sentence

If you remember only one thing:

OOP is a way of organizing programs using objects that combine data and behavior, making code easier to organize, reuse, maintain, and extend.

And the four pillars are:

Encapsulation → Protect

Inheritance → Reuse

Polymorphism → Many forms

Abstraction → Hide complexity

Final Takeaway

OOP may look complicated at first because there are many new terms.

But the basic idea is simple:

Class
  ↓
Object
  ↓
Data + Behavior
  ↓
Organized Code

Then we use the four major OOP concepts:

Encapsulation → Protect and control data
Inheritance   → Reuse common behavior
Polymorphism  → Different behavior through a common interface
Abstraction   → Hide unnecessary implementation details

A simple memory trick

Think about a banking application:

             OOP
              │
     ┌────────┼─────────┐
     ↓        ↓         ↓
   Data    Behavior   Objects
     │        │         │
     └────────┴─────────┘
              │
       Four Pillars
              │
   ┌──────────┼───────────┐
   ↓          ↓           ↓          ↓
Encapsulation Inheritance Polymorphism Abstraction
   ↓          ↓           ↓          ↓
 Protect      Reuse       Different   Hide
 data         code        behavior    complexity

Once you understand these four concepts with real-world examples + small programs, OOP becomes much easier to understand and explain in interviews.

The key is not to memorize definitions.

Instead, ask yourself:

What is the object? What data does it have? What can it do? How should that data be protected? Can behavior be reused or changed? What implementation details can be hidden?

That way of thinking will help you understand OOP rather than simply memorizing it.

Today, I solved two LeetCode problems:

1. Maximum Average Subarray I

2. Maximum Number of Vowels in a Substring of Given Length

Both problems use a fixed-size sliding window.

The main idea is simple: instead of calculating every window from scratch, we maintain the current window and update it by removing the element that leaves and adding the element that enters.

Problems Solved

What is Sliding Window?

Sliding Window is a technique used when we need to work with a continuous subarray or substring.

Instead of repeatedly calculating information for every possible window, we maintain a window and slide it across the array or string.

For example:

nums = [1, 2, 3, 4, 5]
k = 3

The windows are:

[1, 2, 3]
   [2, 3, 4]
      [3, 4, 5]

Instead of calculating the sum of each window from scratch:

1 + 2 + 3
2 + 3 + 4
3 + 4 + 5

we can reuse the previous sum.

For example:

Old window:
[1, 2, 3]
sum = 6

Remove 1
Add 4

New window:
[2, 3, 4]
sum = 6 - 1 + 4
sum = 9

This reduces unnecessary work.

1. Maximum Average Subarray I

LeetCode: 643

Solve Maximum Average Subarray I on LeetCode

Problem

Given an integer array nums and an integer k, find the contiguous subarray of length k that has the maximum average value.

Example

Input:
nums = [1,12,-5,-6,50,3]
k = 4

Output:
12.75

The subarray is:

[12,-5,-6,50]

Its sum is:

12 + (-5) + (-6) + 50 = 51

Average:

51 / 4 = 12.75

Approach

Since every subarray must have exactly k elements, we can use a fixed-size sliding window.

Step 1

Calculate the sum of the first k elements.

[1,12,-5,-6]

Step 2

Store this as the initial maximum sum.

Step 3

Slide the window one position at a time.

When the window moves:

• Remove the element leaving the window.

• Add the new element entering the window.

• Update the maximum sum.

Finally:

maximum average = maximum sum / k

Code

var findMaxAverage = function (nums, k) {
    let sum = 0;

    // Calculate the first window
    for (let i = 0; i < k; i++) {
        sum += nums[i];
    }

    let maxSum = sum;

    // Slide the window
    for (let i = k; i < nums.length; i++) {
        sum = sum - nums[i - k] + nums[i];

        maxSum = Math.max(maxSum, sum);
    }

    return maxSum / k;
};

How It Works

Consider:

nums = [1,12,-5,-6,50,3]
k = 4

First window:

[1,12,-5,-6]

sum = 1 + 12 - 5 - 6
    = 2

So:

maxSum = 2

Now slide the window.

Remove:

1

Add:

50

New window:

[12,-5,-6,50]

New sum:

2 - 1 + 50
= 51

Update:

maxSum = 51

Next window:

[-5,-6,50,3]

Update:

51 - 12 + 3
= 42

The maximum sum remains:

51

Therefore:

51 / 4 = 12.75

Complexity

Time:  O(n)
Space: O(1)

We visit each element essentially once.

2. Maximum Number of Vowels in a Substring of Given Length

LeetCode: 1456

Solve Maximum Number of Vowels in a Substring of Given Length on LeetCode

Problem

Given a string s and an integer k, find the maximum number of vowels in any substring of length k.

The vowels are:

a, e, i, o, u

Example

Input:
s = "abciiidef"
k = 3

Output:
3

The substring:

"iii"

contains 3 vowels.

Approach

Again, we use a fixed-size sliding window.

Instead of calculating the number of vowels in every substring separately, maintain the vowel count of the current window.

When the window moves:

1. Check the character leaving the window.

2. If it is a vowel, decrease the count.

3. Check the new character entering the window.

4. If it is a vowel, increase the count.

5. Update the maximum.

Code

var maxVowels = function(s, k) {
    let vowels = new Set(['a', 'e', 'i', 'o', 'u']);

    let count = 0;

    // Count vowels in the first window
    for (let i = 0; i < k; i++) {
        if (vowels.has(s[i])) {
            count++;
        }
    }

    let maxCount = count;

    // Slide the window
    for (let i = k; i < s.length; i++) {
        // Remove the character leaving the window
        if (vowels.has(s[i - k])) {
            count--;
        }

        // Add the character entering the window
        if (vowels.has(s[i])) {
            count++;
        }

        maxCount = Math.max(maxCount, count);
    }

    return maxCount;
};

How It Works

Consider:

s = "abciiidef"
k = 3

First window:

"abc"

Vowels:

a → 1

So:

count = 1
maxCount = 1

Move the window:

"bci"

The character leaving:

a

is a vowel.

So:

count--

The character entering:

i

is a vowel.

So:

count++

The new count is:

1

Continue sliding.

Eventually we get:

"iii"

which contains:

3 vowels

Therefore:

maxCount = 3

Why Use a Set?

I used a JavaScript Set to store the vowels:

let vowels = new Set(['a', 'e', 'i', 'o', 'u']);

Then we can check whether a character is a vowel using:

vowels.has(s[i])

This makes the vowel-checking logic clean and easy to understand.

Complexity

Time:  O(n)
Space: O(1)

The Set contains only 5 vowels, so its size is constant.

Fixed-Size Sliding Window

Today's two problems follow almost the same structure.

The general pattern is:

// 1. Build the first window

// 2. Store the current result

// 3. Slide the window

// 4. Remove the element leaving

// 5. Add the element entering

// 6. Update the result

Visually:

[ a b c ] d e
  ↓
a [ b c d ] e
  ↓
a b [ c d e ]

The window always contains exactly k elements.

Why Sliding Window Is Better

Suppose:

n = 1000
k = 100

A brute-force solution might calculate the information for every window again.

Sliding Window avoids that repeated work.

Instead of:

Calculate window
Calculate next window from scratch
Calculate next window from scratch
...

we do:

Current window
     ↓
Remove outgoing element
     ↓
Add incoming element
     ↓
Next window

This often changes the solution from O(n × k) to O(n).

Pattern Recognition

When should I think about Sliding Window?

Look for clues such as:

• Contiguous subarray

• Substring

• Window of size k

• Maximum/minimum in a fixed-length range

• Count/sum inside a continuous range

• Longest/shortest substring or subarray

• Need to examine consecutive elements

A particularly strong clue is:

"Find something in every subarray/substring of size k."

That should immediately make me think:

Fixed-Size Sliding Window

What I Learned Today

Today I learned that Sliding Window is mainly about reusing the previous window's work.

Instead of recalculating everything:

Old Window
    ↓
Remove one element
    ↓
Add one element
    ↓
New Window

I also learned that the same pattern can work with different types of information:

Sum

Used in:

Maximum Average Subarray I

sum = sum - outgoing + incoming

Count

Used in:

Maximum Number of Vowels

count = count - outgoing + incoming

So the underlying pattern stays the same even though the calculation changes.

Day 7 Summary

Today I solved:

643  → Maximum Average Subarray I
1456 → Maximum Number of Vowels in a Substring of Given Length

Main pattern:

Fixed-Size Sliding Window

The most important formula I learned today is:

New Window
= Old Window
- Element Leaving
+ Element Entering

Key Takeaway

When a problem asks you to examine every contiguous subarray or substring of a fixed size, think Sliding Window before using nested loops.

Day 7 complete.

Today, I solved 5 LeetCode problems:

1. Container With Most Water

2. Is Subsequence

3. Squares of a Sorted Array

4. 3Sum

5. Trapping Rain Water

These problems helped me understand how two pointers can reduce unnecessary nested loops and improve the efficiency of solutions.

Problems Solved

1. Container With Most Water

LeetCode: 11

Solve Container With Most Water on LeetCode

Problem

You are given an array height, where each element represents the height of a vertical line.

Choose two lines that together with the x-axis form a container that holds the most water.

The amount of water is:

min(height[i], height[j]) × (j - i)

Example

Input:
[1,8,6,2,5,4,8,3,7]

Output:
49

The maximum area is created by heights 8 and 7.

min(8,7) × (8-1)
= 7 × 7
= 49

Approach

Start with two pointers:

left  → beginning
right → end

Calculate the area between them.

Then move the pointer pointing to the shorter height.

Why?

The width decreases every time we move a pointer.

So, to potentially get a larger area, we need to find a taller boundary.

Code

var maxArea = function(height) {
    let i = 0;
    let j = height.length - 1;
    let maxWater = 0;

    while (i < j) {
        let area = Math.min(height[i], height[j]) * (j - i);

        maxWater = Math.max(maxWater, area);

        if (height[i] > height[j]) {
            --j;
        } else {
            ++i;
        }
    }

    return maxWater;
};

How It Works

Suppose:

height = [1,8,6,2,5,4,8,3,7]

Initially:

i = 0
j = 8

We calculate:

min(1,7) × 8 = 8

Since height[i] is smaller, move i.

We continue this process until:

i >= j

Throughout the process, maxWater stores the maximum area found.

Complexity

Time:  O(n)
Space: O(1)

Pattern

Two Pointers

Key idea

When the calculation depends on two ends of an array and one pointer can be safely moved based on a condition, think about Two Pointers.

2. Is Subsequence

LeetCode: 392

Solve Is Subsequence on LeetCode

Problem

Given two strings s and t, determine whether s is a subsequence of t.

A subsequence means the characters of s must appear in t in the same order, but they don't have to be next to each other.

Example

s = "abc"
t = "ahbgdc"

Output:
true

Because:

a → h → b → g → d → c
^       ^           ^
a       b           c

The characters a, b, and c appear in the correct order.

Approach

Use two pointers:

i → s
j → t

If:

s[i] === t[j]

we found the next required character, so move i.

Always move j because we are scanning through t.

At the end:

i === s.length

means every character in s was found.

Code

var isSubsequence = function(s, t) {
    let i = 0;
    let j = 0;

    while (j < t.length) {
        if (s[i] === t[j]) {
            ++i;
        }

        ++j;
    }

    return i === s.length;
};

How It Works

Example:

s = "abc"
t = "ahbgdc"

We compare:

a == a → match → move i
b != h → move j
b == b → match → move i
c != g → move j
c != d → move j
c == c → match → move i

Now:

i === s.length

So the answer is:

true

Complexity

Let:

m = s.length
n = t.length

Time:  O(n)
Space: O(1)

Pattern

Two Pointers

This is a good example of using two pointers when comparing two sequences while maintaining their relative order.

3. Squares of a Sorted Array

LeetCode: 977

Solve Squares of a Sorted Array on LeetCode

Problem

Given a sorted array containing negative and positive integers, return an array containing the squares of every number, also sorted in non-decreasing order.

Example

Input:
[-4,-1,0,3,10]

Output:
[0,1,9,16,100]

The Challenge

Although the original array is sorted:

[-4,-1,0,3,10]

after squaring:

[16,1,0,9,100]

it is no longer sorted.

The largest square can come from either:

• the left side because of a large negative number

• the right side because of a large positive number

Approach

Use two pointers:

left  → beginning
right → end

Compare:

nums[left]²
nums[right]²

The larger square belongs at the end of the result array.

So we fill the result from right to left.

Code

var sortedSquares = function(nums) {
    let n = nums.length;
    let res = [];

    let left = 0;
    let right = n - 1;
    let x = n - 1;

    while (left <= right) {
        let leftSq = nums[left] * nums[left];
        let rightSq = nums[right] * nums[right];

        if (leftSq > rightSq) {
            res[x] = leftSq;
            left++;
        } else {
            res[x] = rightSq;
            right--;
        }

        x--;
    }

    return res;
};

How It Works

For:

[-4,-1,0,3,10]

Compare the two ends:

(-4)² = 16
10²   = 100

100 is larger, so:

res[4] = 100

Move right.

Then compare again.

We continue filling:

[0,1,9,16,100]

from right to left.

Complexity

Time:  O(n)
Space: O(n)

The result array itself requires O(n) space.

Pattern

Two Pointers + Sorted Array

Key observation

When an array is sorted and you need to compare the largest values from both ends, check whether Two Pointers can avoid sorting again.

4. 3Sum

LeetCode: 15

Solve 3Sum on LeetCode

Problem

Given an integer array nums, find all unique triplets:

[a, b, c]

such that:

a + b + c = 0

The solution should not contain duplicate triplets.

Example

Input:
[-1,0,1,2,-1,-4]

Output:
[[-1,-1,2],[-1,0,1]]

Approach

The important idea is:

Sort the array first.

For example:

[-1,0,1,2,-1,-4]

becomes:

[-4,-1,-1,0,1,2]

Then:

1. Fix one number.

2. Use two pointers for the remaining part.

3. Move the pointers depending on the sum.

4. Skip duplicates.

So the problem becomes:

One fixed pointer + Two Pointers

Code

var threeSum = function(nums) {
    nums.sort((a, b) => a - b);

    let ans = [];

    for (let i = 0; i < nums.length; i++) {
        if (i === 0 || nums[i] !== nums[i - 1]) {
            twoSum(nums, i, ans);
        }
    }

    return ans;
};

var twoSum = function(arr, x, ans) {
    let i = x + 1;
    let j = arr.length - 1;

    while (i < j) {
        let sum = arr[x] + arr[i] + arr[j];

        if (sum > 0) {
            j--;
        } else if (sum < 0) {
            i++;
        } else {
            ans.push([arr[x], arr[i], arr[j]]);

            i++;
            j--;

            while (i < j && arr[i] === arr[i - 1]) {
                i++;
            }
        }
    }
};

How It Works

After sorting:

[-4,-1,-1,0,1,2]

Suppose:

arr[x] = -1

Now use two pointers:

i → next element
j → last element

Calculate:

-1 + arr[i] + arr[j]

If sum < 0

We need a larger value.

Move:

i++

If sum > 0

We need a smaller value.

Move:

j--

If sum === 0

We found a valid triplet.

Then move both pointers and skip duplicates.

Why Sorting Is Important

Sorting makes two things possible:

1. Two-pointer movement

Because the values are ordered, we know which pointer to move based on the sum.

2. Duplicate handling

For example:

[-1,-1,0,1]

If we process both -1s as starting points, we may generate duplicate triplets.

So we skip repeated values:

if (i === 0 || nums[i] !== nums[i - 1])

Complexity

Sorting:

O(n log n)

Two-pointer search for each element:

O(n²)

Overall:

Time:  O(n²)
Space: O(log n)*

O(log n) is the typical auxiliary space associated with the JavaScript sorting implementation for the in-place sort, though the exact implementation-dependent stack usage can vary.

The returned answer itself requires additional space proportional to the number of triplets.

Pattern

Sorting + Two Pointers

This is an important pattern:

3Sum
   ↓
Sort
   ↓
Fix one element
   ↓
Two Pointers

5. Trapping Rain Water

LeetCode: 42

Solve Trapping Rain Water on LeetCode

Problem

Given an array representing an elevation map, calculate how much rainwater can be trapped after raining.

Example

Input:
[0,1,0,2,1,0,1,3,2,1,2,1]

Output:
6

Key Idea

For every position, the amount of water it can hold depends on:

minimum(
    maximum height on the left,
    maximum height on the right
)
- current height

Formula:

water[i] =
min(maxL[i], maxR[i]) - height[i]

If the result is negative, we don't add water.

Approach

Create two arrays:

maxL
maxR

maxL

maxL[i] stores the maximum height from the left up to index i.

maxR

maxR[i] stores the maximum height from the right up to index i.

Then calculate:

min(maxL[i], maxR[i]) - height[i]

for every position.

Code

var trap = function(height) {
    let n = height.length;

    let maxL = [];
    maxL[0] = height[0];

    let maxR = [];
    maxR[n - 1] = height[n - 1];

    for (let i = 1; i < n; i++) {
        maxL[i] = Math.max(maxL[i - 1], height[i]);

        maxR[n - 1 - i] =
            Math.max(maxR[n - i], height[n - 1 - i]);
    }

    let ans = 0;

    for (let i = 0; i < n; i++) {
        ans += Math.max(
            Math.min(maxL[i], maxR[i]) - height[i],
            0
        );
    }

    return ans;
};

How It Works

Consider:

[4,2,0,3,2,5]

At index 2:

height = 0

Maximum height on the left:

4

Maximum height on the right:

5

The smaller boundary is:

min(4,5) = 4

Therefore:

water = 4 - 0
      = 4

The same calculation is performed for every position.

Complexity

Time:  O(n)
Space: O(n)

We use two additional arrays:

maxL
maxR

What I Learned Today

Day 6 helped me understand that the Two Pointers pattern is not limited to simple left-right traversal.

I learned several variations:

1. Two pointers from opposite ends

Used in:

• Container With Most Water

• Squares of a Sorted Array

2. Two pointers across two sequences

Used in:

• Is Subsequence

3. Fixed pointer + two pointers

Used in:

• 3Sum

4. Prefix and suffix maximums

Used in:

• Trapping Rain Water

Pattern Recognition

One of the biggest things I am learning from solving DSA problems is that the main challenge is not always writing the code.

The important question is:

What pattern does this problem belong to?

Today, I noticed these clues:

Day 6 Summary

Today I solved:

11   → Container With Most Water
392  → Is Subsequence
977  → Squares of a Sorted Array
15   → 3Sum
42   → Trapping Rain Water

The major patterns were:

Two Pointers
     ↓
Sorting + Two Pointers
     ↓
Prefix/Suffix Maximum

The biggest takeaway from today is that Two Pointers is a technique, not just one fixed algorithm.

Depending on the problem, the pointers can:

• Start from both ends

• Move through two different sequences

• Work around a fixed element

• Build a result from either direction

Key Takeaway

Before writing nested loops, ask yourself: Can two pointers reduce the number of comparisons?

Day 6 complete.

Today, I learned and practiced the Two Pointers pattern.

The two-pointer technique uses two indexes to traverse an array or string efficiently. Depending on the problem, the pointers can move:

• Toward each other

• In the same direction

• At different speeds

Today I solved four problems using this pattern.

Problems Solved

1. Valid Palindrome

Problem

Given a string s, determine whether it is a palindrome after converting uppercase letters to lowercase and removing all non-alphanumeric characters.

A palindrome reads the same forward and backward.

Example

Input:
"A man, a plan, a canal: Panama"

Output:
true

After removing spaces and punctuation and converting to lowercase:

amanaplanacanalpanama

It reads the same from both directions.

Approach

Use two pointers:

i → starts from the beginning
j → starts from the end

If the character at i is not alphanumeric, move i.

If the character at j is not alphanumeric, move j.

Otherwise, compare both characters.

If they are different, return false.

If they are the same, move both pointers toward the center.

Code

var isPalindrome = function (s) {
    s = s.toLowerCase();

    let i = 0;
    let j = s.length - 1;

    while (i < j) {
        if (!s[i].match(/[a-z0-9]/i)) {
            i++;
        } else if (!s[j].match(/[a-z0-9]/i)) {
            j--;
        } else if (s[i] === s[j]) {
            i++;
            j--;
        } else {
            return false;
        }
    }

    return true;
};

How It Works

For:

"A man, a plan, a canal: Panama"

The pointers compare valid characters from both ends:

a ↔ a
m ↔ m
a ↔ a
n ↔ n
...

Whenever a space or punctuation is encountered, that pointer skips it.

If every valid character matches, the string is a palindrome.

Complexity

• Time: O(n)

• Space: O(n)

The space is O(n) here because toLowerCase() creates a new string in JavaScript.

Pattern

Two Pointers

2. Move Zeroes

Problem

Given an integer array, move all 0s to the end while maintaining the relative order of the non-zero elements.

The operation must be performed in-place.

Example

Input:
[0,1,0,3,12]

Output:
[1,3,12,0,0]

Approach

Use a pointer x to represent the position where the next non-zero element should be placed.

Traverse the array with i.

Whenever we find a non-zero value:

nums[x] = nums[i];
x++;

After moving all non-zero values, fill the remaining positions with zeroes.

Code

var moveZeroes = function (nums) {
    let x = 0;

    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== 0) {
            nums[x] = nums[i];
            x++;
        }
    }

    for (let i = x; i < nums.length; i++) {
        nums[i] = 0;
    }
};

How It Works

For:

[0,1,0,3,12]

Non-zero values are moved toward the beginning:

[1,3,12,3,12]

Then the remaining positions are replaced with zero:

[1,3,12,0,0]

The important idea is that x tracks where the next non-zero element belongs.

Complexity

• Time: O(n)

• Space: O(1)

Pattern

Two Pointers / In-place Array Modification

3. Remove Duplicates from Sorted Array

Problem

Given a sorted array, remove duplicates in-place so that each unique element appears only once.

Return the number of unique elements.

Example

Input:
[1,1,2]

Output:
2

Array becomes:
[1,2,_]

Approach

Because the array is sorted, duplicate values are next to each other.

Use:

• i to scan the array

• x to track the position of the last unique element

Whenever:

nums[i] !== nums[x]

we have found a new unique value.

Move x forward and store the new value there.

Code

var removeDuplicates = function (nums) {
    let x = 0;

    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== nums[x]) {
            x++;
            nums[x] = nums[i];
        }
    }

    return x + 1;
};

How It Works

For:

[1,1,2,2,3]

Initially:

x = 0

1 is already at the correct position.

When we find 2:

x = 1
nums[1] = 2

When we find 3:

x = 2
nums[2] = 3

The beginning of the array becomes:

[1,2,3,...]

So the number of unique elements is:

x + 1 = 3

Complexity

• Time: O(n)

• Space: O(1)

Pattern

Two Pointers / Slow and Fast Pointer

4. Two Sum II - Input Array Is Sorted

Problem

Given a 1-indexed array of integers that is already sorted in non-decreasing order, find two numbers that add up to a specific target.

Return their indices.

Example

Input:
numbers = [2,7,11,15]
target = 9

Output:
[1,2]

Because:

2 + 7 = 9

Approach

Since the array is sorted, use two pointers:

i → beginning
j → end

Calculate:

sum = nums[i] + nums[j]

There are three possibilities.

If sum equals target

Return the two indices.

If sum is smaller than target

Move i forward.

Why?

Because we need a larger sum, and the array is sorted.

If sum is greater than target

Move j backward.

Why?

Because we need a smaller sum.

Code

var twoSum = function (nums, target) {
    let i = 0;
    let j = nums.length - 1;

    while (i < j) {
        let sum = nums[i] + nums[j];

        if (sum === target) {
            return [i + 1, j + 1];
        }

        if (sum < target) {
            i++;
        } else {
            j--;
        }
    }

    return [];
};

How It Works

For:

numbers = [2,7,11,15]
target = 9

Initially:

i = 0 → 2
j = 3 → 15

Calculate:

2 + 15 = 17

Too large, so move j:

2 + 11 = 13

Still too large:

2 + 7 = 9

Target found.

Return:

[1,2]

Why Does This Work?

The array is sorted.

If:

nums[i] + nums[j] < target

we need a larger value, so moving i right is useful.

If:

nums[i] + nums[j] > target

we need a smaller value, so moving j left is useful.

This allows us to solve the problem without checking every pair.

Complexity

• Time: O(n)

• Space: O(1)

Pattern

Two Pointers

Understanding the Two Pointer Pattern

There are different ways to use two pointers.

1. Pointers Moving Toward Each Other

Example:

Valid Palindrome
Two Sum II

i → → → 
← ← ← j

The pointers start at opposite ends and move toward the center.

2. Pointers Moving in the Same Direction

Example:

Move Zeroes
Remove Duplicates

One pointer scans the array while another pointer tracks where the next valid element should go.

This is sometimes described as the slow and fast pointer technique.

Pattern Recognition

When should I think about Two Pointers?

Look for clues such as:

Sorted array
Palindrome
Pair of elements
In-place modification
Remove duplicates
Move elements
Compare elements from both ends

A useful mental checklist:

Is the input sorted?
        ↓
Can I avoid nested loops?
        ↓
Can two indexes represent the current state?
        ↓
Try Two Pointers

What I Learned Today

1. Two Pointers Can Reduce Nested Loops

A brute-force pair search might use:

O(n²)

But when the array is sorted, two pointers can often reduce it to:

O(n)

2. Sorted Data Gives Us Information

In Two Sum II, the sorted order tells us which pointer to move.

This is an important problem-solving idea:

Use the properties of the input to eliminate unnecessary work.

3. Two Pointers Are Useful for In-place Problems

Move Zeroes and Remove Duplicates demonstrate how pointers can modify an array without creating another array.

4. Pointer Movement Must Have a Reason

Don't move a pointer randomly.

For every pointer movement, ask:

Why am I moving this pointer?
What information does this movement give me?

For example, in Two Sum II:

sum < target
    ↓
Need a bigger value
    ↓
Move left pointer right

and:

sum > target
    ↓
Need a smaller value
    ↓
Move right pointer left

Day 5 Summary

Key Takeaway

The biggest lesson from Day 5 is:

Two pointers are not just about using two variables called i and j. The important part is understanding what each pointer represents and why it should move.

Before using the pattern, ask:

1. Is the data sorted?

2. Can I compare elements from both ends?

3. Can I use one pointer to scan and another to track a position?

4. Can pointer movement eliminate unnecessary comparisons?

If the answer is yes, Two Pointers may be the right pattern.

Day 5 / 30

Today, I continued practicing Hashing, Set, and Frequency Counting patterns.

The problems I solved today show how hash-based data structures can be used for different purposes:

• Counting frequencies

• Grouping similar elements

• Detecting consecutive sequences

• Tracking previously seen values

• Validating rows, columns, and sub-boxes

Problems Solved

1. Majority Element

Problem

Given an array nums, return the majority element.

The majority element is the element that appears more than n / 2 times.

Example

Input:
[2,2,1,1,1,2,2]

Output:
2

The number 2 appears more than n / 2 times.

Approach

Use a hash map to count the frequency of every number.

After building the frequency map, find the number with the highest frequency.

Code

var majorityElement = function (nums) {
    let map = new Map();

    for (let num of nums) {
        map.set(num, (map.get(num) || 0) + 1);
    }

    let majority = nums[0];
    let maxCount = 0;

    for (let [num, count] of map) {
        if (count > maxCount) {
            maxCount = count;
            majority = num;
        }
    }

    return majority;
};

How It Works

For:

[2,2,1,1,1,2,2]

The frequency map becomes:

2 → 4
1 → 3

The element with the highest frequency is 2.

Complexity

• Time: O(n)

• Space: O(n)

Optimized Approach

The problem can also be solved using the Boyer-Moore Voting Algorithm.

var majorityElement = function (nums) {
    let candidate = 0;
    let count = 0;

    for (let num of nums) {
        if (count === 0) {
            candidate = num;
        }

        if (num === candidate) {
            count++;
        } else {
            count--;
        }
    }

    return candidate;
};

Complexity

• Time: O(n)

• Space: O(1)

2. First Unique Character in a String

Problem

Given a string s, find the first non-repeating character and return its index.

If no unique character exists, return -1.

Example

Input:
"leetcode"

Output:
0

The character l appears only once and is the first unique character.

Approach

Use a hash map to count the frequency of every character.

Then traverse the string again from left to right.

The first character whose frequency is 1 is the answer.

Code

var firstUniqChar = function (s) {
    let map = {};

    for (let char of s) {
        map[char] = (map[char] || 0) + 1;
    }

    for (let i = 0; i < s.length; i++) {
        if (map[s[i]] === 1) {
            return i;
        }
    }

    return -1;
};

How It Works

For:

"leetcode"

The frequency map is:

l → 1
e → 3
t → 1
c → 1
o → 1
d → 1

We scan from left to right.

l has a frequency of 1, so we return index 0.

Complexity

• Time: O(n)

• Space: O(k)

Where k is the number of distinct characters.

3. Group Anagrams

Problem

Given an array of strings, group the anagrams together.

Two strings are anagrams if they contain the same characters with the same frequencies.

Example

Input:
["eat","tea","tan","ate","nat","bat"]

Output:
[
    ["eat","tea","ate"],
    ["tan","nat"],
    ["bat"]
]

Approach

The important observation is:

"eat"
"tea"
"ate"

If we sort the characters, all three become:

"aet"

So the sorted string can be used as the key in a hash map.

Code

var groupAnagrams = function (strs) {
    let map = {};

    for (let str of strs) {
        let sortedStr = str.split("").sort().join("");

        if (!map[sortedStr]) {
            map[sortedStr] = [str];
        } else {
            map[sortedStr].push(str);
        }
    }

    return Object.values(map);
};

How It Works

For:

["eat", "tea", "tan", "ate", "nat", "bat"]

The keys become:

eat → aet
tea → aet
tan → ant
ate → aet
nat → ant
bat → abt

The hash map becomes:

aet → ["eat", "tea", "ate"]
ant → ["tan", "nat"]
abt → ["bat"]

Then:

Object.values(map)

returns the grouped arrays.

Complexity

Let:

• n = number of strings

• k = maximum length of a string

Sorting each string takes O(k log k).

Therefore:

• Time: O(n × k log k)

• Space: O(n × k)

Pattern Recognition

When you need to group anagrams, convert each string into a common representation.

eat → aet
tea → aet
ate → aet

The common representation becomes the hash map key.

4. Longest Consecutive Sequence

Problem

Given an unsorted array of integers, find the length of the longest consecutive elements sequence.

The algorithm must run in O(n) time.

Example

Input:
[100,4,200,1,3,2]

Output:
4

The longest consecutive sequence is:

1 → 2 → 3 → 4

So the answer is 4.

Approach

Put all numbers into a Set.

A number is the beginning of a sequence only if:

!set.has(num - 1)

For example:

1

is a starting point because 0 does not exist.

But:

2

is not a starting point because 1 exists.

From every starting number, keep checking:

num + 1
num + 2
num + 3
...

and count the sequence length.

Code

var longestConsecutive = function (nums) {
    let set = new Set(nums);
    let longest = 0;

    for (let num of set) {
        if (!set.has(num - 1)) {
            let curr = num;
            let count = 1;

            while (set.has(curr + 1)) {
                curr++;
                count++;
            }

            longest = Math.max(longest, count);
        }
    }

    return longest;
};

How It Works

For:

[100,4,200,1,3,2]

The set contains:

{100, 4, 200, 1, 3, 2}

Start with 1.

Check:

0 → doesn't exist

So 1 is the beginning.

Then:

1 → 2 → 3 → 4

Count:

4

Then:

longest = 4;

Why Do We Check num - 1?

Suppose:

1, 2, 3, 4

If we start counting from every number, we would repeatedly scan the same sequence.

Instead:

if (!set.has(num - 1))

means:

Only start counting if this number is the beginning of a sequence.

Therefore:

1 → start
2 → don't start
3 → don't start
4 → don't start

This allows the solution to achieve expected O(n) time.

Complexity

• Time: O(n) expected

• Space: O(n)

5. Valid Sudoku

Problem

Determine whether a partially filled 9 × 9 Sudoku board is valid.

A Sudoku board is valid if:

• Each row contains no repeated digit.

• Each column contains no repeated digit.

• Each 3 × 3 box contains no repeated digit.

• Empty cells are represented by ..

Approach

We need to keep track of three things:

Rows
Columns
3 × 3 Boxes

For each cell, check whether the value already exists in:

row
column
box

If it exists in any of them, the board is invalid.

Otherwise, add it to all three sets.

Code

var isValidSudoku = function (board) {
    let rows = Array.from({ length: 9 }, () => new Set());
    let columns = Array.from({ length: 9 }, () => new Set());
    let boxes = Array.from({ length: 9 }, () => new Set());

    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            let value = board[i][j];

            if (value === ".") {
                continue;
            }

            let boxIndex =
                Math.floor(i / 3) * 3 +
                Math.floor(j / 3);

            if (
                rows[i].has(value) ||
                columns[j].has(value) ||
                boxes[boxIndex].has(value)
            ) {
                return false;
            }

            rows[i].add(value);
            columns[j].add(value);
            boxes[boxIndex].add(value);
        }
    }

    return true;
};

Understanding the Box Index

The board has 9 boxes:

0 | 1 | 2
---------
3 | 4 | 5
---------
6 | 7 | 8

The formula is:

let boxIndex =
    Math.floor(i / 3) * 3 +
    Math.floor(j / 3);

For example:

i = 1
j = 4

Then:

Math.floor(1 / 3) = 0
Math.floor(4 / 3) = 1

0 × 3 + 1 = 1

So the cell belongs to box 1.

Complexity

Because the Sudoku board is always 9 × 9:

• Time: O(1)

• Space: O(1)

For a generalized n × n board:

• Time: O(n²)

• Space: O(n²)

What I Learned Today

1. Hashing Is More Than Frequency Counting

Hashing can be used for:

Frequency counting
Grouping
Fast lookup
Duplicate detection
Sequence detection
Validation

2. Two-Pass Technique

A useful pattern is:

First pass
    ↓
Collect information

Second pass
    ↓
Use that information to find the answer

We used this pattern in First Unique Character.

3. Canonical Representation

Group Anagrams taught me an important technique.

Different inputs can be converted into the same representation:

eat → aet
tea → aet
ate → aet

That common representation becomes the hash map key.

4. Set for Fast Lookup

Longest Consecutive Sequence showed why a Set is useful.

Instead of searching an array repeatedly:

set.has(value)

provides average O(1) lookup.

5. Start From the Beginning of a Sequence

For Longest Consecutive Sequence, this condition is extremely important:

if (!set.has(num - 1))

It prevents repeatedly processing the same sequence.

6. Multiple Sets Can Track Multiple Constraints

Valid Sudoku uses separate Sets for:

Rows
Columns
Boxes

This is useful when a problem has multiple independent constraints.

Day 4 Summary

Day 4 Pattern Recognition

Frequency
    ↓
HashMap / Frequency Counting

Group similar values
    ↓
HashMap + Common Key

Fast existence check
    ↓
Set

Consecutive sequence
    ↓
Set + Check Previous Number

Multiple validation constraints
    ↓
Multiple Sets / Maps

Key Takeaway

The main lesson from Day 4 is:

Don't just ask "Which data structure should I use?" Ask "What information do I need to remember while traversing the input?"

If I need to remember:

• how many times something appeared → HashMap

• whether something exists → Set

• a relationship between values → Map

• information about multiple groups → Multiple Maps/Sets

This helps me recognize the pattern before writing the code.

Day 4 / 30

Problem

Given an array of integers and a target, return the indices of two numbers whose sum equals the target.

Approach

For every number, I calculate the value I need:

needed = target - current number

Before storing the current number, I check whether the required value already exists in the Map.

If it exists, I have found the two numbers.

function twoSum(nums, target) {
    let map = new Map();

    for (let i = 0; i < nums.length; i++) {
        let needed = target - nums[i];

        if (map.has(needed)) {
            return [map.get(needed), i];
        }

        map.set(nums[i], i);
    }

    return [];
}

Example

nums = [2, 7, 11, 15]
target = 9

i = 0
current = 2
needed = 9 - 2 = 7
7 is not in Map
store 2 → 0

i = 1
current = 7
needed = 9 - 7 = 2
2 is already in Map

Therefore:

[0, 1]

Complexity

• Time: O(n)

• Space: O(n)

Pattern

HashMap / Complement Lookup

2. Contains Duplicate — LeetCode 217

Problem

Determine whether an array contains any duplicate value.

Approach

I use a Set to store the numbers I have already seen.

If the current number already exists in the Set, a duplicate has been found.

var containsDuplicate = function(nums) {
    let set = new Set();

    for (let num of nums) {
        if (set.has(num)) {
            return true;
        }

        set.add(num);
    }

    return false;
};

Complexity

• Time: O(n)

• Space: O(n)

Pattern

Set / Seen Elements

3. Intersection of Two Arrays — LeetCode 349

Problem

Return the unique elements that appear in both arrays.

Approach

I store all elements of nums2 in a Set.

Then I traverse nums1. If an element exists in the first Set, I add it to another Set called result.

Using a Set for the result automatically removes duplicates.

var intersection = function(nums1, nums2) {
    let set = new Set();
    let result = new Set();

    for (let num of nums2) {
        set.add(num);
    }

    for (let num of nums1) {
        if (set.has(num)) {
            result.add(num);
        }
    }

    return Array.from(result);
};

Example

nums1 = [1, 2, 2, 1]
nums2 = [2, 2]

Elements in nums2:

{2}

While traversing nums1, 2 is found.

Result:

[2]

Complexity

Let n1 and n2 be the lengths of the two arrays.

• Time: O(n1 + n2)

• Space: O(n1 + n2)

Pattern

Set / Membership Lookup

4. Ransom Note — LeetCode 383

Problem

Determine whether the ransom note can be constructed using the characters available in the magazine.

Each character in the magazine can only be used once.

Approach

First, I count how many times each character appears in the magazine.

Then I traverse the ransom note and decrease the corresponding count.

If a required character doesn't have enough occurrences, I return false.

var canConstruct = function(ransomNote, magazine) {
    let count = {};

    for (let char of magazine) {
        count[char] = (count[char] || 0) + 1;
    }

    for (let char of ransomNote) {
        if (!count[char]) {
            return false;
        }

        count[char]--;
    }

    return true;
};

Example

ransomNote = "aa"
magazine = "aab"

Magazine frequency:

a → 2
b → 1

Process ransom note:

a → count becomes 1
a → count becomes 0

All required characters are available.

Result:

true

Complexity

If m is the ransom note length and n is the magazine length:

• Time: O(m + n)

• Space: O(k), where k is the number of distinct characters.

For the problem's fixed lowercase English alphabet, this can be considered O(1) auxiliary space.

Pattern

Frequency Counting

5. Isomorphic Strings — LeetCode 205

Problem

Determine whether two strings are isomorphic.

Each character in the first string must map to exactly one character in the second string, and two different characters cannot map to the same character.

Approach

I need to maintain the mapping in both directions:

s → t
t → s

This prevents two different characters from mapping to the same character.

A Map is cleaner and safer than a plain object.

var isIsomorphic = function(s, t) {
    let mapStoT = new Map();
    let mapTtoS = new Map();

    for (let i = 0; i < s.length; i++) {
        let charS = s[i];
        let charT = t[i];

        if (
            (mapStoT.has(charS) && mapStoT.get(charS) !== charT) ||
            (mapTtoS.has(charT) && mapTtoS.get(charT) !== charS)
        ) {
            return false;
        }

        mapStoT.set(charS, charT);
        mapTtoS.set(charT, charS);
    }

    return true;
};

Example

s = "egg"
t = "add"

Mappings:

e → a
g → d

The mapping remains consistent.

Therefore:

true

But:

s = "foo"
t = "bar"

We get:

f → b
o → a

Then the second o would need to map to r, which conflicts with:

o → a

Therefore:

false

Complexity

• Time: O(n)

• Space: O(n)

Pattern

Two-Way HashMap / Character Mapping

Day 3 Summary

What I Learned Today

Today I started understanding Hashing as a problem-solving pattern rather than simply learning the Map or Set syntax.

The main ideas I practiced were:

Hashing
   ↓
Fast Lookup
   ↓
Complement Lookup
   ↓
Seen Elements
   ↓
Frequency Counting
   ↓
One-to-One Mapping

The most important question I want to ask myself when solving future problems is:

"Do I need to remember something I have already seen?"

If the answer is yes, a Set or Map may be useful.

Day 3 Key Takeaway

The biggest lesson from today's problems is that Hashing can reduce repeated searching.

For example, in Two Sum, instead of checking every possible pair with O(n²) time, I can remember previous values in a Map and solve the problem in O(n) time.

This is the kind of pattern recognition I want to develop throughout this 30-day DSA journey.

Day 3/30 completed.

On Day 1, I started with basic array problems. Today, I moved into String problems and learned several important problem-solving patterns.

The main patterns I practiced today were:

• Two Pointers

• String Traversal

• Frequency Counting

• Hashing

• Character-by-character comparison

I solved 5 LeetCode problems:

1. Reverse String — LeetCode 344

Problem

Given an array of characters, reverse the string in-place.

Example

Input:
["h","e","l","l","o"]

Output:
["o","l","l","e","h"]

Approach

I used the Two Pointer technique.

One pointer starts from the beginning and another starts from the end.

I swap the characters and move both pointers toward the center.

var reverseString = function(s) {
    let len = s.length;
    let halfLen = Math.floor(len / 2);

    for (let i = 0; i < halfLen; i++) {
        let temp = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = temp;
    }
};

Example

["h","e","l","l","o"]

h ↔ o

["o","e","l","l","h"]

e ↔ l

["o","l","l","e","h"]

We only need to process half of the array because every swap handles two positions.

Complexity

• Time: O(n)

• Space: O(1)

Pattern Learned

Two Pointers + In-place Modification

2. Valid Palindrome — LeetCode 125

Problem

Determine whether a string is a palindrome after:

• Converting uppercase letters to lowercase

• Ignoring non-alphanumeric characters

Example

Input:
"A man, a plan, a canal: Panama"

Output:
true

Approach

I used the Two Pointer technique again.

One pointer starts from the beginning and another from the end.

If the current character is not alphanumeric, I skip it.

If both characters are valid, I compare them.

If they don't match, the string cannot be a palindrome.

var isPalindrome = function(s) {
    s = s.toLowerCase();

    let i = 0;
    let j = s.length - 1;

    while (i < j) {
        if (!s[i].match(/[a-z0-9]/i)) {
            ++i;
        }
        else if (!s[j].match(/[a-z0-9]/i)) {
            --j;
        }
        else if (s[i] === s[j]) {
            ++i;
            --j;
        }
        else {
            return false;
        }
    }

    return true;
};

Example

"A man, a plan, a canal: Panama"

Ignore spaces and punctuation:

amanaplanacanalpanama

Compare from both ends:

a == a
m == m
a == a
...

All characters match, so the answer is true.

Complexity

• Time: O(n)

• Space: O(1) auxiliary space

Pattern Learned

Two Pointers + Character Validation

3. Valid Anagram — LeetCode 242

Problem

Given two strings, determine whether one is an anagram of the other.

Two strings are anagrams if they contain the same characters with the same frequencies.

Example

Input:
s = "anagram"
t = "nagaram"

Output:
true

Approach

I used a frequency map.

First, I count how many times each character appears in s.

Then I traverse t and decrease the count for each character.

If a character doesn't exist or its count becomes invalid, I return false.

var isAnagram = function(s, t) {
    if (s.length !== t.length) return false;

    let map = {};

    for (let i = 0; i < s.length; i++) {
        if (!map[s[i]]) {
            map[s[i]] = 1;
        } else {
            ++map[s[i]];
        }
    }

    for (let i = 0; i < t.length; i++) {
        if (!map[t[i]] || map[t[i]] < 0) {
            return false;
        } else {
            --map[t[i]];
        }
    }

    return true;
};

Example

For:

s = "aab"

Frequency map:

a → 2
b → 1

Now process:

t = "aba"

a → 1
b → 0
a → 0

Everything reaches zero, so it is an anagram.

Complexity

• Time: O(n)

• Space: O(n)

Pattern Learned

Hashing + Frequency Counting

4. First Unique Character in a String — LeetCode 387

Problem

Find the index of the first character that appears only once.

Example

Input:
"leetcode"

Output:
0

Because l appears only once.

Another example:

Input:
"loveleetcode"

Output:
2

Because v is the first unique character.

Approach

I used a frequency map.

I need two traversals:

1. Count the frequency of every character.

2. Traverse the string again and find the first character whose frequency is 1.

var firstUniqChar = function(s) {
    let map = {};

    for (let i = 0; i < s.length; i++) {
        if (!map[s[i]]) {
            map[s[i]] = 1;
        } else {
            ++map[s[i]];
        }
    }

    for (let i = 0; i < s.length; i++) {
        if (map[s[i]] === 1) {
            return i;
        }
    }

    return -1;
};

Example

s = "leetcode"

Frequency:

l → 1
e → 3
t → 1
c → 1
o → 1
d → 1

Traverse again:

l → frequency = 1

So we return:

0

Complexity

• Time: O(n)

• Space: O(n)

Pattern Learned

Frequency Counting + Two Traversals

5. Longest Common Prefix — LeetCode 14

Problem

Given an array of strings, find the longest prefix shared by all strings.

Example

Input:
["flower", "flow", "flight"]

Output:
"fl"

Approach

I compare characters column by column using the first string as the reference.

For every character position:

1. Check that every other string has that position.

2. Check whether the character is the same.

3. If there is a mismatch, return the prefix found so far.

4. Otherwise, add the character to the prefix.

var longestCommonPrefix = function(strs) {
    let prefix = "";

    for (let j = 0; j < strs[0].length; j++) {

        for (let i = 1; i < strs.length; i++) {

            if (
                j >= strs[i].length ||
                strs[0][j] !== strs[i][j]
            ) {
                return prefix;
            }
        }

        prefix += strs[0][j];
    }

    return prefix;
};

Example

["flower", "flow", "flight"]

Compare index 0:

f
f
f

Match → "f"

Compare index 1:

l
l
l

Match → "fl"

Compare index 2:

o
o
i

Mismatch.

Therefore:

"fl"

is the longest common prefix.

Complexity

Let:

• m = number of strings

• n = length of the shortest string

Time: O(m × n)

Auxiliary Space: O(1)

The returned prefix itself can require up to O(n) space.

Pattern Learned

String Traversal + Character Comparison

What I Learned on Day 2

Today's problems helped me identify some important DSA patterns.

1. Two Pointers

Used in:

• Reverse String

• Valid Palindrome

The general idea is:

left →              ← right

Process both ends and move toward the center.

2. Frequency Counting

Used in:

• Valid Anagram

• First Unique Character

The general idea is:

character → frequency

For example:

a → 3
b → 1
c → 2

This is one of the most common patterns in string problems.

3. String Traversal

Used in:

• Longest Common Prefix

Instead of treating a string as one large value, I can process it character by character.

Day 2 Summary

• Auxiliary space; the returned prefix itself can require O(n).

🚀 Day 2 Completed

Today I moved from basic array problems into string-based problem solving.

The biggest takeaway from Day 2:

Don't just ask "How do I solve this problem?" Ask "Which pattern can I recognize here?"

Today's patterns:

String Problems
      ↓
Two Pointers
      ↓
Frequency Counting
      ↓
Hashing
      ↓
Character Comparison

#DSA #JavaScript #LeetCode #Algorithms #DataStructures #CodingInterview #ProblemSolving #DSAJourney

My goal is not just to solve LeetCode problems, but to understand the patterns behind the problems, analyze time and space complexity, and learn how to explain my solutions in technical interviews.

For Day 1, I solved 5 Easy problems focused mainly on Array Traversal and Hashing.

Problems Solved

1. Running Sum of 1d Array — LeetCode 1480

Problem

Given an array nums, calculate the running sum.

The running sum at index i is the sum of all elements from index 0 to i.

Example

Input:
[1, 2, 3, 4]

Output:
[1, 3, 6, 10]

Approach

I can solve this using the previous element.

At every index:

current value = current value + previous running sum

The previous index already contains the calculated running sum, so I can modify the array directly.

JavaScript Solution

var runningSum = function(nums) {
    for (let i = 1; i < nums.length; i++) {
        nums[i] = nums[i] + nums[i - 1];
    }

    return nums;
};

How It Works

For:

[1, 2, 3, 4]

At i = 1:

2 + 1 = 3
[1, 3, 3, 4]

At i = 2:

3 + 3 = 6
[1, 3, 6, 4]

At i = 3:

4 + 6 = 10
[1, 3, 6, 10]

Complexity

• Time: O(n) — we traverse the array once.

• Space: O(1) — no additional array is created.

Pattern Learned

Array Traversal + In-place Modification

2. Concatenation of Array — LeetCode 1929

Problem

Given an array nums, create an array containing the original array twice.

Example

Input:
[1, 2, 1]

Output:
[1, 2, 1, 1, 2, 1]

Approach

For every element at index i, I place it at:

i
i + n

where n is the length of the original array.

JavaScript Solution

var getConcatenation = function(nums) {
    let ans = [];
    let n = nums.length;

    for (let i = 0; i < n; i++) {
        ans[i] = nums[i];
        ans[i + n] = nums[i];
    }

    return ans;
};

How It Works

If:

nums = [1, 2, 1]
n = 3

Then:

i = 0
ans[0] = 1
ans[3] = 1

i = 1
ans[1] = 2
ans[4] = 2

i = 2
ans[2] = 1
ans[5] = 1

Result:

[1, 2, 1, 1, 2, 1]

Complexity

• Time: O(n)

• Space: O(n) because we create a new array containing 2n elements.

Pattern Learned

Array Traversal + Index Manipulation

3. Shuffle the Array — LeetCode 1470

Problem

The input contains two halves:

[x1, x2, ..., xn, y1, y2, ..., yn]

We need to return:

[x1, y1, x2, y2, ..., xn, yn]

Example

Input:
[2, 5, 1, 3, 4, 7]

n = 3

Output:
[2, 3, 5, 4, 1, 7]

Approach

The first half contains the x values and the second half contains the y values.

For every index i, I add:

nums[i]
nums[i + n]

to the result.

JavaScript Solution

var shuffle = function(nums, n) {
    let res = [];
    let i = 0;

    while (i < n) {
        res.push(nums[i]);
        res.push(nums[i + n]);
        i++;
    }

    return res;
};

Complexity

• Time: O(n)

• Space: O(n) because we create the result array.

Pattern Learned

Array Traversal + Index Relationship

4. Richest Customer Wealth — LeetCode 1672

Problem

Each customer has money in multiple bank accounts.

We need to find the customer with the maximum total wealth.

Example

Input:
[
    [1, 2, 3],
    [3, 2, 1]
]

Output:
6

Approach

This is an array containing other arrays.

So I use:

• Outer loop → iterate through each customer

• Inner loop → calculate that customer's total wealth

• max → store the maximum wealth

JavaScript Solution

var maximumWealth = function(accounts) {
    let max = 0;

    for (let i = 0; i < accounts.length; i++) {
        let sum = 0;

        for (let j = 0; j < accounts[i].length; j++) {
            sum += accounts[i][j];
        }

        if (sum > max) {
            max = sum;
        }
    }

    return max;
};

How It Works

For:

[
    [1, 2, 3],
    [3, 2, 1],
    [4, 5, 6]
]

We calculate:

Customer 1 → 1 + 2 + 3 = 6
Customer 2 → 3 + 2 + 1 = 6
Customer 3 → 4 + 5 + 6 = 15

Therefore:

Maximum wealth = 15

Complexity

If there are m customers and each customer has n accounts:

• Time: O(m × n)

• Space: O(1)

Pattern Learned

Nested Array Traversal

Important Lesson

Two loops do not automatically mean O(n²).

We need to understand what each loop is traversing.

Here, one loop traverses customers and the other traverses accounts.

5. Contains Duplicate — LeetCode 217

Problem

Given an integer array, determine whether any value appears at least twice.

Example

Input:
[1, 2, 3, 1]

Output:
true

Approach

I need to remember which numbers I have already seen.

A Set is useful because it allows me to check whether a value already exists.

JavaScript Solution

var containsDuplicate = function(nums) {
    let set = new Set();

    for (let num of nums) {
        if (set.has(num)) {
            return true;
        }

        set.add(num);
    }

    return false;
};

How It Works

For:

[1, 2, 3, 1]

We process each number:

1 → not present → add
2 → not present → add
3 → not present → add
1 → already present → return true

Complexity

• Time: O(n)

• Space: O(n)

The Set can store up to n unique elements.

Important Mistake I Learned

Initially, I considered the space complexity as O(1).

But that was incorrect.

Since the Set can grow depending on the input size, the correct space complexity is:

O(n)

This reminded me that writing the solution is only one part of DSA. Understanding complexity is equally important.

🎯 Day 1 — What I Learned

Today I learned several important array patterns:

1. Array Traversal

Visit every element once.

2. In-place Modification

Modify the existing array instead of creating another array when possible.

3. Index Manipulation

Use relationships between indexes to rearrange elements.

4. Nested Array Traversal

Use nested loops when working with arrays containing other arrays.

5. Hashing with Set

Use a Set when I need to efficiently check whether I've already seen a value.

Interview Learning

One of my goals with this DSA journey is not just to solve problems but to explain my solutions during interviews.

For every problem, I want to practice explaining:

1. What is the problem asking?
2. What is my approach?
3. Why does my approach work?
4. Can I optimize it?
5. What is the time complexity?
6. What is the space complexity?

I realized that being able to write code and being able to explain the code clearly are two different skills.

I want to improve both.

Day 1 Summary

Final Takeaway

Day 1 taught me that DSA is not about memorizing solutions.

The real goal is to recognize:

What pattern does this problem follow?

Today I started with simple array problems. From here, I'll gradually move towards more important patterns such as:

Arrays
↓
Two Pointers
↓
Sliding Window
↓
Hashing
↓
Stack & Queue
↓
Linked List
↓
Binary Search
↓
Trees
↓
Graphs
↓
Dynamic Programming

Day 1/30 completed. 🚀

The journey has just started.

LeetCode Problems

• LeetCode 1480 — Running Sum of 1d Array

• LeetCode 1929 — Concatenation of Array

• LeetCode 1470 — Shuffle the Array

• LeetCode 1672 — Richest Customer Wealth

• LeetCode 217 — Contains Duplicate

#DSA #JavaScript #LeetCode #Algorithms #DataStructures #CodingInterview #ProblemSolving #100DaysOfCode