LeetCode 179: Largest Number with Custom Comparator

Today's topic: recursion. A function that calls itself. Sounds simple, right? Here are two ways to add up a list of numbers: Without recursion — honest, reliable, easy to follow: python def suma(lista): suma = 0 for i in range(0, len(lista)): suma = suma + lista[i] return suma print(suma([6,3,4,2,10])) # 25 With recursion — elegant, almost poetic... and a little terrifying: python def suma(lista): if len(lista) == 1: return lista[0] else: return lista[0] + suma(lista[1:]) print(suma([6,3,4,2,10])) # 25 Same result. Two completely different roads to get there. The recursive version looks more "pro" — but if you forget to define when it stops, the function calls itself forever. Literally. Forever. 💀 So yes, it's getting challenging. And yes, recursion feels more elegant to write. But I'm not ready to fully trust something that could loop into oblivion if I blink wrong. Lesson of the day: simple is not the same as bad. And documenting the moments that confuse you? That's part of learning too. #Python #LearningToCode #DaysOfCode #PythonProgramming #CodingJourney #Recursion #BeginnerCoder #TechLearning #CodeNewbie #LinkedInLearning

Day 6 of my Python learning journey: Focusing on writing code that's not just functional, but also dependable. Highlights from today: - Warmed up by practicing iterators and generators. - Solved the "First Non-Repeating Character" problem using a clean two-pass frequency approach with O(n) complexity. - Merged two sorted arrays efficiently through the two-pointer technique (O(n + m))—avoiding any redundant sorting. - Developed a FastAPI endpoint for the above problem, complete with schema validation. Observations: Initially, I attempted a one-pass solution for the non-repeating character problem, but it ended up feeling convoluted. Switching to a two-pass strategy made the solution much more straightforward and maintainable. Current focus areas: - Maintaining input order integrity. - Performing input validation early on. - Keeping logic as simple as possible. - Thoroughly testing edge cases beforehand. Major takeaway: Define inputs/outputs upfront → validate data early → then prioritize optimization. Starting to grasp how even minor design decisions can significantly impact code quality. GitHub link: https://lnkd.in/gGPw8_js #Python #FastAPI #ProblemSolving #SoftwareEngineering #CleanCode #LearningInPublic #OOP #Testing

𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗹𝗲𝘀𝘀𝗼𝗻𝘀, 𝘂𝗻𝗳𝗶𝗹𝘁𝗲𝗿𝗲𝗱 I added logging to my Python app and thought I was done. Two lessons later — I wasn't even started. 𝗟𝗲𝘀𝘀𝗼𝗻 𝟭 : 𝘆𝗼𝘂𝗿 𝗹𝗼𝗴 𝗳𝗶𝗹𝗲 𝗶𝘀 𝗮 𝘁𝗶𝗰𝗸𝗶𝗻𝗴 𝗯𝗼𝗺𝗯 No size limit. No rotation. No cleanup. It just grows. Forever. Dev - fine. Production - it silently eats your disk until your app is down at 2AM. One swap in Python's standard library fixes this. Max size. Backup count. Auto-rotates. Auto-deletes oldest. That's it. 𝗟𝗲𝘀𝘀𝗼𝗻 𝟮 : 𝘆𝗼𝘂𝗿 𝗹𝗼𝗴𝘀 𝗮𝗿𝗲 𝘂𝗻𝗿𝗲𝗮𝗱𝗮𝗯𝗹𝗲 𝗮𝘁 𝘀𝗰𝗮𝗹𝗲 🔍 Human-readable text is perfect for dev. In production with thousands of requests ⁉️ Useless. Switch to JSON logs. Every line becomes a structured event : timestamp, level, request_id, user_id. Want all errors from one specific request? One query. Done. No regex. No grepping through walls of text. The difference between logging and logging for production is bigger than I thought. That gap - that's what this series is about #Python #Backend #LearnInPublic #SoftwareEngineering

🚀 Day 13/30 of My LeetCode Journey (Python + SQL) Showing up every day and pushing my limits a little more! 💻🔥 🔹 SQL Problem of the Day 👉 Customer with Most Orders Given an Orders table, write a query to find the customer_number who has placed the highest number of orders. 💡 Key Concept: GROUP BY + COUNT() with ordering/aggregation to find maximum. 🔹 Python Problem of the Day 👉 Subarray Sum Equals K Given an array and an integer k, return the total number of subarrays whose sum equals k. 💡 Key Concept: Prefix Sum + HashMap for optimizing from O(n²) → O(n). Learning how to optimize brute force solutions into efficient ones is a big win ⚡ Day 13 done ✅ #LeetCode #30DaysChallenge #Python #SQL #CodingJourney #Consistency #ProblemSolving #PrefixSum #Learning

This week I didn't just write code. I understood what's happening inside it. Here's a recursive function I built 👇 It calculates hotel earnings for N days at ₹5000/day — no loops allowed, only recursion. Watch how Python actually executes it step by step 🎥 What I covered this week: → 🔁 Recursion — functions calling themselves → 📁 File I/O — reading & writing files with Python → 🌐 Internet fundamentals — TCP/IP, HTTP, DNS, REST APIs (Phase 4 done!) Still learning. Still showing up. That's the only formula I know. 💪 💻 Visualization tool: staying.fun 🐍 Language: Python #Python #LearningInPublic #DataAnalytics #Recursion #BBA #100DaysOfCode

Technical post: I've been posting some graphs on here, talking about functions and "equivalence". This was all started by working on porting an MLOPs framework from python 3.10 to 3.12, and all the "dependency hell" one has to go through. Then naturally the question arose "What are the boundaries of one project to another, in terms of functions being called etc.,?" This led me down the rabbit hole (not too deep) of what happens when I do something like python -m <module> <somescript>. Specifically, what is a "no op" module, and what kind of ops can we inject, thanks to python being an interpreted language. A few years ago I'd worked on something along similar lines called TracePath, which provided a decorator to do something similar (e.g. who called who, how long it took, etc.). So I merged these two ideas (avoid decorating every function, have an "inspector" module) and ran this on a simple pandas dataframe creation. The resulting function invocation graph is the image attached to this post. When I ran it across the whole workflow (create, load, transform data etc.,), the graph had ~9000 connections. The nice thing is I can specify which modules (e.g. only pandas, or pandas and numpy) should be added to the graph etc. What do you think is the next logical thing to do with something like this? What kind of graphs would well structured software produce? How about badly written software? #graphs #swe #dependencyhell #python

Day 18: Scope and Precision — The Limits of Logic 🌐 As your programs grow, you'll start having variables with the same names in different places. How does Python know which one to use? And when doing math, how many decimals can Python actually "remember"? 1. Local vs. Global Scope Think of Scope as the "area of visibility" for a variable. Global Scope: Variables defined at the top level (outside any function). They can be read from anywhere in your script. Local Scope: Variables defined inside a function. They only exist while that function is running. Once the function ends, the variable is deleted. 💡 The Engineering Lens: Avoid using too many Global variables. If every function can change a variable, it becomes a nightmare to track down bugs. Keep data "Local" whenever possible! 2. The LEGB Rule: Python’s Search Engine When you call a variable name, Python searches in a very specific order to find it. This is the LEGB rule: Local: Inside the current function. Enclosing: Inside any nested "parent" functions. Global: At the top level of the file. Built-in: Python’s pre-installed names (like len or print). 3. Precision: The Decimal Limit When you use a Float (a decimal number), Python has to fit that number into a fixed amount of memory. Maximum Precision: Python floats are typically "double-precision" (64-bit). This means they can hold about 15 to 17 significant decimal digits. The Default: When you perform a calculation, Python will show as many decimals as are relevant, but it stops being accurate after that 15–17 digit mark. 💡 The Engineering Lens: Because of this limit, 0.1 + 0.2 often equals 0.30000000000000004. If you are building a banking app or a scientific tool where you need infinite precision, don't use floats! Use Python’s decimal module instead. #Python #SoftwareEngineering #CleanCode #ProgrammingTips #DataPrecision #LearnToCode #TechCommunity #PythonDev

Day 40 of my #100DaysOfCode challenge 🚀 Today I implemented the Merge Sort algorithm in Python. Merge Sort is a powerful divide-and-conquer algorithm that divides the list into smaller parts, sorts them, and then merges them back together. What the program does: • Takes an unsorted list as input • Recursively divides the list into halves • Sorts each half separately • Merges the sorted halves into a final sorted list How the logic works: • If the list has 1 or 0 elements, it is already sorted (base case) • The list is divided into two halves using the middle index • Each half is recursively sorted using merge_sort() • A helper function merge() combines the two sorted halves • Elements are compared and merged in sorted order • Remaining elements are appended after comparison Example: Input: [38, 27, 43, 3, 9, 82, 10] Output: [3, 9, 10, 27, 38, 43, 82] Why Merge Sort is powerful: – Time Complexity: O(n log n) – Efficient for large datasets – Stable sorting algorithm – Widely used in real-world applications Key learnings from Day 40: – Understanding divide-and-conquer strategy – Writing recursive functions – Merging sorted arrays efficiently – Moving towards advanced DSA concepts #100DaysOfCode #Day40 #Python #PythonProgramming #MergeSort #SortingAlgorithms #DataStructures #Algorithms #DivideAndConquer #ProblemSolving #CodingPractice #InterviewPrep #BTech #CSE #AIandML #VITBhopal #TechJourney

🚀 Day 12/30 of My LeetCode Journey (Python + SQL) Consistency continues… and the concepts are getting sharper! 💻🔥 🔹 **SQL Problem of the Day** 👉 *Invalid Tweets* Given a `Tweets` table, write a query to find tweet IDs where the content length is strictly greater than 15 characters. 💡 *Key Concept:* String functions like `LENGTH()` for validation. 🔹 **Python Problem of the Day** 👉 *Single Number* Given an array where every element appears twice except one, find that single element. 💡 *Key Concept:* Bit manipulation using XOR for optimal O(n) time and O(1) space. Loving how problem-solving is becoming more intuitive day by day ⚡ Day 12 done ✅ #LeetCode #30DaysChallenge #Python #SQL #CodingJourney #Consistency #ProblemSolving #Learning #BitManipulation