DEV Community: luparinx

Day 09/90: Mastering the Longest Palindromic Substring - Center Expansion Technique in TypeScript

luparinx — Thu, 01 May 2025 14:54:31 +0000

Longest Palindromic Substring

Introduction
Today we're solving one of LeetCode's classic string problems - finding the longest palindromic substring. This is problem #5, and it's an excellent way to understand dynamic programming and center expansion techniques in string algorithms.

The Problem
Given a string s, return the longest substring that reads the same forwards and backwards (a palindrome).

Example:
'''
Input: "babad"
Output: "bab" or "aba"
Explanation: Both "bab" and "aba" are valid palindromic substrings.
'''

The Optimal Solution
'''typescript
function longestPalindrome(s: string): string {
let start = 0;
let end = 0;

for (let i = 0; i < s.length; i++) {
    const [left1, right1] = expandAroundCenter(s, i, i);
    const [left2, right2] = expandAroundCenter(s, i, i + 1);

    if (right1 - left1 > end - start) {
        start = left1;
        end = right1;
    }
    if (right2 - left2 > end - start) {
        start = left2;
        end = right2;
    }
}

return s.substring(start, end + 1);

}

function expandAroundCenter(s: string, left: number, right: number): [number, number] {
while (left >= 0 && right < s.length && s[left] === s[right]) {
left--;
right++;
}
return [left + 1, right - 1];
}
'''

This solution is:
✅ Efficient - O(n²) time complexity (optimal for this problem)
✅ Space-optimized - O(1) additional space
✅ Clean - Uses simple center expansion logic
✅ Handles both odd and even length palindromes

How It Works
Center Expansion Technique: Checks each character (and between characters) as potential palindrome centers

Dual Expansion: Expands for both odd-length (single center) and even-length (dual center) palindromes

Bounds Tracking: Maintains the start/end indices of the longest palindrome found

Length Comparison: Continuously updates when longer palindromes are found

Alternative Approaches
Dynamic Programming Approach:
'''typescript
function longestPalindrome(s: string): string {
const n = s.length;
const dp: boolean[][] = Array(n).fill(false).map(() => Array(n).fill(false));
let result = '';

for (let i = n - 1; i >= 0; i--) {
    for (let j = i; j < n; j++) {
        dp[i][j] = s[i] === s[j] && (j - i < 3 || dp[i + 1][j - 1]);
        if (dp[i][j] && j - i + 1 > result.length) {
            result = s.substring(i, j + 1);
        }
    }
}
return result;

}
'''
Pros:

Systematic approach using DP table
Easier to understand the recurrence relation

Cons:

O(n²) space complexity
More complex implementation
Slower due to table initialization

Brute Force Approach:
'''typescript
function longestPalindrome(s: string): string {
let longest = '';
for (let i = 0; i < s.length; i++) {
for (let j = i; j < s.length; j++) {
const substr = s.substring(i, j + 1);
if (isPalindrome(substr) && substr.length > longest.length) {
longest = substr;
}
}
}
return longest;
}

function isPalindrome(s: string): boolean {
return s === s.split('').reverse().join('');
}
'''
Pros:

Simple to understand
No advanced concepts needed

Cons:

O(n³) time complexity
Extremely inefficient for longer strings

Edge Cases to Consider

Empty string
Single character string ("a")
All characters same ("aaaaa")
No palindromes longer than 1 character ("abcde")
Even-length palindromes ("abba")
Mixed case with special characters

Performance Considerations
The optimal solution:

Processes each character as a potential center
Expands outward in O(n) time per center
Total O(n²) time complexity (optimal for this problem)
Uses constant space (just stores indices)

Common Mistakes to Avoid

Forgetting to check both odd and even length palindromes
Incorrect bounds when expanding from center
Not updating the longest palindrome properly
Off-by-one errors in substring extraction
Not handling edge cases like empty strings

Real-world Applications
This algorithm has practical uses in:

DNA sequence analysis (palindromic sequences)
Cryptography (pattern matching)
Data compression (finding repeated patterns)
Text processing (finding mirrored structures)
Plagiarism detection (finding similar structures)

Conclusion
The center expansion approach provides the best combination of:
🔥 Optimal O(n²) time complexity
🔥 Minimal O(1) space usage
🔥 Clean implementation
🔥 Robust handling of all edge cases

Understanding this center expansion technique will help with many other string manipulation problems. It's a fundamental pattern that demonstrates how we can often find efficient solutions by looking for natural symmetries in problems!

Day 08/90: Solving the Longest Substring Without Repeating Characters Problem in TypeScript/JavaScript

luparinx — Wed, 30 Apr 2025 15:27:33 +0000

Introduction
Today, we're tackling a classic string manipulation problem - finding the length of the longest substring without repeating characters. This is LeetCode Problem 3, and it's a great way to understand sliding window techniques and hash map usage in algorithms.

**The Problem
**Given a string s, find the length of the longest substring without repeating characters.

Example:

Input: "abcabcbb"
Output: 3
Explanation: The answer is "abc", with the length of 3.

The Optimal Solution

function lengthOfLongestSubstring(s: string): number {
    let start = 0;
    let maxLength = 0;
    const charMap = new Map<string, number>();

    for (let end = 0; end < s.length; end++) {
        const currentChar = s[end];
        if (charMap.has(currentChar)) {
            const prevIndex = charMap.get(currentChar)!;
            if (prevIndex >= start) {
                start = prevIndex + 1;
            }
        }
        charMap.set(currentChar, end);
        maxLength = Math.max(maxLength, end - start + 1);
    }

    return maxLength;
}

*This solution is:
*✅ Efficient - O(n) time complexity
✅ Space-optimized - O(min(m, n)) space (m = character set size)
✅ Clean - Uses a single pass with smart window adjustment

How It Works
Sliding Window Technique: Maintains a window of characters that haven't repeated

Hash Map Tracking: Stores the most recent index of each character

Window Adjustment: When a duplicate is found, moves the start of the window

Length Calculation: Continuously updates the maximum length found

Alternative Approaches
Brute Force Approach:

function lengthOfLongestSubstring(s: string): number {
    let max = 0;
    for (let i = 0; i < s.length; i++) {
        const seen = new Set();
        let j = i;
        while (j < s.length && !seen.has(s[j])) {
            seen.add(s[j]);
            j++;
        }
        max = Math.max(max, j - i);
    }
    return max;
}

Pros:

Simple to understand

No advanced concepts needed

Cons:

O(n²) time complexity

Inefficient for long strings

** Optimized Sliding Window with Set**

function lengthOfLongestSubstring(s: string): number {
    let start = 0;
    let end = 0;
    let maxLength = 0;
    const charSet = new Set<string>();

    while (end < s.length) {
        if (!charSet.has(s[end])) {
            charSet.add(s[end]);
            maxLength = Math.max(maxLength, end - start + 1);
            end++;
        } else {
            charSet.delete(s[start]);
            start++;
        }
    }

    return maxLength;
}

Pros:

O(n) time complexity

Easier to visualize than the map approach

Cons:

Potentially more operations than the optimal solution

Worst case O(2n) time when many duplicates exist

Edge Cases to Consider
Empty string

All characters the same ("aaaaa")

No repeating characters ("abcdef")

Mixed case with special characters

Very long strings (performance testing)

Performance Considerations
The optimal solution:

Processes each character exactly once

Uses efficient hash map operations (O(1) average case)

Minimizes unnecessary computations

Works well with Unicode characters

Common Mistakes to Avoid
Not properly handling window adjustment: Moving start to just prevIndex instead of prevIndex + 1

Forgetting to update the character's latest position in the map

Incorrect length calculation: Using end - start instead of end - start + 1

Not considering all test cases: Especially edge cases with 0 or 1 length strings

**Real-world Applications
**This algorithm has practical uses in:

Text editors (finding unique sequences)

Data analysis (pattern detection)

Bioinformatics (DNA sequence analysis)

Cryptography (finding unique character patterns)

Conclusion
The sliding window with hash map tracking provides the best combination of:
🔥 Optimal O(n) time complexity
🔥 Efficient space usage
🔥 Clean implementation
🔥 Robust handling of all edge cases

Understanding this pattern will help with many other string manipulation and subarray problems. The sliding window technique is a powerful tool to have in your algorithm toolbox!

Day 07/90: Adding Two Numbers Represented by Linked Lists in TypeScript/JavaScript

luparinx — Tue, 29 Apr 2025 14:24:01 +0000

Introduction

When numbers are represented as linked lists where each digit is stored in reverse order, adding them requires careful traversal and carry management. Today, we'll solve LeetCode Problem 2 ("Add Two Numbers") efficiently in TypeScript/JavaScript.

The Problem
Given two non-empty linked lists representing two non-negative integers (with digits stored in reverse order), add the two numbers and return the sum as a linked list.

Example:
Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 0 -> 8
Explanation: 342 + 465 = 807

The Optimal Solution

function addTwoNumbers(l1: ListNode | null, l2: ListNode | null): ListNode | null {
    let dummy = new ListNode(0);
    let current = dummy;
    let carry = 0;

    while (l1 || l2 || carry) {
        const x = l1 ? l1.val : 0;
        const y = l2 ? l2.val : 0;
        const sum = x + y + carry;

        carry = Math.floor(sum / 10);
        current.next = new ListNode(sum % 10);
        current = current.next;

        if (l1) l1 = l1.next;
        if (l2) l2 = l2.next;
    }

    return dummy.next;
};

This solution is:
✅ Efficient - O(max(n,m)) time complexity
✅ Clean - Handles all cases uniformly
✅ Memory-friendly - O(max(n,m)) space complexity

How It Works
Dummy Node: Simplifies edge cases by providing an initial node

Carry Propagation: Tracks overflow between digit places

Flexible While Condition: Continues until both lists and carry are exhausted

Null Handling: Safely accesses values using ternary operators

Alternative Approaches

Recursive Solution

function addTwoNumbers(l1: ListNode | null, l2: ListNode | null, carry = 0): ListNode | null {
    if (!l1 && !l2 && !carry) return null;

    const sum = (l1?.val || 0) + (l2?.val || 0) + carry;
    return new ListNode(
        sum % 10,
        addTwoNumbers(l1?.next || null, l2?.next || null, Math.floor(sum / 10))
    );
}

Pros:

More declarative style

No dummy node needed

Cons:

Potential stack overflow for very long lists

Slightly less efficient

Convert-and-Add Approach:

function addTwoNumbers(l1: ListNode | null, l2: ListNode | null): ListNode | null {
    const num1 = listToNum(l1);
    const num2 = listToNum(l2);
    return numToList(num1 + num2);
}

function listToNum(node: ListNode | null): number {
    let num = 0;
    let place = 1;
    while (node) {
        num += node.val * place;
        place *= 10;
        node = node.next;
    }
    return num;
}

function numToList(num: number): ListNode | null {
    if (num === 0) return new ListNode(0);

    let dummy = new ListNode(0);
    let current = dummy;

    while (num > 0) {
        current.next = new ListNode(num % 10);
        current = current.next;
        num = Math.floor(num / 10);
    }

    return dummy.next;
}

Pros:

Conceptually simple

Easy to understand

Cons:

Fails with very large numbers (JavaScript number precision limits)

Inefficient for long lists

Edge Cases to Consider
Lists of different lengths

Final carry (e.g., 5 + 5 = 10)

Zero values

Single-digit lists

Large numbers (but within JavaScript safe integer range)

Performance Considerations
The optimal solution:

Processes each node exactly once

Uses constant extra space (just the carry)

Minimizes memory allocations

Conclusion
The dummy node approach provides the best combination of:
🔥 Clean implementation
🔥 Optimal performance
🔥 Robust edge case handling

Day 06/90: Find the First Occurrence of a Substring in TypeScript/JavaScript

luparinx — Sun, 27 Apr 2025 18:14:32 +0000

Introduction

When working with strings in programming, a common task is finding whether one string exists within another and locating its position. In this post, we'll explore how to solve the classic "strStr" problem (LeetCode Problem 28) in TypeScript/JavaScript, achieving optimal performance with just one line of code.

The Problem

Given two strings haystack and needle, we need to return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Examples:

strStr("sadbutsad", "sad") returns 0

strStr("leetcode", "leeto") returns -1

The Simple Solution

The most straightforward solution in JavaScript/TypeScript is to use the built-in indexOf method:

function strStr(haystack: string, needle: string): number {
    return haystack.indexOf(needle);
};

This solution is:

Concise: Just one line of code

Efficient: Leverages JavaScript's highly optimized string search

Readable: Clearly expresses the intent

Why This Works

JavaScript's indexOf method is implemented natively in the engine using efficient string search algorithms (likely a variation of the Boyer-Moore or Knuth-Morris-Pratt algorithms). These algorithms provide:

O(n + m) average time complexity

O(1) space complexity

Optimized performance for real-world use cases

Alternative Approaches

While the one-liner is ideal for most cases, it's worth understanding alternative implementations:

1. Brute Force Approach

function strStr(haystack: string, needle: string): number {
    if (needle.length === 0) return 0;
    for (let i = 0; i <= haystack.length - needle.length; i++) {
        let j = 0;
        while (j < needle.length && haystack[i + j] === needle[j]) {
            j++;
        }
        if (j === needle.length) return i;
    }
    return -1;
};

Pros:

Doesn't rely on built-in methods

Good for learning purposes

Cons:

O(n*m) time complexity in worst case

More verbose

2. Using substring comparison

function strStr(haystack: string, needle: string): number {
    if (needle.length === 0) return 0;
    for (let i = 0; i <= haystack.length - needle.length; i++) {
        if (haystack.substring(i, i + needle.length) === needle) {
            return i;
        }
    }
    return -1;
};

Pros:

Day 5/90: Purge Elements Like the Shadow Monarch — Conquering LeetCode’s Remove Element Problem

luparinx — Sun, 27 Apr 2025 18:08:27 +0000

“The difference between the hunter and the prey is persistence.”

Sung Jin-Woo, moments before annihilating a dungeon boss

The Daily Quest: System Notification
Objective: Remove all occurrences of val from an array nums in-place.
Difficulty: 🟢 Level 2 (Beginner-Friendly But Tactical)
Reward: +15 DSA XP, +7 In-Place Operation Mastery

--
The Problem: A Dungeon Infested with "Val" Monsters
Imagine your array is a dungeon corridor filled with monsters (elements equal to val). Your mission: eliminate them all without using extra space (no portals or shadow summons allowed).

Example:
Input: nums = [3, 2, 2, 3], val = 3 → Output: 2 (nums becomes [2, 2, _, _])

Constraints:

Do it in O(n) time.

Use O(1) memory (no creating new arrays).

--
The Shadow Monarch’s Strategy: Two-Pointer Technique
Sung Jin-Woo doesn’t waste energy fighting every monster head-on. He strategically deploys his forces. Here’s how we mimicked his tactics:

The Shadow Squad:

Scout (i): Traverses the dungeon (array) to identify threats.

Gatekeeper (k): Secures the safe zone by marking positions for non-monster elements.

The Battle Plan:

Initialize k = 0 (Gatekeeper starts at the dungeon entrance).

Send the Scout (i) to inspect every element:

If nums[i] != val (not a monster), order the Gatekeeper to secure it at nums[k].

Advance the Gatekeeper (k++) to fortify the next position.

Return k (number of survivors).

Code Crafting: Commanding the Shadows

typescript
function removeElement(nums: number[], val: number): number {

let k = 0; // Gatekeeper starts at the gates

for (let i = 0; i < nums.length; i++) { // Scout explores the dungeon

if (nums[i] !== val) { // Found a human survivor!

nums[k] = nums[i]; // Gatekeeper secures them

k++; // Advance the safe zone

}

}

return k; // Total survivors

}

Live Battle Simulation:
Input: nums = [0, 1, 2, 2, 3, 0, 4, 2], val = 2

Scout (i=0): 0 is safe → Gatekeeper (k=0) secures it.

Scout (i=1): 1 is safe → Gatekeeper (k=1) secures it.

Scout (i=2): 2 is a monster → skipped.

Scout (i=6): 4 is safe → Gatekeeper (k=4) secures it.

Final Array: [0, 1, 3, 0, 4, _, _, _] → k = 5 survivors.

--
Why This Strategy Dominates

Time Complexity: O(n) — Scout clears the dungeon in one sweep.

Space Complexity: O(1) — No mana (memory) wasted.

This is the coding equivalent of Sung Jin-Woo’s Shadow Extraction skill — efficient, ruthless, and resourceful.

Level-Up Loot (Key Takeaways)

In-Place Operations Are King: Like Jin-Woo repurposing defeated shadows, we repurposed the array itself.

Order Doesn’t Matter: Focus on securing survivors, not their sequence (chaos is acceptable in battle).

Edge Cases:

Empty dungeon (array)? Return 0.

All monsters (elements = val)? Return 0.

Join the Shadow Army (Community Callout)

Upvote if you’d partner with Sung Jin-Woo in this coding dungeon!

Comment Below:

Your favorite in-place algorithm tactic.

Which Solo Leveling character best represents recursion? (Beru? Igris?)

Post your solution — let’s see who writes the cleanest code!

“Those who hesitate are disqualified.” Keep grinding, hunters! 🔥

Follow My Journey:

Reddit: Join r/CodeMonarch for daily updates.

Series Tag: #SoloCodingJourney

“The System is watching. Are you strong enough to answer?” 🕶️

Day 5/90: Purge Elements Like the Shadow Monarch — Conquering LeetCode’s Remove Element Problem 🗡️

luparinx — Sun, 27 Apr 2025 18:06:54 +0000

“The difference between the hunter and the prey is persistence.”

Sung Jin-Woo, moments before annihilating a dungeon boss

Example:
Input: nums = [3, 2, 2, 3], val = 3 → Output: 2 (nums becomes [2, 2, _, _])

Constraints:

Do it in O(n) time.

Use O(1) memory (no creating new arrays).

The Shadow Squad:

Scout (i): Traverses the dungeon (array) to identify threats.

Gatekeeper (k): Secures the safe zone by marking positions for non-monster elements.

The Battle Plan:

Initialize k = 0 (Gatekeeper starts at the dungeon entrance).

Send the Scout (i) to inspect every element:

If nums[i] != val (not a monster), order the Gatekeeper to secure it at nums[k].

Advance the Gatekeeper (k++) to fortify the next position.

Return k (number of survivors).

Code Crafting: Commanding the Shadows

Scout (i=0): 0 is safe → Gatekeeper (k=0) secures it.

Scout (i=1): 1 is safe → Gatekeeper (k=1) secures it.

Scout (i=2): 2 is a monster → skipped.

Scout (i=6): 4 is safe → Gatekeeper (k=4) secures it.

Final Array: [0, 1, 3, 0, 4, _, _, _] → k = 5 survivors.

--
Why This Strategy Dominates

Time Complexity: O(n) — Scout clears the dungeon in one sweep.

Space Complexity: O(1) — No mana (memory) wasted.

This is the coding equivalent of Sung Jin-Woo’s Shadow Extraction skill — efficient, ruthless, and resourceful.

Level-Up Loot (Key Takeaways)

In-Place Operations Are King: Like Jin-Woo repurposing defeated shadows, we repurposed the array itself.

Order Doesn’t Matter: Focus on securing survivors, not their sequence (chaos is acceptable in battle).

Edge Cases:

Empty dungeon (array)? Return 0.

All monsters (elements = val)? Return 0.

Join the Shadow Army (Community Callout)

Upvote if you’d partner with Sung Jin-Woo in this coding dungeon!

Comment Below:

Your favorite in-place algorithm tactic.

Which Solo Leveling character best represents recursion? (Beru? Igris?)

Post your solution — let’s see who writes the cleanest code!

“Those who hesitate are disqualified.” Keep grinding, hunters! 🔥

Follow My Journey:

Reddit: Join r/CodeMonarch for daily updates.

Series Tag: #SoloCodingJourney

“The System is watching. Are you strong enough to answer?” 🕶️

Day 5/90: Purge Elements Like the Shadow Monarch — Conquering LeetCode’s Remove Element Problem 🗡️

luparinx — Sat, 26 Apr 2025 17:39:36 +0000

“The difference between the hunter and the prey is persistence.”

Sung Jin-Woo, moments before annihilating a dungeon boss

The Problem: A Dungeon Infested with "Val" Monsters
Imagine your array is a dungeon corridor filled with monsters (elements equal to val). Your mission: eliminate them all without using extra space (no portals or shadow summons allowed).

Example:
Input: nums = [3, 2, 2, 3], val = 3 → Output: 2 (nums becomes [2, 2, _, _])

Constraints:

Do it in O(n) time.

Use O(1) memory (no creating new arrays).

The Shadow Monarch’s Strategy: Two-Pointer Technique
Sung Jin-Woo doesn’t waste energy fighting every monster head-on. He strategically deploys his forces. Here’s how we mimicked his tactics:

The Shadow Squad:

Scout (i): Traverses the dungeon (array) to identify threats.

Gatekeeper (k): Secures the safe zone by marking positions for non-monster elements.

The Battle Plan:

Initialize k = 0 (Gatekeeper starts at the dungeon entrance).

Send the Scout (i) to inspect every element:

If nums[i] != val (not a monster), order the Gatekeeper to secure it at nums[k].

Advance the Gatekeeper (k++) to fortify the next position.

Return k (number of survivors).

Code Crafting: Commanding the Shadows

Scout (i=0): 0 is safe → Gatekeeper (k=0) secures it.

Scout (i=1): 1 is safe → Gatekeeper (k=1) secures it.

Scout (i=2): 2 is a monster → skipped.

Scout (i=6): 4 is safe → Gatekeeper (k=4) secures it.

Final Array: [0, 1, 3, 0, 4, _, _, _] → k = 5 survivors.

Why This Strategy Dominates

Time Complexity: O(n) — Scout clears the dungeon in one sweep.

Space Complexity: O(1) — No mana (memory) wasted.

This is the coding equivalent of Sung Jin-Woo’s Shadow Extraction skill — efficient, ruthless, and resourceful.

Level-Up Loot (Key Takeaways)

In-Place Operations Are King: Like Jin-Woo repurposing defeated shadows, we repurposed the array itself.

Order Doesn’t Matter: Focus on securing survivors, not their sequence (chaos is acceptable in battle).

Edge Cases:

Empty dungeon (array)? Return 0.

All monsters (elements = val)? Return 0.

--
Join the Shadow Army (Community Callout)

Upvote if you’d partner with Sung Jin-Woo in this coding dungeon!

Comment Below:

Your favorite in-place algorithm tactic.

Which Solo Leveling character best represents recursion? (Beru? Igris?)

Post your solution — let’s see who writes the cleanest code!

“Those who hesitate are disqualified.” Keep grinding, hunters! 🔥

Follow My Journey:

Reddit: Join r/CodeMonarch for daily updates.

Series Tag: #SoloCodingJourney

“The System is watching. Are you strong enough to answer?” 🕶️

Day 5/90: Purge Elements Like the Shadow Monarch — Conquering LeetCode’s Remove Element Problem 🗡️

luparinx — Sat, 26 Apr 2025 17:39:36 +0000

“The difference between the hunter and the prey is persistence.”

Sung Jin-Woo, moments before annihilating a dungeon boss

Example:
Input: nums = [3, 2, 2, 3], val = 3 → Output: 2 (nums becomes [2, 2, _, _])

Constraints:

Do it in O(n) time.

Use O(1) memory (no creating new arrays).

The Shadow Monarch’s Strategy: Two-Pointer Technique
Sung Jin-Woo doesn’t waste energy fighting every monster head-on. He strategically deploys his forces. Here’s how we mimicked his tactics:

The Shadow Squad:

Scout (i): Traverses the dungeon (array) to identify threats.

Gatekeeper (k): Secures the safe zone by marking positions for non-monster elements.

The Battle Plan:

Initialize k = 0 (Gatekeeper starts at the dungeon entrance).

Send the Scout (i) to inspect every element:

If nums[i] != val (not a monster), order the Gatekeeper to secure it at nums[k].

Advance the Gatekeeper (k++) to fortify the next position.

Return k (number of survivors).

Code Crafting: Commanding the Shadows

Scout (i=0): 0 is safe → Gatekeeper (k=0) secures it.

Scout (i=1): 1 is safe → Gatekeeper (k=1) secures it.

Scout (i=2): 2 is a monster → skipped.

Scout (i=6): 4 is safe → Gatekeeper (k=4) secures it.

Final Array: [0, 1, 3, 0, 4, _, _, _] → k = 5 survivors.

Why This Strategy Dominates

Time Complexity: O(n) — Scout clears the dungeon in one sweep.

Space Complexity: O(1) — No mana (memory) wasted.

This is the coding equivalent of Sung Jin-Woo’s Shadow Extraction skill — efficient, ruthless, and resourceful.

Level-Up Loot (Key Takeaways)

In-Place Operations Are King: Like Jin-Woo repurposing defeated shadows, we repurposed the array itself.

Order Doesn’t Matter: Focus on securing survivors, not their sequence (chaos is acceptable in battle).

Edge Cases:

Empty dungeon (array)? Return 0.

All monsters (elements = val)? Return 0.

--
Join the Shadow Army (Community Callout)

Upvote if you’d partner with Sung Jin-Woo in this coding dungeon!

Comment Below:

Your favorite in-place algorithm tactic.

Which Solo Leveling character best represents recursion? (Beru? Igris?)

Post your solution — let’s see who writes the cleanest code!

“Those who hesitate are disqualified.” Keep grinding, hunters! 🔥

Follow My Journey:

Reddit: Join r/CodeMonarch for daily updates.

Series Tag: #SoloCodingJourney

“The System is watching. Are you strong enough to answer?” 🕶️

🏋️ Day 4/100: Crushing LeetCode - Remove Duplicates from Sorted Array

luparinx — Sat, 26 Apr 2025 17:35:51 +0000

Day 4/90: Conquering Duplicates in Sorted Arrays

The Challenge:
As I continue my 90-day DSA journey, today's battlefield was removing duplicates from a sorted array. The mission seemed simple at first glance, but required careful strategy to execute efficiently.

Why This Matters:
Duplicate removal is fundamental for:

Data cleaning and preprocessing
Optimizing storage space
Preparing data for other algorithms

My Battle Plan:
After analyzing the problem, I chose the two-pointer technique because:

The array is already sorted (duplicates are adjacent)
We need O(1) space complexity
It allows single-pass operation (O(n) time)

The Solution:
Here's how I implemented the two-pointer approach:

'''typescript
function removeDuplicates(nums: number[]): number {
if (nums.length === 0) return 0;

let uniquePointer = 0;

for (let scout = 1; scout < nums.length; scout++) {
    if (nums[scout] !== nums[uniquePointer]) {
        uniquePointer++;
        nums[uniquePointer] = nums[scout];
    }
}

return uniquePointer + 1;

}
'''

How It Works:

uniquePointer marks the end of our unique elements section
scout looks ahead for the next unique element
When we find a new unique element, we:
- Move uniquePointer forward
- Place the new element in its position

Visual Walkthrough:
For input [1,1,2,3,3]:

Initial: [1,1,2,3,3], uniquePointer=0, scout=1
First unique found: [1,2,2,3,3], uniquePointer=1
Second unique found: [1,2,3,3,3], uniquePointer=2
Final result: 3 unique elements [1,2,3,...]

Performance Analysis:

Time Complexity: O(n) - Single pass through array
Space Complexity: O(1) - No additional storage needed

Key Insights:

The sorted property is crucial - random order would require different approach
We're effectively compressing the unique elements to the front
The remaining elements after our uniquePointer don't need to be cleared

Common Pitfalls:

Forgetting to handle empty array case
Off-by-one errors in the return value
Unnecessary swaps when elements are equal

Testing Your Solution:
Always test these edge cases:

Empty array
All duplicates
No duplicates
Single element array

Going Further:
Try modifying this to:

Allow at most 2 duplicates
Work with unsorted arrays
Return the modified array instead of just count

Final Thoughts:
This problem was an excellent exercise in efficient array manipulation. The two-pointer technique is powerful and appears in many other problems - well worth mastering!

Next Challenge:
Day 5 will tackle merging two sorted arrays - another practical application of similar techniques.

Discussion Question:
What other problems can benefit from this two-pointer approach? Share your thoughts below!

How I Mastered Merging Sorted Lists with Pointer Tactics

luparinx — Thu, 24 Apr 2025 19:06:52 +0000

🔥 The Challenge

Problem: Merge two sorted linked lists into one sorted list.

Input: list1 = [1->2->4], list2 = [1->3->4]  
Output: [1->1->2->3->4->4]

🧠 My Battle Strategy

I deployed the Two-Pointer Technique with a Dummy Node vanguard:

Sentinel Node: Created a dummy head to eliminate edge cases.
Pointer March: Advanced through both lists like shadow soldiers
Optimal Selection: Always chose the smaller value to maintain order

function mergeTwoLists(list1: ListNode | null, list2: ListNode | null): ListNode | null {
  const dummy = new ListNode(0); // 🛡️ My shield against null cases
  let current = dummy;

  while (list1 && list2) {
    if (list1.val <= list2.val) {
      current.next = list1;
      list1 = list1.next!;
    } else {
      current.next = list2;
      list2 = list2.next!;
    }
    current = current.next;
  }

  current.next = list1 || list2; // ⚡ Finishing move
  return dummy.next;
}

💡 Key Insights
Space Efficiency: O(1) space complexity by reusing existing nodes

Time Optimization: O(n+m) time by single-pass merging

Elegant Edge Handling: Dummy node prevents null reference headaches

🚀 Level Up Challenge

Can you solve this recursively? Here's a sneak peek:

function mergeRecursive(l1: ListNode | null, l2: ListNode | null): ListNode | null {
  if (!l1) return l2;
  if (!l2) return l1;

  if (l1.val < l2.val) {
    l1.next = mergeRecursive(l1.next, l2);
    return l1;
  } else {
    l2.next = mergeRecursive(l1, l2.next);
    return l2;
  }
}

Daily Progress: ▰▰▰▰▰ 4.44% (4/90)
Tags: algorithms, linkedlists, typescript, dsa, programming

Conquering Valid Parentheses with Stack Magic

luparinx — Wed, 23 Apr 2025 19:08:09 +0000

🔥 Today's Challenge Problem: Given a string containing just (, ), {, }, [ and ], determine if the input string is valid.

Example:

Input: "()[]{}"
Output: true
🧠 The Hunter's Strategy Weapon of Choice: Stack Data Structure When dealing with nested structures, stacks are your best friend. Here's why:

Last-In-First-Out (LIFO) principle perfectly matches bracket validation

O(n) time complexity - we process each character exactly once

Early termination possible when mismatches occur

Approach Breakdown: Initialize an empty stack

Create a bracket pairing map (] → [, etc.)

Iterate through the string:

Push opening brackets onto stack

For closing brackets: check if top of stack matches

Final stack check ensures all brackets were closed

💻 TypeScript Implementation

function isValid(s: string): boolean {
const stack: string[] = [];
const bracketPairs: Record = {
')': '(',
'}': '{',
']': '['
};

for (const char of s) {
    if (!bracketPairs[char]) {
        stack.push(char);
    } else if (stack.pop() !== bracketPairs[char]) {
        return false;
    }
}

return stack.length === 0;

}
Key Optimizations:

Used a hashmap for O(1) bracket lookups

Early return on mismatch

Single pass through the string

🎯 Edge Cases That Made Me Wiser Empty string: Technically valid (handled by final stack check)

Nested valid brackets: ({[]}) → true

Mismatched brackets: ([)] → false

Single bracket: [ → false

🚀 Performance Analysis Metric Value Time Complexity O(n) Space Complexity O(n) LeetCode Runtime 72ms (faster than 92.5%) 💡 Pro Tips Visualize the stack like a tower - you can only remove the top block!

Test these cases:

"(([]){})" (complex but valid)

"]" (immediate fail)

Try solving it without stack (hint: recursive approach exists)

What's your favorite stack-based algorithm? Let's discuss in the comments! 👇

Tomorrow's Preview: We'll tackle "Merge Two Sorted Lists" using pointer manipulation!