🚀 LeetCode Top 150 — Progress Log #1

Deekshitha — Sun, 01 Mar 2026 10:06:29 +0000

I’ve officially started my Top 150 LeetCode journey to strengthen my foundations in Data Structures & Algorithms.

✅ Progress: 3 / 150 Problems Solved

Rather than rushing through problems, my focus is on understanding patterns, improving reasoning, and writing cleaner solutions over time.

🧩 Problems Solved Today

1️⃣ Merge Sorted Array

Approach:
Merged elements from the second array into the first and applied sorting to maintain order.

Key Learning:
A working solution isn’t always the optimal one. This problem introduced the importance of thinking about pointer-based merging instead of relying purely on sorting.

class Solution {
public:
    vector<int> merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        for(int i = m; i < m + n; i++) {
            nums1[i] = nums2[i - m];
        }
        for(int i = 0; i < m + n - 1; i++) {
            for(int j = 0; j < m + n - i - 1; j++) {
                if(nums1[j] > nums1[j+1]) {
                    swap(nums1[j], nums1[j+1]);
                }
            }
        }
        return nums1;
    }
};

2️⃣ Remove Element

Approach:
Used a write pointer (idx) to overwrite unwanted values in-place.

Key Learning:
Many array problems reduce to maintaining a correct write index rather than deleting elements.

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int idx = 0;
        for(int i = 0; i < nums.size(); i++){
            if(nums[i] != val){
                nums[idx++] = nums[i];
            }
        }
        return idx;
    }
};

3️⃣ Remove Duplicates from Sorted Array

Approach:
Compared current element with the previous one and stored only unique values using a pointer.

Key Learning:
Sorted arrays unlock simpler logic — recognizing structure in input data is powerful.

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty()) return 0;
        int idx = 1;
        for(int i = 1; i < nums.size(); i++) {
            if(nums[i] != nums[i-1]) {
                nums[idx++] = nums[i];
            }
        }
        return idx;
    }
};

🧠 Reflection

Early DSA problems look simple, but they build essential habits:

thinking in-place,
minimizing extra memory,
recognizing reusable patterns.

This challenge isn’t about speed — it’s about consistent improvement.

📍 Next Target: Top 150 continues…

If you’re also working on DSA or building consistency in problem solving, let’s grow together.

🔗 GitHub — https://github.com/CodeWithDeeksh
🐦 X — https://x.com/deekshithax

One problem at a time. Consistency over intensity.

🚀 Building in Public: My Tech Learning Journey

Deekshitha — Sun, 01 Mar 2026 09:57:12 +0000

Hi, I’m Deekshitha, a 2nd-year Computer Science student exploring Data Structures & Algorithms, AI/ML, and real-world problem building.

Instead of learning silently, I’ve decided to document my journey openly — sharing not just outcomes, but the thinking, experiments, failures, and lessons behind them.

Here’s what I’ll be sharing:

• 📌 DSA Journey — problem-solving approaches, patterns, and how I reason through challenges
• 🤖 AI / ML Learning — concepts, implementations, and practical exploration
• 🧠 LLM Research & Experimentation — understanding modern AI systems by building with them
• 🛠 Projects — from idea → execution → learnings

The goal is simple: learn deeply, build consistently, and share openly.

I believe learning matters most when it turns into technology that creates real impact.

If you’re passionate about building, learning, or collaborating on cool and meaningful projects, let’s connect and create something impactful together.

🔗 GitHub — https://github.com/CodeWithDeeksh
🐦 X (Twitter) — https://x.com/deekshithax

Documenting the journey — one problem, one project, one breakthrough at a time.