Filtering for even numbers divisible by 3 in Java

71 days strong. Small steps. Big consistency. ✅ 🚀 #Day71 of #100DaysOfCodeChallenge Today was about digit manipulation and careful validation logic. 📌 Problem 01: Check If The Number is Fascinating (Easy) A number is called fascinating if: When you concatenate n, 2*n, and 3*n, the resulting number contains all digits from 1 to 9 exactly once, and no zeros. 🧠 Logic: Compute 2*n and 3*n. Concatenate them with n into a single string. If total length is not 9 → return false. Use a boolean array to track digits (1–9). If any digit is 0 or repeated → return false. If all digits from 1 to 9 appear exactly once → return true. This problem looks simple, but it demands attention to edge cases and validation checks. Day 71 complete ✅ Discipline > motivation. Always. 🚀 #100DaysOfCode #Day71 #LeetCode #DSA #Math #Java #ProblemSolving #CodingJourney #LearnInPublic #Consistency

Day 67/100 – LeetCode Challenge ✅ Problem: #228 Summary Ranges Difficulty: Easy Language: Java Approach: Single Pass with Range Detection Time Complexity: O(n) Space Complexity: O(1) excluding output Key Insight: Track start of current consecutive range. When gap found (next ≠ previous + 1), close current range: Single number if start == previous Range "start → previous" otherwise Solution Brief: Iterated through array comparing consecutive elements. Detected breaks in consecutive sequences. Formatted ranges appropriately with arrow for multi-number ranges. Added final range after loop. #LeetCode #Day67 #100DaysOfCode #Array #Java #Algorithm #CodingChallenge #ProblemSolving #SummaryRanges #EasyProblem #RangeDetection #SinglePass #DSA

Day 55: Root-to-Leaf Grinding 🌳 Problem 1022: Sum of Root To Leaf Binary Numbers Back to trees. The goal: sum binary paths from root to leaf. The Strategy: • DFS Brute Force: Stack-based traversal to explore every branch. • Path Tracking: Dragging binary strings down the tree like a heavy backpack. • Conversion: Hit a leaf, parse the string to base 2, add to sum. Ngl, string concatenation in a loop is a bit mid for efficiency, but it got the job done. Bitwise shortcuts are next on the menu. We move. 🚀 #LeetCode #Java #BinaryTree #DFS #Coding #DailyCode

Day 22 of Daily DSA 🚀 Solved LeetCode 66: Plus One ✅ Approach: Treat the array as a number and simulate addition from the last digit: • If the last digit is not 9, increment and return • Handle carry by setting 9 → 0 and moving left • If all digits are 9, create a new array with leading 1 This avoids converting the array into an integer and handles large numbers safely. ⏱ Complexity: • Time: O(n) • Space: O(1) (extra array only when overflow happens) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 43.58 MB (Beats 38.49%) A simple problem that tests edge-case thinking 💡 #DSA #LeetCode #Java #ProblemSolving #DailyCoding #Consistency

Day 85/100 – LeetCode Challenge ✅ Problem: #226 Invert Binary Tree Difficulty: Easy Language: Java Approach: Recursive DFS (Divide and Conquer) Time Complexity: O(n) Space Complexity: O(h) where h = tree height Key Insight: Swap left and right child at every node, then recursively invert both subtrees. Classic recursion problem — made famous by Google interview story. Solution Brief: Base case: if root is null, return null. Swap left and right children using temporary variable. Recursively call invertTree on left and right subtrees. Return the root (now inverted). #LeetCode #Day85 #100DaysOfCode #Tree #Java #Algorithm #CodingChallenge #ProblemSolving #InvertBinaryTree #EasyProblem #DFS #Recursion #DSA

🚀 Day 81 / 100 – LeetCode Daily Challenge 📌 Problem: Minimum Partitions to Decompose a Number (1689) 🧠 Concept: Greedy | String Manipulation Today’s problem was deceptively simple but conceptually rich — finding the minimum number of deci-binary numbers needed to sum up to a given string n. The key insight? 🔍 The answer is simply the maximum digit in the string! Why? Because in any addition of deci-binary numbers (each made of only 0s and 1s), the largest digit in the target number dictates how many numbers are needed in the worst-case scenario. So if the number is "82734", we need at least 8 numbers (one for each unit at the position of '8'). ✅ One pass. One max check. Clean and greedy. 📊 Runtime: 6 ms | Beats 75.56% 💾 Memory: 47.43 MB ✨ Key takeaway: Sometimes the most efficient solution is hiding in plain sight — just read the problem carefully and think about the underlying constraints. #LeetCode #CodingJourney #100DaysOfCode #Day81 #GreedyAlgorithm #Java #ProblemSolving #TechCommunity #DevLife #CodeNewbie

Day 9/100 – LeetCode Challenge Problem Solved: Pow(x, n) Today I worked on implementing a power function that calculates x raised to the power n. The challenge lies in handling edge cases such as negative exponents and integer overflow scenarios, especially when n equals Integer.MIN_VALUE. The core idea was to carefully manage the exponent: If n is negative, convert the base to its reciprocal. Convert the exponent to a positive value for computation. Handle extreme integer boundaries safely. The straightforward implementation multiplies the base repeatedly, but this approach runs in linear time with respect to n. While it works for smaller inputs, it highlights an important lesson about optimization and algorithmic efficiency. Time Complexity: O(n) Space Complexity: O(1) #100DaysOfLeetCode #Java #ProblemSolving #Algorithms #Consistency #Learning

🚀 Day 52/100: Reverse Simulation with Deques Today’s challenge: LeetCode 950 - Reveal Cards In Increasing Order. 🃏 The trick to this problem isn't moving forward; it's thinking backward. To find the original deck order, I reversed the "reveal and move to bottom" process: Sort the deck to know the target reveal order. Reverse the simulation using a Deque (Double-Ended Queue). Shift the last element to the front and add the next sorted card. Key Learning: When a process seems complex to simulate forward, try starting from the result and working back to the beginning! #100DaysOfCode #DSA #LeetCode #Java #ProblemSolving #CodingChallenge

Day 82/100 – LeetCode Challenge ✅ Problem: #43 Multiply Strings Difficulty: Medium Language: Java Approach: Manual Multiplication with Result Array Time Complexity: O(n × m) Space Complexity: O(n + m) Key Insight: Multiply digits from right to left (least significant first). Store intermediate results in array where index i + j + 1 holds current digit. Handle carry by adding to previous index. Solution Brief: Edge case: if either number is "0", return "0". Created result array of size n1 + n2 (max possible digits). Nested loops multiply each digit of num1 with each digit of num2. Accumulated results with proper carry handling. Built final string skipping leading zeros. #LeetCode #Day82 #100DaysOfCode #Math #String #Java #Algorithm #CodingChallenge #ProblemSolving #MultiplyStrings #MediumProblem #Multiplication #Array #DSA