Srikanth Doddi’s Post

⚙️ Day 72 of #100DaysOfCode ⚙️ 💡 Problem: GCD of Odd and Even Sums – LeetCode ✨ Approach: Calculated the sum of the first n odd and even numbers separately, then determined their GCD through iterative checking. A neat blend of arithmetic patterns and number theory logic! 🔢 📊 Complexity Analysis: Time Complexity: O(n)** — summing and iterating up to the limit Space Complexity: O(1)** — constant auxiliary space ✅ Runtime: 575 ms ✅ Memory: 42.79 MB 🔑 Key Insight: Even the simplest mathematical patterns can reveal deep logic — coding is where math meets creativity! ✨ #LeetCode #100DaysOfCode #ProblemSolving #DSA #NumberTheory #LogicBuilding #AlgorithmDesign #ProgrammingChallenge #Efficiency #CodeJourney #DeveloperGrowth #CodingDaily

🎯 LeetCode Daily – Integer Break (Day 127) Today’s problem was an excellent Dynamic Programming + Math Optimization challenge - Integer Break. ✅ My Approach: 🔹 Problem – Integer Break: • The goal was to break a given integer n into at least two positive integers such that their product is maximized. • Implemented Memoization (Top-Down DP) to recursively explore all possible partitions of n and stored results in a dp[] array to avoid recomputation. • For each split i, compared both possibilities - breaking further (i * helper(n - i)) and not breaking (i * (n - i)), ensuring the best product was selected. 🧠 Key Insight: This problem elegantly demonstrates how Dynamic Programming enhances mathematical intuition. Instead of checking every partition brute-force, the recursive structure ensures we compute only what’s necessary - turning an exponential problem into a polynomial-time one. It’s also a great reminder of how recursion + memoization simplifies seemingly complex combinatorial optimization problems. 📊 Time Complexity: O(N²) 📦 Space Complexity: O(N) #LeetCode #DSA #DynamicProgramming #MathOptimization #ProblemSolving #DailyCoding #LearningInPublic #Day127

🚀 Day 67 | Math & Dynamic Programming Insights Today’s challenge was all about maximizing product through intelligent partitioning — a perfect mix of mathematical intuition and dynamic programming. 🧩 Problem Solved: 343. Integer Break • Approach: Used dynamic programming to compute the maximum product by breaking n into smaller integers, or derived the math-based insight that splitting into 3s gives the optimal product. • Insight: Not every optimization needs brute force — sometimes, number patterns reveal the most efficient path. ✨ Key Takeaway: Mathematics and programming go hand in hand — understanding the underlying formula often leads to cleaner and faster solutions. 📚 Topics: Math · Dynamic Programming · Optimization 💻 Platform: LeetCode #DSA #LeetCode #ProblemSolving #DailyCoding #DynamicProgramming #Math #Consistency

🚀 Day 65 | Math Patterns & Pascal’s Logic Today’s problem revisited one of the most elegant mathematical structures — Pascal’s Triangle — focusing on generating a specific row efficiently. 🧩 Problem Solved: 119. Pascal’s Triangle II • Approach: Built the row iteratively using the relationship row[i] = row[i-1] * (n - i + 1) / i, avoiding full triangle generation. • Insight: Recognizing combinatorial patterns transforms nested loops into simple mathematical formulas. ✨ Key Takeaway: Efficiency often comes from understanding the math beneath the pattern — logic over loops. 📚 Topics: Math · Dynamic Programming · Combinatorics 💻 Platform: LeetCode #DSA #LeetCode #ProblemSolving #DailyCoding #Math #DynamicProgramming #Consistency

🚀 Algorithm Books Every Programmer Should Know 🚀 If you want to master algorithms and data structures, these are my essential recommendations. 1️⃣ “Introduction to Algorithms” by Cormen, Leiserson, Rivest & Stein The gold standard in academia. Over 1,000 pages of rigorous theory with detailed pseudocode. Dense but comprehensive. 2️⃣ “Grokking Algorithms” by Aditya Bhargava Perfect for beginners. Visual and intuitive explanations without intimidating math. My favorite for getting started! 3️⃣ “Algorithms” by Robert Sedgewick & Kevin Wayne Comprehensive textbook with Java code. 4️⃣ “The Algorithm Design Manual” by Steven S. Skiena Practical approach with real world examples. Ideal for seeing how algorithms are used in industry. 5️⃣ “The Art of Computer Programming” by Donald Knuth The legendary (and dense) work of the 1974 Turing Award winner. Slow but essential reading. Links in comments!

💻 Day 28 of My DSA Learning Journey : Today’s problems were all about patterns and optimization — one highlighting the beauty of mathematics in programming, and the other demonstrating algorithmic efficiency in arrays. 🔹 Problem 1: Pascal’s Triangle 📘 LeetCode #118 — Pascal’s Triangle 🧩 Problem Brief: Given an integer numRows, generate the first numRows of Pascal’s Triangle — where each number is the sum of the two numbers directly above it. 💡 My Approach: Instead of constructing it row by row using loops, I used the combination method, calculating each element based on its position in the triangle. This approach connects combinatorics with programming and simplifies the logic significantly while maintaining efficiency. 🕒 Time Complexity: O(n²) 💾 Space Complexity: O(1) (excluding output storage) 🔹 Problem 2: Majority Element (n/3 times) 📘 LeetCode #229 — Majority Element II 🧩 Problem Brief: Find all elements in an array that appear more than [ n/3 ] times. 💡 My Approach: I implemented the Extended Boyer-Moore Voting Algorithm, which efficiently tracks up to two potential majority candidates and validates them in a second pass. This method is highly optimized — both in time and space — making it a great example of clever algorithmic design. 🕒 Time Complexity: O(n) 💾 Space Complexity: O(1) 💭 Today’s problems reminded me how mathematics and algorithms go hand in hand — from generating beautiful patterns to crafting optimized logic. Every concept builds a stronger foundation for problem-solving. #100DaysOfCode #LeetCode #DSA #CodingChallenge #PascalTriangle #Combinatorics #BoyerMoore #Algorithms #ProblemSolving #Programming #LearnToCode

💻 Day 5 of #100DaysOfCode 🔹 Problem: Given an array nums containing n distinct numbers in the range [0, n], find and return the only number that is missing from the array. Example: If nums = [3, 0, 1], the range is [0, 3] and the missing number is 2. 🔹 Today’s Focus: ✅ Applying mathematical sum formula → n * (n + 1) / 2 ✅ Finding the missing value using: missing = expectedSum - actualSum ✅ Understanding alternative approaches such as XOR-based solution ✅ Strengthening logical thinking for array and number problems 🔹 Result: ✔ All test cases passed successfully ✔ Improved understanding of math-based and XOR-based problem solving ✔ Another step forward in the 100 days coding journey 🚀 #Day5 #100DaysOfCode #Arrays #Math #BitManipulation #CodingChallenge #DSA #GeeksforGeeks #ProblemSolving #LearnToCode #DeveloperJourney #KRMU #UNIVERSITY

Pragmatic AI Labs just launched our 6th, and most exciting WASM interactive book on the Ruchy Programming language. Ruchy is a NEW language built on top of Rust that is a high-performance scripting language optimized for general purpose programming, Data Science, machine learning and systems administration. Oh...and it compiles to PURE Rust and you can use Rust libraries and Cargo to import and publish packages. Check it out: interactive.paiml.com Take a course from us: paiml.com #rust #llms #mcp #ruchy #paiml

𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐃𝐚𝐢𝐥𝐲 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: 2654. 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐍𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐭𝐨 𝐌𝐚𝐤𝐞 𝐀𝐥𝐥 𝐀𝐫𝐫𝐚𝐲 𝐄𝐥𝐞𝐦𝐞𝐧𝐭𝐬 𝐄𝐪𝐮𝐚𝐥 𝐭𝐨 1. This problem was an excellent application of mathematical reasoning through the Euclidean Algorithm (GCD). It helped me appreciate how fundamental math concepts can simplify complex algorithmic logic and lead to optimized solutions. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: We are given an array of positive integers. In one operation, we can select an index i and replace either nums[i] or nums[i+1] with their GCD value. The task is to find the minimum number of operations required to make all elements equal to 1, or return -1 if it is impossible. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Checked if the array already contains any element equal to 1. If yes, the minimum operations equal the number of elements that are not 1. If not, used a nested loop to find the shortest subarray whose GCD becomes 1 using the Euclidean Algorithm. Once such a subarray is found, it can be made 1 in (subarray length - 1) operations. The total number of operations is calculated as (subarray length - 1) + (n - 1), representing the steps to convert the rest of the array to 1. Added an early break once GCD reaches 1 for better performance. 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 𝐀𝐧𝐚𝐥𝐲𝐬𝐢𝐬: Time Complexity: O(n² * log(max(nums))) Space Complexity: O(1) 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬: Reinforced the use of the Euclidean Algorithm and recursion for GCD calculations. Understood the role of early exits in improving nested loop efficiency. Observed how mathematical insight directly enhances algorithmic problem-solving. This marks my first post in my LeetCode Daily Challenge journey. I plan to continue sharing my learnings and reasoning from each daily challenge to stay consistent and deepen my problem-solving approach. #LeetCode #DSA #Java #ProblemSolving #CodingPractice #LearningEveryday #Consistency #Algorithms #100DaysOfCode

🧩 LeetCode Challenge – Day 85 ✅ Took on an interesting number theory problem today — combining logic, math, and array manipulation. 🔗 LeetCode 2654 – Minimum Number of Operations to Make All Array Elements Equal to 1 This problem revolves around using the GCD (Greatest Common Divisor) operation strategically to transform all elements into 1. It starts with checking if a 1 already exists and, if not, finding the shortest subarray whose GCD equals 1 — a clever mix of mathematical insight and iterative optimization. 💡 Key Takeaways: • GCD logic uncovers mathematical structure within array transformations. • Combining math and iteration often leads to elegant problem-solving paths. • Understanding problem symmetry can turn complex operations into predictable steps. #Day85 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Math #GCD #NumberTheory #Arrays #Optimization