DEV Community: hassam bin shahid

🚀 DSA Progress Update | Solved 3 LeetCode Problems

hassam bin shahid — Mon, 20 Jul 2026 16:08:44 +0000

🚀 DSA Progress Update | Solved 3 LeetCode Problems

Today's LeetCode session was focused on strengthening my understanding of three fundamental problem-solving patterns that frequently appear in technical interviews.

✅ Problems Solved

🔹 682. Baseball Game

Pattern: Stack
Built a score history using a stack to efficiently process operations such as +, D, and C.
Time Complexity: O(n)

stack = []

for op in operations:
    if op == "+":
        stack.append(stack[-1] + stack[-2])
    elif op == "D":
        stack.append(2 * stack[-1])
    elif op == "C":
        stack.pop()
    else:
        stack.append(int(op))

return sum(stack)

🔹 1456. Maximum Number of Vowels in a Substring of Given Length

Pattern: Sliding Window
Optimized the brute-force approach by maintaining a fixed-size window and updating the vowel count in constant time.
Time Complexity: O(n)

vowels = {'a', 'e', 'i', 'o', 'u'}

count = sum(1 for ch in s[:k] if ch in vowels)
maximum = count

for i in range(k, len(s)):
    if s[i-k] in vowels:
        count -= 1
    if s[i] in vowels:
        count += 1
    maximum = max(maximum, count)

return maximum

🔹 134. Gas Station

Pattern: Greedy Algorithm
Learned how tracking the fuel balance helps identify the only valid starting station while solving the problem in linear time.
Time Complexity: O(n)

if sum(gas) < sum(cost):
    return -1

start = 0
tank = 0

for i in range(len(gas)):
    tank += gas[i] - cost[i]

    if tank < 0:
        start = i + 1
        tank = 0

return start

💡 Key Takeaways

✔️ Choosing the right algorithmic pattern is often more important than writing more code.

✔️ Today's practice reinforced three essential interview concepts:

Stack
Sliding Window
Greedy Algorithm

Every problem I solve improves not only my coding skills but also my ability to analyze problems, optimize solutions, and think like a software engineer.

I'm committed to solving LeetCode problems consistently and documenting my progress as I continue growing in Data Structures & Algorithms.

LeetCode #Python #DSA #Algorithms #ProblemSolving #SoftwareEngineering #CodingJourney #100DaysOfCode #Tech #Developer #LearningInPublic

🚀 DSA Journey | Solved 3 LeetCode Problems in Python

hassam bin shahid — Sat, 18 Jul 2026 18:21:24 +0000

Today's practice focused on three different algorithmic patterns, each reinforcing an important concept in problem solving and writing efficient code.

✅ 1. To Lower Case (LeetCode 709)

Concept: String Manipulation

class Solution:
    def toLowerCase(self, s: str) -> str:
        return s.lower()

Key Takeaway: Reviewed string operations and learned how character conversion can also be implemented using ASCII values.

✅ 2. Product of Array Except Self (LeetCode 238)

Concept: Prefix & Suffix Products

class Solution:
    def productExceptSelf(self, nums):
        n = len(nums)
        ans = [1] * n

        prefix = 1
        for i in range(n):
            ans[i] = prefix
            prefix *= nums[i]

        suffix = 1
        for i in range(n - 1, -1, -1):
            ans[i] *= suffix
            suffix *= nums[i]

        return ans

Key Takeaway: Practiced solving array problems in O(n) time without using division by leveraging prefix and suffix products.

✅ 3. Maximum Average Subarray I (LeetCode 643)

Concept: Sliding Window

class Solution:
    def findMaxAverage(self, nums, k):
        window_sum = sum(nums[:k])
        max_sum = window_sum

        for i in range(k, len(nums)):
            window_sum += nums[i] - nums[i - k]
            max_sum = max(max_sum, window_sum)

        return max_sum / k

Key Takeaway: Applied the Sliding Window technique to optimize repeated calculations and reduce the time complexity to O(n).

Every LeetCode problem teaches more than just syntax—it strengthens analytical thinking, algorithm selection, and code optimization. Consistency in practice is helping me build a stronger foundation in Data Structures and Algorithms, one problem at a time.

I'm looking forward to tackling more challenging problems and continuing to grow as a software engineer.

💻 Language: Python
📚 Topics Covered: String Manipulation, Prefix & Suffix Products, Sliding Window

LeetCode #Python #DSA #Algorithms #ProblemSolving #SoftwareEngineering #CodingJourney #100DaysOfCode #Developer #Programming

# 🚀 Solving 3 LeetCode Problems in Python: String Manipulation, Hashing, and Data Structures

hassam bin shahid — Mon, 13 Jul 2026 18:41:30 +0000

🚀 Solving 3 LeetCode Problems in Python: String Manipulation, Hashing, and Data Structures

Consistency is the key to becoming a better software engineer. As part of my daily Data Structures and Algorithms (DSA) practice, I solved three LeetCode problems that strengthened my understanding of string manipulation, hash maps, and designing efficient data structures.

📌 Problems Solved Today

1️⃣ Length of Last Word (LeetCode #58)

Problem:
Given a string consisting of words and spaces, return the length of the last word.

Approach:
I removed any trailing spaces using strip(), split the string into words, and returned the length of the last word.

Python Solution

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        return len(s.strip().split()[-1])

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

2️⃣ Max Number of K-Sum Pairs (LeetCode #1679)

Problem:
Given an integer array nums and an integer k, return the maximum number of operations where each operation removes two numbers whose sum equals k.

Approach:
I used a Hash Map (dictionary) to keep track of previously seen numbers. For every element, I searched for its complement (k - num). If found, I formed a valid pair; otherwise, I stored the current number for future matching.

Python Solution

from collections import defaultdict

class Solution:
    def maxOperations(self, nums, k):
        count = defaultdict(int)
        operations = 0

        for num in nums:
            complement = k - num

            if count[complement] > 0:
                operations += 1
                count[complement] -= 1
            else:
                count[num] += 1

        return operations

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

3️⃣ Insert Delete GetRandom O(1) (LeetCode #380)

Problem:
Design a data structure that supports insertion, deletion, and returning a random element in average O(1) time.

Approach:
The optimal solution combines:

A list for storing elements.
A hash map to store the index of each element.

This combination enables constant-time insertion, deletion (by swapping with the last element), and random access.

Python Solution

import random

class RandomizedSet:

    def __init__(self):
        self.nums = []
        self.pos = {}

    def insert(self, val: int) -> bool:
        if val in self.pos:
            return False

        self.pos[val] = len(self.nums)
        self.nums.append(val)
        return True

    def remove(self, val: int) -> bool:
        if val not in self.pos:
            return False

        idx = self.pos[val]
        last = self.nums[-1]

        self.nums[idx] = last
        self.pos[last] = idx

        self.nums.pop()
        del self.pos[val]

        return True

    def getRandom(self) -> int:
        return random.choice(self.nums)

Time Complexity

Insert: O(1)
Remove: O(1)
GetRandom: O(1)

Space Complexity: O(n)

💡 Key Takeaways

✔️ Improved string manipulation techniques.
✔️ Strengthened understanding of Hash Maps for efficient lookups.
✔️ Learned how combining arrays and hash maps enables constant-time operations.
✔️ Reinforced the importance of choosing the right data structure for optimized solutions.

Every LeetCode problem is an opportunity to think critically, write cleaner code, and improve algorithmic problem-solving skills. Small, consistent improvements today lead to significant growth tomorrow.

If you're also practicing DSA, I'd love to connect and discuss different approaches to solving problems. Happy coding! 🚀

LeetCode #DSA #Python #Algorithms #DataStructures #ProblemSolving #SoftwareEngineering #Coding #Programming #TechCommunity #100DaysOfCode #DeveloperJourney

🚀 DSA Journey Update | Solved 3 LeetCode Problems in Python

hassam bin shahid — Sat, 11 Jul 2026 10:11:35 +0000

Continuing my journey of improving problem-solving skills and strengthening my Data Structures & Algorithms fundamentals.

Today, I solved three important LeetCode problems that helped me practice different algorithmic techniques:

✅ Roman to Integer (LeetCode #13)
🔹 Learned how to handle symbol mapping and subtraction patterns using Hash Maps.

✅ Container With Most Water (LeetCode #11)
🔹 Improved my understanding of the Two Pointer technique to achieve an optimized O(n) solution.

✅ H-Index (LeetCode #274)
🔹 Practiced sorting-based problem solving and learned how to analyze citation-based conditions efficiently.

Key Takeaways:

✔️ Choosing the right algorithm can significantly improve performance.
✔️ Understanding patterns like Two Pointers and Sorting helps solve complex problems faster.
✔️ Consistent practice builds strong problem-solving skills.

Every problem solved is another step toward becoming a better software engineer. 🚀

LeetCode #DSA #Python #Algorithms #DataStructures #SoftwareEngineering #CodingJourney #100DaysOfCode

🚀 Solving 3 LeetCode Problems: Arrays, Strings, and Greedy Algorithms

hassam bin shahid — Thu, 09 Jul 2026 19:02:07 +0000

As part of my daily Data Structures and Algorithms (DSA) practice, today I focused on solving three LeetCode problems that strengthened my understanding of arrays, string manipulation, and greedy algorithms.
Consistent practice is helping me improve my problem-solving skills and prepare for coding interviews.

📌 Problems Solved

1. Monotonic Array (LeetCode 896)

Concept: Arrays

The goal was to determine whether an array is entirely non-decreasing or non-increasing.

What I Learned

How to identify increasing and decreasing trends in a single traversal.
Why checking both possibilities simultaneously leads to an efficient solution.
Time Complexity: O(n)
Space Complexity: O(1)

2. String Compression (LeetCode 443)

Concept: Two Pointers, Strings

This problem required compressing a character array in-place without using extra memory.

What I Learned

Applying the Two Pointers technique for reading and writing.
Performing in-place modifications efficiently.
Handling multi-digit counts correctly during compression.
Time Complexity: O(n)
Space Complexity: O(1)

3. Jump Game II (LeetCode 45)

Concept: Greedy Algorithm

The challenge was to find the minimum number of jumps needed to reach the last index.

What I Learned

How greedy algorithms can produce optimal solutions.
Tracking the farthest reachable position while minimizing jumps.
Understanding why greedy outperforms brute-force approaches for this problem.
Time Complexity: O(n)
Space Complexity: O(1)

💡 Key Takeaways

Today's practice reinforced several important concepts:

Efficient array traversal techniques.
In-place string manipulation using Two Pointers.
Solving optimization problems with Greedy Algorithms.
Writing clean, optimized Python code with linear time complexity whenever possible.

The more problems I solve, the better I become at recognizing patterns and selecting the right algorithmic approach.

🎯 Next Goal

I'm committed to solving LeetCode problems every day to strengthen my fundamentals in Data Structures & Algorithms and become a better software engineer.

If you're also practicing DSA, I'd love to hear about your favorite problem-solving strategies or discuss different approaches in the comments.

Happy Coding! 🚀

🏷️ Tags

#leetcode #python #algorithms #datastructures

🚀 My Daily DSA Practice – Solving 6 LeetCode Problems (Greedy + Arrays)

hassam bin shahid — Mon, 06 Jul 2026 18:09:03 +0000

📌 Introduction

Today I focused on strengthening my understanding of Greedy Algorithms and Array-based problems by solving multiple LeetCode questions.

This practice helped me improve my pattern recognition, problem-solving speed, and coding efficiency in Python.

🧠 Problems Solved

Sign of the Product of an Array

Instead of calculating full multiplication, we only track:

Number of negative values
Presence of zero

👉 Key idea:

Even negatives → 1
Odd negatives → -1
Zero → 0

Is Subsequence

Used Two Pointers Technique:

Traverse both strings
Match characters in order

👉 Time Complexity: O(n)

Best Time to Buy and Sell Stock II

Used Greedy Approach:

Add every positive difference

👉 Idea: Profit comes from every upward trend.

Can Make Arithmetic Progression Sort array Check constant difference between elements

👉 Time Complexity: O(n log n)

Increasing Triplet Subsequence

Used greedy tracking:

first smallest
second smallest larger than first

👉 If third number found → return True

Jump Game

Track maximum reachable index:

If index > max reach → return False
💡 Key Learnings
Greedy algorithms simplify complex problems using local optimal choices.
Two pointers help reduce nested loops to linear time.
Tracking variables (min, max, bounds) is often enough instead of brute force.
Pattern recognition is the most important skill in DSA.
⚡ Skills Improved Today
Greedy Algorithms
Two Pointers Technique
Array Manipulation
Time Complexity Optimization
Python Problem Solving
🚀 Conclusion

Consistency is the key in mastering DSA. Each problem improves my ability to think logically and recognize patterns faster.

I will continue solving problems daily and sharing my learning journey.

🚀 DSA Journey – Daily Learning Update

hassam bin shahid — Fri, 03 Jul 2026 17:21:23 +0000

🚀 DSA Journey – Daily Learning Update

Today's learning session focused on strengthening my understanding of Arrays, Two Pointers, and Greedy Algorithms by solving three LeetCode problems in Python.

✅ Problems Solved

Sign of the Product of an Array – Learned how to determine the sign of a product without computing the entire multiplication by tracking zeros and negative numbers.
Is Subsequence – Practiced the Two Pointers technique to efficiently verify whether one string is a subsequence of another.
Best Time to Buy and Sell Stock II – Applied a Greedy Algorithm to maximize profit by capturing every positive price difference.

💡 Key Takeaways

Strengthened problem-solving skills through pattern recognition.
Improved understanding of Greedy Algorithms and Two Pointers.
Practiced writing optimized Python solutions with efficient time and space complexity.
Continued building consistency in my daily Data Structures & Algorithms journey.

Every problem solved is another step toward becoming a better software engineer. Consistency, discipline, and continuous learning remain my biggest priorities.

💻 Today's LeetCode Progress

✅ Sign of the Product of an Array
✅ Is Subsequence
✅ Best Time to Buy and Sell Stock II

🐍 Language: Python

LeetCode #DSA #Python #Algorithms #GreedyAlgorithm #TwoPointers #Arrays #ProblemSolving #SoftwareEngineering #CodingJourney #LearningInPublic #TechJourney #ComputerScience #OpenToWork

My First Step into LeetCode and Problem Solving Journey

hassam bin shahid — Wed, 17 Jun 2026 17:56:51 +0000

As a BSIT student passionate about Software Engineering, Data Structures & Algorithms, and Machine Learning, I have recently begun a consistent problem-solving journey on LeetCode. This is my first step toward improving my coding skills and strengthening my logical thinking.
One of the first problems I worked on was “Merge Strings Alternately”. At first, it looked simple, but it helped me understand how important it is to break problems into smaller steps and think clearly about edge cases.
Through this problem, I learned how to:
Traverse two strings simultaneously
Handle different lengths of input
Build a new string step by step
Improve my coding efficiency in Python
Here is a simple approach I used:
Use two pointers for both strings
Alternate characters from each string
Append remaining characters when one string ends
This small problem gave me confidence that consistent practice is the key to improving in DSA.
Key Takeaways
Start with small problems and build consistency
Focus on logic, not just syntax
Practice improves speed and confidence
Every problem teaches something new
This is just the beginning of my journey. I will continue solving problems, learning new concepts, and sharing my progress here on Medium.