Why Tuples are a Superpower in Professional Code

🚀 Day 74 of #100DaysOfCode 🧩 LeetCode 220 – Contains Duplicate III (Hard) Today’s problem was a solid mix of logic + optimization. Not brute-force friendly at all — you have to think smart. 🔍 Problem Statement: Given an array "nums" and two integers "indexDiff" and "valueDiff", check if there exist two indices "i" and "j" such that: ✔️ "i ≠ j" ✔️ "|i - j| ≤ indexDiff" ✔️ "|nums[i] - nums[j]| ≤ valueDiff" 💡 Approach Used (Bucket + Sliding Window): Instead of comparing every pair (which would be too slow), I used: 👉 Bucketization Technique 👉 Sliding Window Constraint Each number is placed into a bucket of size "valueDiff + 1". - Same bucket ⇒ valid pair - Neighbor buckets ⇒ check manually - Maintain only last "indexDiff" elements ⚡ Why this works: It reduces time complexity from O(n²) → O(n) 📊 My Performance: ⏱️ Runtime: 139 ms 💾 Memory: 37.38 MB 🔥 Key Learning: Efficient problems are less about coding and more about choosing the right data structure. #Day74 #LeetCode #100DaysOfCode #DSA #CodingJourney #Python #ProblemSolving #Consistency

Mistakes are part of the process Day 7 – #100DaysOfCode ⏰ Time Spent: 2 hours ⚒️ What I Did: * Yesterday I have learned one way to read scatter plots , today I Practiced that . * Modified my function to make it reusable * Plotted relationships between complaints and aggregated features I observed only these two trends: * log(x) vs y → logarithmic trend [ y = a · log(x) + b ] * log(x) vs log(y) → power law [ y = k · xᵃ ] But then I realized something important… I was plotting a sum on the x-axis, which naturally increases the values which created misleading patterns. So I switched to mean,but the trends disappeared. Which implies no relation but I'll experiment with few other transformations before I conclude that --- 🚪 Links: * Repo: [https://lnkd.in/g7zsMygp) --- 🧠 Learning: Bad feature choice can create fake patterns. 📌 Closing: Should try to work on these things when I am not tired ( Mornings / After a nap ) #DataScience #DataAnalytics #Python #CodingJourney

Leveling Up with Functions Focus: Functions, Scope, and Efficiency Day 8(04-04-2026): Today was the day I stopped repeating myself! I dove into Functions, and it’s a total game-changer for writing clean code. Instead of writing the same logic over and over, I can now "wrap" it into a function and call it whenever I need it. It’s all about working smarter, not harder. Key concepts I tackled: Parameters vs. Arguments: Understanding the difference between what a function expects and what I actually give it. The Return Statement: Learning how to get a result back from a function so I can use it elsewhere. Variable Scope: This one was tricky! Understanding why a variable created inside a function "disappears" once the function is done (Global vs. Local). In-built Libraries: Starting to explore the massive world of pre-written tools Python offers. It feels like I’m finally moving from writing "scripts" to building "systems." 🏗️ #PythonFunctions #CleanCode #Day8 #TechSkills #CodingLogic

🐍 Why 𝐢𝐧𝐩𝐥𝐚𝐜𝐞=𝐓𝐫𝐮𝐞 in Pandas Isn’t Always a Good Idea 🚨It looks convenient… but can lead to unexpected issues. 👉𝐖𝐡𝐚𝐭 𝐝𝐨𝐞𝐬 𝐢𝐧𝐩𝐥𝐚𝐜𝐞=𝐓𝐫𝐮𝐞 𝐝𝐨? It directly modifies the original DataFrame. df.dropna(inplace=True) 👉𝐒𝐨𝐮𝐧𝐝𝐬 𝐞𝐟𝐟𝐢𝐜𝐢𝐞𝐧𝐭? 𝐘𝐞𝐬. 𝐁𝐮𝐭 𝐡𝐞𝐫𝐞’𝐬 𝐭𝐡𝐞 𝐜𝐚𝐭𝐜𝐡👇 ⚠️𝐖𝐡𝐲 𝐢𝐭 𝐜𝐚𝐧 𝐛𝐞 𝐫𝐢𝐬𝐤𝐲: • Original data gets overwritten • Difficult to debug mistakes • No easy way to revert changes 🎯𝐁𝐞𝐭𝐭𝐞𝐫 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Instead of modifying data in place, create a new DataFrame: df = df.dropna() 💡𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐢𝐬 𝐛𝐞𝐭𝐭𝐞𝐫: • Keeps original data safe • Easier to track changes • Improves code readability 𝐂𝐨𝐧𝐯𝐞𝐧𝐢𝐞𝐧𝐜𝐞 𝐢𝐬 𝐠𝐨𝐨𝐝, 𝐛𝐮𝐭 𝐝𝐚𝐭𝐚 𝐬𝐚𝐟𝐞𝐭𝐲 𝐢𝐬 𝐛𝐞𝐭𝐭𝐞𝐫. 🔥 #Python #Pandas #DataAnalytics #DataAnalyst #Learning

🚀 Day 344 of solving 365 medium questions on LeetCode! 🔥 Today’s challenge: “89. Gray Code” ✅ Problem: You are given an integer n. Your goal is to generate an n-bit Gray code sequence, which is an array of 2^n integers where every adjacent pair of numbers (including the first and last numbers) differs by exactly one single bit in their binary representation. ✅ Approach (Bit Manipulation / The Formula) You could solve this using backtracking or mirroring, but there is a mathematical cheat code that solves it instantly! Find the Size: First, we need to know exactly how many numbers to generate. For an n-bit sequence, there are exactly 2^n numbers. I used a bitwise left shift (1 << n) to calculate this size instantly. The Magic Formula: The i-th number in a standard Gray code sequence can always be found using the exact formula: i ^ (i >> 1). This takes the number, shifts its bits to the right by one, and applies a bitwise XOR against the original number. List Comprehension: I packed this entire logic into a single Python list comprehension that loops from 0 up to our calculated size. It applies the magic formula to every index i, generating the perfect sequence in one go! ✅ Key Insight Bitwise operations are essentially black magic when you know the right formulas. Recognizing that Gray code has a direct integer-to-sequence mapping completely eliminates the need for messy recursive state-tracking. What looks like a complex combinatorial sequence problem is actually just a one-line math trick! ✅ Complexity Time: O(2^n) — We must iterate to generate exactly 2^n elements for the sequence. Space: O(1) — Excluding the space required for the output array, the mathematical generation uses strictly constant auxiliary memory. 🔍 Python solution attached! 🔥 Flexing my coding skills until recruiters notice! #LeetCode365 #BitManipulation #Math #Python #ProblemSolving #DSA #Coding #SoftwareEngineering

📅 Date: April 25, 2026 Day 4 of my LeetCode Journey 🚀 ✅ Problem Solved: 9. Palindrome Number 🧠 Approach & Smart Solution: While it's easy to solve this by converting the integer to a string and reversing it, that takes extra memory! I opted for a highly optimized mathematical approach. I reversed the integer by peeling off its digits one by one using modulo and division, keeping the space complexity to an absolute minimum. • Pseudo-code: Handle edge cases: If the number is less than 0, it can't be a palindrome, so return false. Store the original number in a temporary variable for final comparison. Initialize a 'reverse' variable to 0. Loop while the number is greater than 0: Extract the last digit: digit = x % 10. Add it to the reversed number: reverse = (reverse * 10) + digit. Remove the last digit from the original number: x = x / 10. Finally, return true if the original number matches the reversed number. This math-based solution avoids expensive string conversions and runs instantly! ⏱️ Time Complexity: O(log₁₀(n)) (We only iterate through the digits of the number) 📦 Space Complexity: O(1) (Only using a few integer variables) 📊 Progress Update: • Streak: 3 Days 🔥 • Difficulty: Easy • Pattern: Math / Digit Extraction 🔗 LeetCode Profile: https://lnkd.in/gBcDQwtb (@Hari312004) Choosing mathematical operations over string manipulations is a great way to optimize basic algorithms! 💡 #LeetCode #DSA #Math #Java #CodingJourney #ProblemSolving #InterviewPrep #Consistency #BackendDevelopment

Some problems are not about moving elements, but about understanding structure. Day 22/100 — Data Structures & Algorithms Journey Today’s Problem: Rotate List This problem helped me understand how linked lists behave when we manipulate their structure efficiently. Approach: Instead of rotating the list step by step (which is inefficient), I first calculated the length of the list. Then, I connected the tail to the head to form a circular linked list. By finding the correct breaking point using k % length, I was able to determine the new head and tail of the rotated list. At each step: Convert list into a circular structure Find the new tail position Break the circle to form the rotated list Key Takeaways: Understanding structure is more important than brute force Modulo operation helps avoid unnecessary rotations Linked list problems often become easier when visualized as cycles Efficient thinking leads to cleaner and faster solutions This problem strengthened my understanding of linked list manipulation and optimization techniques. #DSA #LeetCode #LinkedList #ProblemSolving #SoftwareEngineering #CodingJourney #100DaysOfCode #TechLearning #DeveloperJourney #Programming #Python #InterviewPreparation #CodingSkills #ComputerScience #FutureEngineer #TechCareers #SoftwareDeveloper #LearnInPublic #OpenToWork

Day 11/30 🔹 Problem: Build a calculator using functions 🔹 What I focused on today: Breaking a problem into small reusable functions and controlling flow using a menu 🔹 My Thinking Process: Create separate functions for each operation (add, subtract, multiply, divide) Show a menu to the user Take user choice Call the corresponding function 👉 Functions + menu = clean and organized program 🔹 Inputs I used: Two numbers Operation choice 🔹 Code: def add(a, b): return a + b def subtract(a, b): return a - b def multiply(a, b): return a * b def divide(a, b): if b == 0: return "Cannot divide by zero" return a / b print("1. Add") print("2. Subtract") print("3. Multiply") print("4. Divide") choice = input("Enter your choice: ") num1 = float(input("Enter first number: ")) num2 = float(input("Enter second number: ")) if choice == "1": print("Result:", add(num1, num2)) elif choice == "2": print("Result:", subtract(num1, num2)) elif choice == "3": print("Result:", multiply(num1, num2)) elif choice == "4": print("Result:", divide(num1, num2)) else: print("Invalid choice") 🔹 Example: Choice = 1, Numbers = 10 and 5 Output → 15 🔹 Key Takeaway: Using functions makes code modular, reusable, and easier to manage, especially when multiple operations are involved #Day11 #Python #30DaysOfCode #LearningInPublic #DataAnalytics #ProblemSolving

🚀 Solved another classic problem on LeetCode: Plus One Today I worked on a fundamental yet important problem that tests edge case handling and array manipulation skills. 🔹 Problem: Given an integer represented as an array of digits, increment it by one. 🔹 Key Insight: Handle carry propagation efficiently, especially when digits contain 9s. 💡 Approach: Traverse the array from the end Handle carry when digit is 9 Return early when no carry is needed Edge case: all digits are 9 → result becomes [1,0,0,...] ✅ Result: ✔️ All test cases passed (114/114) ⚡ Runtime: 3 ms 📊 Memory: 12.35 MB This problem reinforced the importance of: Thinking about edge cases Writing clean, efficient code Avoiding unnecessary conversions Consistency in problem-solving is key to mastering Data Structures & Algorithms 💪 #LeetCode #DSA #Python #Coding #SoftwareEngineering #AIEngineer #ProblemSolving #100DaysOfCode link of #Solution :- https://lnkd.in/g5F-xAAB

STOP THE "STORAGE BOX" LIE! 📦🚫 Your Python variables aren't physical boxes; they are frantic goblins holding onto memory tethers. It’s time to see the strings and stop the bugs before you smash another digital potion! 🧵👹. Ever change one variable and accidentally break an entirely different function?. Your code isn’t haunted, it’s just a tug-of-war between reference tethers!. We just dropped "The Alchemist’s Memory" masterclass on YouTube to help you visually decode: • The Assignment Tether: How goblins link names to data chests. • Logic Scissors: How to properly "snip" references without crashing your system. • The Spectral Hand: How the Garbage Collector sweeps away "abandoned" data. 🔥 Watch the 60-second cinematic breakdown here: https://lnkd.in/d8Jr_NgX Don't just write code, master the architecture. Download the accompanying Code Codex & Chronicles worksheet and start snipping those tethers like a pro! ✂️📜. Keep Building, The Nazli Tech School Team 🎓💻