Divyansh Upadhyay’s Post

🚀 Day 11/30 | LeetCode Problem: Merge Two Sorted Lists (21) Problem: You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted linked list and return its head. 💡 Approach (Recursive) Since both lists are already sorted: If one list is empty → return the other. Compare the current values of both lists. Attach the smaller node to the result. Recursively merge the remaining nodes. This keeps the final list sorted automatically. ⏱ Complexity Time Complexity: O(n + m) Space Complexity: O(n + m) (due to recursion stack) 🧠 Python Code class Solution: def mergeTwoLists(self, list1, list2): if not list1: return list2 if not list2: return list1 if list1.val < list2.val: list1.next = self.mergeTwoLists(list1.next, list2) return list1 else: list2.next = self.mergeTwoLists(list1, list2.next) return list2 📌 Example Input: list1 = [1,2,4] list2 = [1,3,4] Output: [1,1,2,3,4,4] 🎯 Key Takeaway When working with sorted data structures, compare and attach is a powerful pattern. Also, recursion makes linked list problems elegant and clean. ✅ Accepted 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day11 #Python #LinkedList #Recursion #DataStructures #Algorithms #ProblemSolving #CodingJourney

Day 6 was the most hands-on day yet. I stopped looking at Python as a collection of rules and started using it as a high-powered filter for data. Here is how Day 6 changed my perspective on Algorithms and Strings: 🔹 The Accumulator Pattern: I learned how to make a loop remember things. Whether it’s counting occurrences, summing up values, or finding the average, it’s all about maintaining a state while the loop churns through data. 🔹 The Search Party: I built logic to find the largest and smallest values in a set. Realizing that Smallest is tricky—you have to be careful with how you initialize your variables, or your starting "zero" might accidentally become your answer. 🔹 Strings are Collections: I used to think of a word as just "text." Now I see it as a sequence. I’ve learned to Slice strings to grab exactly what I need, Strip away the "noise" (whitespace), and use Parsing to extract specific data from a messy block of text. 🔹 The "In" Operator: Python’s readability shines here. Using if 'search_term' in text: feels like writing English, but it’s actually a powerful logical tool for filtering information instantly. Next up: File Handling. I’m moving from typing data manually into the console to letting Python read and analyze entire documents for me. 📂 #Python #DataAnalysis #CodingJourney #BuildInPublic #SoftwareLogic #Algorithms #StringManipulation

🚀 Day 7/30 | LeetCode Problem: Two Sum (1) Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target. You may assume exactly one solution exists. 💡 Approach (Hash Map – Optimal Solution) Instead of checking every pair (which takes O(n²)), we use a dictionary (hash map) to store previously seen numbers. Steps: Iterate through the array. For each number, compute target - current_number. If that value exists in the dictionary → we found the answer. Otherwise, store the needed complement in the dictionary. This reduces the time complexity significantly 🚀 ⏱ Complexity Time Complexity: O(n) Space Complexity: O(n) 🧠 Python Code class Solution: def twoSum(self, nums, target): dis = {} for i in range(len(nums)): if nums[i] in dis: return [dis[nums[i]], i] else: a = target - nums[i] dis[a] = i 📌 Example Input: nums = [2,7,11,15] target = 9 Output: [0,1] 🎯 Key Takeaway Using a hash map can reduce brute-force nested loops into a single-pass solution. Understanding data structures makes problems much easier. ✅ Accepted | 100% runtime 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day7 #Python #HashMap #DataStructures #Algorithms #ProblemSolving #CodingJourney #SoftwareEngineering

🚀 Day 8/30 | LeetCode Problem: Merge Sorted Array (88) Problem: You are given two sorted arrays nums1 and nums2, and two integers m and n representing the number of initialized elements in each array. Merge nums2 into nums1 as one sorted array. The final result should be stored inside nums1. 💡 Approach Since nums1 already has enough space at the end (filled with 0s), Steps: Copy elements of nums2 into the empty positions of nums1 Sort the entire nums1 array This ensures the final array remains sorted. ⏱ Complexity Time Complexity: O((m+n) log(m+n)) → due to sorting Space Complexity: O(1) → in-place modification 🧠 Python Code class Solution: def merge(self, nums1, m, nums2, n): for i in range(n): nums1[m + i] = nums2[i] nums1.sort() return nums1 📌 Example Input: nums1 = [1,2,3,0,0,0], m = 3 nums2 = [2,5,6], n = 3 Output: [1,2,2,3,5,6] 🎯 Key Takeaway Sometimes a straightforward solution works perfectly. Optimization (like using two pointers from the end) can further improve time complexity — but clarity first, then optimization. ✅ Accepted | 100% Runtime 🔖 Hashtags #LeetCode #30DaysOfLeetCode #Day8 #Python #Arrays #Sorting #DataStructures #Algorithms #ProblemSolving #CodingJourney

🚀Day 12 of #75DaysofLeetcode LeetCode #11 – Container With Most Water (Medium) Today I solved the classic Two Pointer problem: Container With Most Water. 🔎 Problem Summary: Given an array height, each element represents a vertical line. The goal is to choose two lines such that together with the x-axis they form a container that holds the maximum amount of water. 💡 Key Insight: Instead of checking all pairs (O(n²)), we can use the Two Pointer Technique: ✔ Start with one pointer at the beginning and one at the end ✔ Calculate the container area using area = min(height[left], height[right]) * (right - left) ✔ Move the pointer pointing to the smaller height ✔ Keep track of the maximum area ⚡ Optimal Complexity: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 💻 Python Implementation: from typing import List class Solution: def maxArea(self, height: List[int]) -> int: left, right = 0, len(height) - 1 max_water = 0 while left < right: area = min(height[left], height[right]) * (right - left) max_water = max(max_water, area) if height[left] < height[right]: left += 1 else: right -= 1 return max_water 📚 This problem reinforced how two pointers can reduce a brute force problem from O(n²) to O(n). Consistency in solving problems daily is slowly improving my problem-solving skills and algorithmic thinking. 💪 #LeetCode #DSA #Python #TwoPointers #ProblemSolving #CodingPractice #100DaysOfCode

NumPy Memory Order: Choose C vs F to Match Your Data Access (and Get Faster Code) In Python's NumPy, you can control how an array is stored in contiguous memory using the order setting. There are two order styles: C-style F-style A = [ [1, 2, 3], [4, 5, 6] ] 1) C-order (Row-major): Data is laid out row by row → best when you process one person/record at a time. Syntax: a_c = np.array(a, order="C") Memory: [ 1, 2, 3, 4, 5, 6 ] Walk : (0,0)(0,1)(0,2)(1,0)(1,1)(1,2) 2) F-order (Column-major): data is laid out column by column → best when you process one feature/column for everyone Syntax: a_f = np.array(a, order="F") Memory: [ 1, 4, 2, 5, 3, 6 ] Walk : (0,0)(1,0)(0,1)(1,1)(0,2)(1,2) Row slicing is “cheap” in C-order. Column slicing is “cheap” in F-order. Performance takeaway: -->fewer cache misses. -->faster scans in your hot loop.  -->lower memory overhead. -->more stable latency. -->no hidden copies during slicing/transforms/native calls.

Have you ever noticed how much of your code is actually just working with text? The more I program in Python, the more I respect how powerful string handling really is. Strings may look simple, but they are one of the most essential data types in real-world applications. One key lesson I learned early is that text value is immutable. That means when I “change” a string, I’m actually creating an updated copy, not modifying the original text.If I forget to assign the result to cleaned text or formatted line, nothing is saved. Methods like replace(), upper(), lower(), title(), and capitalize() help me quickly transform raw_input into polished_output. For example, I can take greeting_line and turn it into greeting_line.upper() for emphasis, while the source remains untouched. When handling user_input or file_content, I often rely on strip(), lstrip(), and rstrip() to remove unwanted spaces or noisy_characters. But I use them carefully, because removing the wrong symbols can turn meaningful data into an empty string. That small detail can break validation logic in seconds. My advice to developers is simple. Always store transformation results in a new variable like normalized_text instead of reusing vague names like s or temp. Validate input_length before and after cleaning. And remember that chaining methods like raw_text.strip().lower() is powerful, but readability still matters. Clean text processing creates clean software architecture. #evgenprolife #Python #Programming #CodeQuality #SoftwareDevelopment #LearnToCode #BackendDevelopment #CleanCode #PythonTips #DeveloperLife #CodingJourney

I wasted 3 hours thinking my code was broken. It wasn't. The GIL was just laughing at me. I had this Python script doing heavy data processing. Added multi-threading to speed it up. Ran it. Expected magic. Got... the exact same speed. Maybe even slower. I checked my logic. Checked my threads. Googled everything. Then finally someone in a forum said — "Bro, that's just the GIL." So what even IS the GIL? In simple words — Python has this rule that says only one thread can run at a time, no matter how many cores your machine has. It's called the Global Interpreter Lock. It exists to keep Python's memory safe, but it also means your threads aren't actually running in parallel when doing heavy computation. I felt cheated honestly. But here's what actually helped me: → Switched to multiprocessing — each process has its own GIL. Problem solved. → For API calls and I/O stuff? asyncio is your best friend. → Libraries like NumPy actually release the GIL during computation. Smart. → Python 3.13 is experimenting with making the GIL optional. The future looks good. The GIL isn't evil. It's just something nobody tells you about when you're starting out — and you only discover it when you're sitting there confused at 2am wondering why your "optimized" code is still slow. If this saves even one person that 3-hour spiral, this post was worth it. Have you hit the GIL wall before? What did you do? Let me know below #Python #PythonDeveloper #Programming #LearnPython #SoftwareEngineering #CodingLife #TechCommunity

Insert Interval (LeetCode 57) - Medium I explored a more optimized way to handle intervals when the input is already sorted. Instead of re-sorting everything, I learned how to process the intervals in a single linear pass. Key Learnings: * Linear Scan: Since the input is sorted, we can divide the problem into three logical parts: Before overlap, During overlap (merge), and After overlap. * In-place Merging: For the overlapping part, we simply update the start to the min and the end to the max of the conflicting intervals. * Efficiency: No sorting means we save time! This approach is much faster for pre-sorted data. Complexity: ⏱️ Time Complexity: O(N) — because we only iterate through the list once. 📂 Space Complexity: O(N) — to store the result list. Consistency is the key #LeetCode #CodingJourney #Blind75 #SDEPrep #DataStructures #Python #ProblemSolving #TechCommunity

Thinking through decision logic before writing anything. At some point, every program has to make a decision. Whether to continue or stop. Whether a condition is met or not. Whether one path should run instead of another. This is what decision logic exists for. Decision logic works by evaluating conditions exactly as they are written. Nothing is inferred, and nothing is implied. If a condition is incomplete or unclear, the behavior that follows will reflect that directly. This is why decision logic is less about syntax and more about precision. Each condition is a statement about what must be true. Each branch defines what should happen when that statement holds and what happens when it doesn’t. When logic is well-defined, code behaves predictably. When it isn’t, code may still run, but the outcome becomes unreliable. In data work especially, decision logic shapes how data is filtered, categorized, and acted upon. Small assumptions at this level can quietly affect results downstream. Decision logic doesn’t make code clever. It makes behavior explicit. Day 25 / 30 #30DaysOfDataScience #Indepthsofdatascience #Python #DecisionLogic #LearningInPublic