Improved problem-solving skills with LeetCode Java challenges

🔹 Day 39 – LeetCode Practice Problem: Perfect Number (LeetCode #507) 📌 Problem Statement: A perfect number is a positive integer that is equal to the sum of its positive divisors, excluding itself. Return true if the given number is perfect, otherwise return false. ✅ My Approach (Java): Initialize sum = 0. Iterate from 1 to num / 2. For every divisor i such that num % i == 0, add it to sum. After the loop, if sum == num, it’s a perfect number. 📊 Complexity: Time Complexity: O(n/2) Space Complexity: O(1) ⚡ Submission Results: Accepted ✅ Runtime: 2108 ms Memory: 41.19 MB 💡 Reflection: This problem reinforced the importance of divisor-based iteration. While this brute-force solution works, optimizing divisor checks using square roots can greatly improve performance — a good next step for refinement! #LeetCode #ProblemSolving #Java #DSA #CodingPractice #Learning

🚀Day 29/100 - Problem of the day :- Minimum Number of Increments on Subarrays to Form a Target Array. 🎯 Goal: Solve the “Minimum Number of Increments on Subarrays to Form a Target Array” problem efficiently on LeetCode. 💡 Core Idea: The key observation is that we only need to add operations when the current element is greater than the previous one. So, the total operations = target[0] + sum(max(target[i] - target[i-1], 0)). This approach ensures we only count necessary increments, avoiding redundant steps. 🎯 Key Takeaway: By focusing on the difference between consecutive elements, we transform a complex problem into a simple linear pass — achieving both clarity and top performance. ✅ Passed all 129 test cases 🚀 Runtime beats 100% of Java submissions 💾 Space Complexity: O(1) — constant extra space used. ⏱ Time Complexity: O(n) — single pass through the array. #Java #DSA #ProblemSolving #Day29 #Leetcode #CodingJourney #100DaysChallenge

🚀 Day 89 of #100DaysOfLeetCode 🚀 Today’s problem: Plus One ➕ In this problem, the goal is to increment a large integer represented as an array of digits by one. It’s a simple-sounding task but highlights how important it is to handle carry-over logic correctly — especially when the last digits are 9s (e.g., [9,9,9] → [1,0,0,0]). The main challenge was to iterate through the digits from right to left, manage the carry efficiently, and ensure that the solution works for all edge cases without using string conversion. ✅ Key learnings: Array manipulation Handling carry in arithmetic operations Edge case management (all digits being 9) 💻 Language: Java ⚡ Result: Accepted | Runtime: 0ms (Beats 100%) Each problem, no matter how simple it looks, strengthens logical thinking and attention to detail — one step closer to mastering problem-solving! 💪 #LeetCode #100DaysOfCode #ProblemSolving #CodingChallenge #Java #LearningEveryday

💻 LeetCode Problem-Solving Practice (Java) practiced a few problems that helped me deepen my understanding of greedy and counting-based approaches: 🔹 Jump Game II Implemented a greedy solution to determine the minimum number of jumps required to reach the end of the array by dynamically tracking reachable indices. Time Complexity: O(n) 🔹 H-Index Solved using a counting approach to efficiently calculate the research impact score based on citation frequencies. Time Complexity: O(n) Each problem helped reinforce the importance of optimizing both logic clarity and performance in algorithm design. #LeetCode #Java #DSA #ProblemSolving #Algorithms #Coding #SoftwareEngineering

🚀 Day 68 of My #100DaysOfCode Challenge ✅ Problem: Maximum Number of Distinct Elements After Operations (LeetCode #3397) 📘 Language: Java 📈 Difficulty: Medium Today’s challenge was about optimizing distinct elements in an array when you’re allowed to modify each element within a range [-k, k]. 🔍 Approach: Sort the array to handle elements in increasing order. Use a greedy strategy: for each number, pick the smallest possible distinct value within [x - k, x + k] that hasn’t been used before. Keep track of the previous chosen value to ensure uniqueness. 💡 Key Insight: Sorting + Greedy = Simple and efficient! This ensures minimal overlap and maximum distinctness. ⏱️ Runtime: 19 ms (Beats 84.14%) 💾 Memory: 58.00 MB (Beats 73.79%) Every day, one step closer to mastering algorithmic thinking 💪 #LeetCode #Java #ProblemSolving #100DaysOfCode #CodingJourney #SoftwareEngineering

🚀 Day 13/100 ✅ : Binary addition Tackled the binary-string addition problem in Java today. Here’s what stood out: ⏱ Time Complexity: O(max(n, m)) — we visit each bit exactly once. ✨ Key Strengths: handles different lengths, propagates carry correctly, and avoids overflow. I’m always looking to write code that’s not just correct, but clean and efficient. 💡 What’s one small improvement you made today in your code? Share below! 👇 #100DaysOfCode #Java #Algorithms #CodeQuality #GrowthMindset

#Day-44) of Problem Solving | LeetCode 2011 – Final Value of Variable After Performing Operations Just solved a fun one! 🚀 This problem tests how well you can interpret simple string-based operations and apply them efficiently. Given a list of operations like "++x", "x--", etc., the goal is to compute the final value of a variable starting from zero. 🔍 My approach (Java): Used String.indexOf("+") to detect increment operations and updated the counter accordingly. Clean, readable, and runs in linear time. #LeetCode #Java #ProblemSolving #DSA #CodingChallenge #PranshuCodes #LinkedInCoding #TechJourney

💻 Strengthening My Algorithmic Skills with LeetCode (Java) Recently solved a few problems focusing on string manipulation and pattern-based logic, which helped me improve both problem decomposition and implementation clarity: 🔹 Zigzag Conversion Implemented a pattern-based traversal to simulate zigzag text arrangement across multiple rows. Approach: Row-by-row traversal Time Complexity: O(n) 🔹 Find the Index of the First Occurrence in a String (strStr) Developed a substring matching solution using a straightforward iterative comparison. Approach: Sliding window Time Complexity: O(n × m) 🔹 Reverse Words in a String Solved by splitting the input string, trimming spaces, and reconstructing it in reverse order. Approach: String split + reverse iteration Time Complexity: O(n) These problems helped strengthen my understanding of string operations, pattern logic, and efficient iteration techniques. #LeetCode #Java #DSA #ProblemSolving #Algorithms #Coding #SoftwareEngineering

🔹 Day 38 – LeetCode Practice Problem: Missing Number (LeetCode #268) 📌 Problem Statement: You are given an array nums containing n distinct numbers taken from the range [0, n]. Find the one number that is missing from the array. ✅ My Approach (Java): Calculated the expected sum using the formula total = \frac{n \times (n + 1)}{2} The missing number = total - actual sum. This method avoids sorting or extra space, keeping it optimal. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) ⚡ Submission Results: Accepted ✅ Runtime: 0 ms (Beats 100%) 🚀 Memory: 45.51 MB (Beats 32.44%) 💡 Reflection: A great reminder that sometimes the most efficient solutions come from simple mathematical reasoning. Clean, elegant, and lightning-fast! #LeetCode #ProblemSolving #Java #DSA #CodingPractice #Learning

NeetCode 35 | LeetCode #143 | Reorder Linked List This one’s all about mastering pointer manipulation! Steps I followed: 1️⃣ Find the middle using slow & fast pointers 2️⃣ Reverse the second half 3️⃣ Merge both halves alternately Such problems really sharpen understanding of linked list structure and in-place rearrangement. #NeetCode #LeetCode #Java #DSA #LinkedList #Algorithms #CodingJourney #ProblemSolving