Reversing Integer in Java: Handling Overflow and Edge Cases

🚀 Day 29 of 100 Days of LeetCode 📘 Problem: Combination Sum 💻 Language: Java ✅ Status: Accepted — Runtime ⚡ 2 ms (Beats 86%) Today’s problem was all about backtracking — exploring all possible combinations to reach a target sum. It’s a perfect blend of recursion, decision-making, and pruning unnecessary paths 🧠 ✨ Key Learnings: Backtracking is like exploring a maze — try, backtrack, and try again until you find the exit 🌀 Each recursive call represents a “choice point” — include or skip the element Clean recursion with controlled base cases leads to clarity and precision This problem reminded me how persistence works in both code and life: 💬 “Sometimes, the path to the solution is not straightforward — you just need to keep exploring.” #Day29 #100DaysOfCode #LeetCode #Java #Backtracking #Recursion #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #KeepLearning #CodeEveryday

🚀Day 96/100 #100DaysOfLeetCode 🧩Problem: Reverse Linked List II✅ 💻Language: Java 💡 Approach: 1️⃣ First, use a dummy node to handle edge cases where reversal starts at the head. 2️⃣ Traverse to the node just before the left position — call it prev. 3️⃣ Reverse the sublist between left and right using standard pointer manipulation. 4️⃣ Reconnect the reversed portion back into the original list. 🔑Key Takeaways: 🔹Dummy nodes simplify linked list edge cases. 🔹In-place reversal reduces memory overhead. 🔹Careful pointer tracking ensures list integrity. ⚙️Performance: ⏱️Runtime: 0 ms(beats 100.00%) 💾Memory: 41.29 MB(beats 70.37%) #100DaysOfLeetCode #Java #LinkedList #CodingJourney #ProblemSolving #DSA #LeetCode #CodingChallenge

Day 20 of #50DaysOfCode – Java Today’s task: Find the sum of all odd digits in a given number! 🔢 A simple yet logical exercise that helps strengthen your understanding of loops, conditionals, and digit manipulation. 💡 👉 This program takes a number as input and calculates the total of its odd digits using a while loop and the modulus operator. #Java #CodingChallenge #50DaysOfCode #LearnToCode #ProgrammingBasics #LogicBuilding #CodeEveryday #JavaProgramming

🚀 Method Overloading (Java) Method overloading is a feature in Java that allows a class to have multiple methods with the same name but different parameter lists (different number, types, or order of parameters). The compiler determines which method to call based on the arguments passed to the method. Method overloading enhances code readability and provides flexibility in how methods are called. It allows you to perform similar operations with varying inputs. 🌟 Read. Learn. Grow. Repeat. 🔄 📚 Everything you need to master tech — 10,000+ concepts, 4,000+ articles, 12,000+ quizzes. Personalized for you! 👇 Links available in the comments! #Java #JavaDev #OOP #Backend #professional #career #development

🚀Day 99/100 #100DaysOfLeetCode 🔍Problem: Sum of Two Integers✅ 💻Language: Java 💡Approach: Instead of using the ‘+’ or ‘–’ operators, this problem leverages bit manipulation to perform addition. 🔸Use XOR (^) to calculate the sum without carry. 🔸Use AND (&) followed by a left shift (<< 1) to calculate the carry. 🔸Repeat until no carry remains. 📚Key Takeaways: 🔹Reinforced understanding of bitwise operations. 🔹Learned how addition can be simulated using logical operations. 🔹Improved understanding of low-level arithmetic computation. ⚡Performance: ⏱️Runtime: 0 ms (Beats 100.00%) 💾Memory: 40.88 MB (Beats 10.05%) #100DaysOfLeetCode #Java #BitManipulation #CodingChallenge #ProblemSolving #DSA #LeetCode #CodingJourney

🌟 Day 86 of #100DaysOfCodingChallenge 🌟 🚀 Problem: 561. Array Partition 💻 Language: Java Today’s challenge was about maximizing the sum of the minimum values in n pairs formed from an array of 2n integers. 🧩 Approach: 1️⃣ Sort the array in ascending order. 2️⃣ Take every alternate element (starting from index 0). 3️⃣ Add them up — this gives the maximum possible sum of mins in all pairs. 🧠 Key Insight: When the array is sorted, pairing adjacent elements ensures the smallest numbers are always matched optimally, leading to the maximum possible result. 📊 Example: Input → [1,4,3,2] Sorted → [1,2,3,4] Pairs → (1,2), (3,4) Output → 4 ✅ ✨ Learning: Sometimes the simplest approach — sorting and selecting — can yield the most optimal result! #Day86 #LeetCode #Java #100DaysOfCode #CodingChallenge #ProblemSolving #ArrayPartition #DSA #WomenInTech #SathyabamaUniversity

🌟 Java Insight: @IntrinsicCandidate Annotation Just discovered @IntrinsicCandidate in Java! It’s a special tag in the code that tells the JVM, “This method could be supercharged for speed.” If the JVM agrees, it swaps in a highly optimized version behind the scenes—no extra work needed from us. Think of it like giving the JVM permission to use a power tool instead of a regular one for certain jobs, making things run faster and smoother. You’ll find this in core methods like Math, String, and Array operations—places where speed really matters. It’s internal magic that helps Java stay both easy to use and lightning fast! #Java #Performance #JVM

#Day-68) LeetCode #3228 – Maximum Number of Operations to Move Ones to the End (Java Edition) Tackled this neat string problem using a greedy approach in Java. The challenge? Move '1's to the end of the string under specific movement rules, maximizing the number of valid operations. 🧠 Core Idea: Track how many '0's we've seen and how many '1's we've already moved. Only move a '1' if there's enough '0's to justify it and the next character is also '1'. 💻 Java Strategy: Loop through the string Use counters to manage '0's and '1's Let me know how you'd tweak this or if you see a more optimal path! #Java #LeetCode #GreedyAlgorithm #StringProblems #DSA #CodingChallenge #LinkedInTech #ProblemSolving

💡 Today I learned about Prime Factorization in Java! Prime Factorization means breaking a number into its prime factors — the building blocks of the number. 🧩 Basic Approach: int i = 2; while (n > 1) { while (n % i == 0) { System.out.println(i); n = n / i; } i++; } ⏱️ Time Complexity: O(n) ⚙️ Optimized Approach: int i = 2; while (i * i <= n) { while (n % i == 0) { System.out.println(i); n = n / i; } i++; } if (n > 1) System.out.println(n); ⏱️ Time Complexity: O(√n) ✅ Key Takeaway: Checking factors only up to √n makes the algorithm much faster — no need to go till n. Small change, big improvement in performance! #Java #DSA #LearningJourney #Coding #Algorithms #Optimization