Strictly Palindromic Number LeetCode Solution

Day 85 / 100 – 100 Days of LeetCode Challenge 🚀 Problem: Alternating Digit Sum (LeetCode #2544) Today I solved the Alternating Digit Sum problem. The task is to calculate the alternating sum of the digits of a number, where digits in odd positions are added and digits in even positions are subtracted. Approach I extracted each digit of the number from left to right and alternated between addition and subtraction using a sign variable. This allowed me to compute the result efficiently without storing extra data structures. Steps followed: • Convert the number into digits • Initialize a sign variable starting with positive • Add or subtract digits based on the current sign • Flip the sign after processing each digit • Return the final alternating sum This approach keeps the logic simple and efficient using basic arithmetic operations. Complexity Time Complexity: O(d) (where d is the number of digits) Space Complexity: O(1) Result ✔ Accepted ⚡ Efficient runtime 🧠 Simple arithmetic logic A good problem to strengthen understanding of number manipulation and digit processing techniques. #100DaysOfCode #100DaysLeetCodeChallenge #LeetCode #DSA #CPlusPlus #ProblemSolving #Math #Numbers

LeetCode Daily | Day 72 🔥 LeetCode POTD – 3653. XOR After Range Multiplication Queries I (Medium) ✨ 📌 Problem Insight Given an array and queries: ✔ Each query updates indices in a range [l, r] ✔ Jump pattern using step k (i.e., l, l+k, l+2k...) ✔ Multiply elements by v under modulo ✔ Finally compute XOR of entire array 🔍 Initial Thinking – Direct Simulation ✅ 💡 Idea: ✔ For each query, iterate from l → r with step k ✔ Apply multiplication ✔ After all queries, compute XOR ⏱ Works because: ✔ Constraints are small (n, q ≤ 1000) ✔ Even worst case passes comfortably ⚠️ Common Pitfall ❌ 💡 Mistake: ✔ Misreading query format [l, r, k, v] ✔ Using wrong index for v 💡 Important Fix: ✔ Always use v = query[3] ✔ Use 1LL * a * b to avoid overflow 💡 Key Observation 🔥 ✔ This looks complex due to jumps (k) ✔ But no overlapping pattern optimization needed ✔ Pure simulation + careful coding is enough ⏱ Complexity: ✔ Time: O(q * n) ✔ Space: O(1) 🧠 Key Learning ✔ Not every problem needs optimization ✔ Read queries carefully (indexing matters!) ✔ Handle overflow using long long ✔ Simulation problems test implementation skills 🚀 Takeaway A clean simulation problem where correctness > complexity — perfect for building attention to detail ⚡ #LeetCode #DSA #Algorithms #CPlusPlus #ProblemSolving #CodingJourney #DataStructures

Day 4 of #100DaysOfCode Solved: Rotate Function (LeetCode 396) Approach 1: Brute Force Rotate array each time → O(n) Recalculate F(k) → O(n) Total: O(n²) (Too slow) Approach 2: Optimized (Using Relation) Instead of recomputing, reuse the previous value: Each rotation shifts elements by +1 index Last element moves to index 0 Use relation to compute next value in O(1) Total: O(n) Key Intuition: When array rotates: Every element’s contribution increases by its value But we subtract n × last element to adjust Takeaway: Whenever a problem involves repeated recomputation after shifts/rotations look for a mathematical relation #LeetCode #DSA #CodingInterview #ProblemSolving #100DaysOfCode

Today I tackled the "Total Step Count" problem. While the logic seems simple—you can take 1 step or 2 steps at a time—implementing it through recursion really tests your understanding of base cases and the call stack. I've shared two snippets in my screenshot: The first tracks paths using a global variable. The second uses a more concise recursive return. It’s not just about getting the right answer; it’s about understanding the flow of the data. Every bug fixed is a lesson learned! #LearningToCode #PythonProgramming #DSA #ProgrammingLife #StudentDeveloper

📅 Day 279 – Digit Counting & Mathematical Observation (Apr 12, 2026) 🔢📊 🔹 Problems Solved Today: 1️⃣ LeetCode 3895 – Count Digit Appearances 🔢 • Counted occurrences of digits across numbers efficiently. • Avoided brute force by using mathematical patterns. • Broke numbers into place values (units, tens, etc.). • Calculated contribution of each digit position. • Optimized counting using digit-based logic. 💡 Key Takeaways from Day 279: • Digit problems often rely on place value analysis. • Mathematical observation can replace brute force iteration. • Breaking problems into smaller numeric patterns simplifies logic. 🔥 Consistency Update: ✅ Day 279 streak maintained. 🎯 1016 problems solved so far. #LeetCode #DSA #ProblemSolving #Math #DigitDP #Consistency #Day279 🚀

🚀 Solved “Mirror Distance of an Integer” – A Simple Yet Insightful Problem -- Today I worked on a problem that looks simple at first glance but highlights the importance of number manipulation and logic building. -- Problem Statement: Given an integer n, find the mirror distance, defined as the absolute difference between the number and its reversed form. -- Approach: - Reverse the integer using digit extraction (n % 10), Build the reversed number step by step, Compute the absolute difference. -- Key Learnings: - How to reverse integers efficiently - Importance of digit manipulation - Writing clean helper functions (getReverse) - Keeping logic modular and readable #DSA #ProblemSolving #CPlusPlus #CodingJourney #LeetCode #SoftwareEngineering #Algorithm

LeetCode Daily | Day 78 🔥 LeetCode POTD – 3488. Closest Equal Element Queries (Medium) ✨ 📌 Problem Insight Given a circular array: ✔ For each query index, find nearest same value ✔ Distance is circular ✔ Return minimum distance ✔ If no same value exists → return -1 🔍 Initial Thinking – Brute Force ⚙️ 💡 Idea: ✔ For each query, scan entire array ✔ Check all indices with same value ⚠️ Problem: ✔ O(n) per query → too slow ✔ Total becomes O(n²) in worst case 💡 Key Observation 🔥 ✔ Same values repeat → group their indices ✔ Nearest answer lies among adjacent indices in that group ✔ Circular distance: → min(|i - j|, n - |i - j|) 🚀 Optimized Approach ✔ Store indices for each value (hash map) ✔ For each query: → Use binary search to find position → Check nearest left & right indices ✔ Handle circular wrap using modulo 🔧 Core Idea ✔ Reduce search space using grouping ✔ Use binary search for nearest neighbors ✔ Apply circular distance formula ⏱ Complexity ✔ Time: O(n + q log n) ✔ Space: O(n) 🧠 Key Learning ✔ Nearest element problems → check neighbors, not all ✔ Preprocessing (grouping) can drastically optimize queries ✔ Circular arrays often need wrap-around handling 🚀 Takeaway A great mix of hashing + binary search + circular logic — classic interview pattern to reduce brute force into efficient queries ⚡ #LeetCode #DSA #Algorithms #CPlusPlus #ProblemSolving #CodingJourney

Day 16/30 – LeetCode Challenge YouTube : https://lnkd.in/gzVSCZ9Z I tried to explain the problem and its solution—would love to hear your feedback Today’s problem: 2515. Shortest Distance to Target String in a Circular Array Problem Overview • Given a circular array of strings • You can move left or right (1 step at a time) • Find the shortest distance from startIndex to any index where value = target • If target not found, return -1 Approach • Traverse the array once • For every index where words[i] == target: – Compute forward distance → abs(i - startIndex) – Compute circular distance → n - abs(i - startIndex) • Take the minimum of both distances • Keep track of the global minimum answer Complexity • Time Complexity: O(n) • Space Complexity: O(1) Key Learning • Circular array problems often need two directions (forward + wrap-around) • Always compare normal distance vs circular distance • Simple traversal + math can avoid complex logic #LeetCode #Day16 #CodingChallenge #DSA #CPP #ProblemSolving

🚀 Day 37 of Consistency | #75DaysLeetCodeChallenge 🧠 Today’s Problem: Subtree of Another Tree (#572) 💡 Key Learning: This problem deepens understanding of tree comparison + recursion, combining subtree traversal with structural validation. ⚡ Approach: Use recursion (DFS) Traverse each node of root At each node, check if trees are identical If not, recursively check left & right 🧠 Why this works: Checks every possible subtree Uses same-tree logic to validate structure & values 🔥 Result: ✔️ Runtime: 35 ms (Beats 86.67%) ⚡ Time Complexity: O(n * m) ⚡ Space Complexity: O(n) (recursion stack) 📈 A great problem that combines traversal and comparison—very useful for mastering tree-based questions. A big thanks to Shivam Singh, Nikhil Yadav & Akshat Tiwari for this amazing challenge 🙌 Consistency is compounding. Keep going. 💪 #Day37 #LeetCode #DSA #CodingJourney #BinaryTree #Recursion #DFS #100DaysOfCode

🚀 Solved a challenging Binary Tree problem – FindElements (Recover Contaminated Tree) on LeetCode! Today I worked on an interesting problem where an entire binary tree was “contaminated” (all values set to -1), and the goal was to reconstruct the original tree structure using given rules and efficiently support search queries. 🔍 Key Learnings & Approach: Recovered the tree using DFS by applying: Left child → 2*x + 1 Right child → 2*x + 2 Designed a recursive solution to restore values starting from root = 0 Implemented a traversal-based search to verify whether a target exists in the tree ⚡ Performance: ✅ All test cases passed (34/34) ⏱ Runtime: 304 ms 💾 Memory Usage: Optimized (better than ~91% submissions) 💡 What made it interesting? This problem is a great example of: Tree reconstruction logic DFS traversal usage Understanding implicit tree properties 📌 Next Improvement Plan: Planning to optimize the find() operation from O(n) to O(1) using hashing (unordered_set) for faster lookups. Consistency in solving DSA problems is really paying off. On to the next challenge! 💪 #DataStructures #Algorithms #BinaryTree #LeetCode #CodingJourney #Cplusplus #DSA #ProblemSolving