Vishal Balasubramanian’s Post

LeetCode Progress | 258. Add Digits (Python) Today I solved “Add Digits” on LeetCode. Problem: Given an integer num, repeatedly add its digits until the result has only one digit, and return it. My approach: I used an iterative digit-sum process. -- Repeatedly extracted digits using modulo and division -- Summed the digits until the number became a single digit -- Returned the final value Optimal approach (O(1) without loops): This problem follows the mathematical concept of a Digital Root. The result can be found using: -- If num == 0, return 0 -- Otherwise, return 1 + (num - 1) % 9 This avoids iteration entirely and runs in constant time. What I learned: -- Some problems that look iterative have hidden mathematical patterns -- Recognizing number properties (like digital roots) can lead to O(1) solutions -- Always look for a formula when repeated digit operations are involved #leetcode #python #dsa #datastructures #algorithms #coding #programming #problemSolving #softwareengineering #computerscience #interviewprep #codinginterview #100daysofcode #pythonprogramming

Headline: Stop writing loops to clean your data. 🛑 One of the most common tasks in Python is handling duplicate entries. While you could write a for-loop with a conditional check, there’s a much faster, more "Pythonic" way to do it: Sets. Sets are unordered collections of unique elements. By casting your list to a set, Python handles the heavy lifting of deduplication instantly. Why use this? ✅ Cleaner, more readable code. ✅ Better performance for large datasets. ✅ Built-in membership testing (O(1) complexity). How are you using Sets in your current workflow? Let’s discuss below! 👇 #PythonProgramming #Pyspiders #CodingTips #SoftwareDevelopment

🚀 Day 4/30 | LeetCode Problem: Running Sum of 1D Array (1480) Problem: Given an array nums, return the running sum, where each element at index i is the sum of elements from index 0 to i. Approach: Initialize a variable to store the cumulative sum Traverse the array one by one Add each element to the cumulative sum Store the result in a new list This is a simple single-pass solution. Time Complexity: O(n) Space Complexity: O(n) Python Code: class Solution: def runningSum(self, nums): a = 0 b = [] for i in nums: a = a + i b.append(a) return b Example: Input: [1, 2, 3, 4] Output: [1, 3, 6, 10] Takeaway: Running sum is a basic form of prefix sum, which is very useful in many array problems. 📌 Accepted ✅ | All test cases passed 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day4 #Python #DSA #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering #TechCommunity

🚀 Day 7/30 | LeetCode Problem: First Unique Character in a String (387) Problem: Given a string s, find the first non-repeating character and return its index. If it doesn't exist, return -1. Approach: Use a dictionary to count occurrences of each character Traverse the string a second time to find the first character with count 1 Return its index Time Complexity: O(n) → Two passes over the string Space Complexity: O(1) → Dictionary holds at most 26 letters (for lowercase English letters) Python Code: class Solution: def firstUniqChar(self, s): a = {} for i in s: if i in a: a[i] += 1 else: a[i] = 1 for i in range(len(s)): if a[s[i]] == 1: return i return -1 Example: Input: "leetcode" Output: 0 → 'l' is the first unique character Input: "loveleetcode" Output: 2 → 'v' is the first unique character Takeaway: Counting occurrences is a common technique for string problems and can be applied to many scenarios like finding duplicates, frequency analysis, etc. 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day7 #Python #Strings #DSA #ProblemSolving #CodingJourney #SoftwareEngineering #TechCommunity

Multiple inheritance in Python can be powerful when a class genuinely needs to combine behaviors from different parents (e.g., a string-like object that also counts elements). But the moment those inheritance paths reconnect, you run into the classic diamond problem: the same base class can be reached through multiple routes, so method lookup can become ambiguous if it isn’t handled consistently. Python addresses this with the Method Resolution Order (MRO), computed via C3 linearization. In practice, this gives a predictable search path for attributes and methods: subclasses are checked before base classes, and the order of base classes in the class definition matters. When things are well-formed, you can always inspect the exact lookup chain using ClassName.__mro__ to understand why a specific method implementation is selected. super() fits into this same model: it forwards the call to the next class in the MRO—not simply “the parent.” That makes cooperative multiple inheritance possible (especially with mixins), but it also raises the bar for design discipline. When the goal is clean, safe APIs, the recommended default is often composition over inheritance, keeping mixins small and focused, and using narrower interfaces (e.g., protocols) so classes expose only what they truly need. #Python #SoftwareEngineering #OOP #Programming #CleanCode

There's a nagging feeling when you see certain code. The kind that feels like a winding path with too many steps. It often stems from a misunderstanding of how to break down complex problems. We tend to build things up incrementally, sometimes creating unnecessary layers of state management. The fix is simple: embrace recursion. Think of calculating factorial: 5! = 5 * 4!. Each step is the same problem, just a smaller version. Python makes this straightforward. def factorial(n): if n == 0: # Base case return 1 else: return n * factorial(n - 1) # Recursive step This approach leads to cleaner, more elegant solutions. Fewer bugs. Better focus. More maintainable code. #Python #Recursion #SoftwareEngineering #CodeQuality

LeetCode Problem 19: "Given the head of a linked list, remove the nth node from the end of the list and return its head." The below implementation is simple and clear- Approach Double traverse the list, once to calculate the length of the list and second time to find the position of the node to be deleted. Maintain two pointers at each iteration, one to keep track present node and second to keep track of previous node. position is calculated by using the formula: pos = (len of list-n)+1 Complexity Time complexity: O(m) where m is length of list Space complexity: O(1) i.e. constant #Python #LeetCode #CompetitiveProgramming #TwoPointers #ProblemSolving #LinkedList #Algorithms #DataStructures

Stop memorising syntax. Start understanding the mechanics. 🧠🐍 Most beginners quit programming not because the code is hard, but because the vocabulary is confusing. They write class or import without knowing why those words exist or what they actually do to the machine. In Day 3 of my Python Fundamentals 2026 series, we stop coding to build a "Mental Map." We break down the 16 Most Critical Python Concepts using real-world analogies that stick: Program vs. Code: Why one is just "Sticky Notes", and the other is a "Full Recipe." The Interpreter: Why Python is like a "Street Food Vendor" (order-by-order) vs. a "Restaurant Kitchen" (Compiler). Indentation: It’s not just style; it’s a strict "Nested To-Do List" that prevents crashes. If you want to move beyond "Hello World" and understand the architecture of the language, this 15-minute guide is for you. 👉 Watch the full breakdown here: [https://lnkd.in/dUHyk-2D] #Python #DataScience #LearningToCode #SoftwareEngineering #Python2026 #TechEducation

We all hit those moments. You're debugging a complex function, and a simple, repeated calculation keeps tripping you up. It feels like you're writing the same logic over and over, tangled in nested loops that are hard to trace. This often happens because we're trying to solve a problem by breaking it down into smaller, identical versions of itself. We're thinking about "what's the answer for this input, and how does it relate to the answer for a slightly smaller input?" The fix is to embrace recursion. Think about calculating factorial. 5! is 5 4!. And 4! is 4 3!, and so on, until you reach the simplest case: 1! is just 1. In Python, this looks elegant: def factorial(n): if n == 1: return 1 else: return n * factorial(n - 1) The function calls itself with a smaller input until it hits the base case. This approach leads to cleaner, more readable code. It simplifies complex problems into understandable, self-similar steps. Less code to write. Fewer bugs to find. Easier to reason about. #Python #Recursion #SoftwareEngineering #CodingTips #SeniorEngineer