Solved LeetCode 3421: Check if final two digits are equal after transformations

𝐃𝐚𝐲 𝟐𝟏 𝐨𝐟 #50DaysOfDSA 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐋𝐢𝐧𝐤 : https://lnkd.in/gzNm43Xx 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/gAXsPq4Q Today’s challenge was all about counting substrings efficiently — without generating them one by one. The problem? Given a binary string, find the number of substrings that contain only ‘1’s, modulo 1e9+7.  𝐊𝐞𝐲 𝐈𝐧𝐬𝐢𝐠𝐡𝐭: Instead of checking all substrings, simply count consecutive 1s. For every continuous segment of k ones, the number of valid substrings is:  𝐤 * (𝐤 + 𝟏) / 𝟐 But we optimize further by counting while we iterate. 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: -> Maintain a running count of consecutive 1s -> Add that to the total whenever a 1 appears -> Reset when a 0 appears -> Handle large numbers using modulo  𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧)  𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝟏) #leetcode #dsa #java #coding #problemsolving #programming #learningeveryday #devcommunity #softwareengineering #100daysofcode #girlswhocode #problem solving

🚀 Day 110 of #gfg160 – 160 Days of Coding Challenges ✅ Problem Solved: Longest Increasing Subsequence (LIS) 🟡 Difficulty: Medium 🧠 Approach: Used an optimized Binary Search + Dynamic Programming (Patience Sorting) approach to find the length of the Longest Increasing Subsequence. 🔹 Created a temporary list temp to store the smallest possible tail values of increasing subsequences of various lengths. 🔹 For each element in the array: 1️⃣ Used binary search to find its correct position in temp. 2️⃣ If the element is greater than all elements in temp, append it (extend LIS). 3️⃣ Otherwise, replace the first element in temp that is greater than or equal to it (to maintain smallest possible tails). 🔹 The length of temp at the end gives the LIS length. ✅ Efficient and elegant — avoids the O(N²) DP approach by leveraging binary search! ⚡ Complexity: 🕒 Time Complexity: O(N log N) → Each element processed with binary search 💾 Space Complexity: O(N) → For the temp list 📊 Result: ✔️ 1111 / 1111 test cases passed 📈 Accuracy: 100% Finding structure in chaos — building the Longest Increasing Subsequence efficiently! 💪 #Day110 #gfg160 #GeeksforGeeks #Java #BinarySearch #DynamicProgramming #LIS #ProblemSolving #DSA #CodingChallenge #LearnByDoing #160DaysOfCode #DailyDSA #SoftwareEngineering #Consistency #CodingJourney #StJosephsInstituteOfTechnology

💡 Day 56 of #100DaysOfCode 💡 Today, I tackled LeetCode Problem #2220 – Minimum Bit Flips to Convert Number ⚙️ A bit flip means toggling a binary bit from 0 → 1 or 1 → 0. The goal: find the minimum number of flips needed to convert one integer into another using their binary forms. 💻 Language: Java ⚡ Runtime: 0 ms — Beats 💯% 🚀 📉 Memory: 40.31 MB — Beats 90.20% 🧠 Key Learnings: Refreshed bitwise manipulation concepts. Learned efficient use of XOR (^) to find differing bits. Strengthened understanding of binary representation and counting set bits. 🧩 Approach: 1️⃣ Use XOR (start ^ goal) to identify bits that differ. 2️⃣ Count the number of set bits (1s) — each represents one flip needed. 3️⃣ Return the total count as the minimum flips. ✅ Complexity: Time: O(1) — 32-bit integer fixed loop Space: O(1) ✨ Takeaway: Bitwise problems help sharpen low-level thinking — a must for optimizing performance in system-level or embedded applications. #100DaysOfCode #LeetCode #Java #BitManipulation #CodingChallenge #ProblemSolving #CleanCode #Programming #SoftwareEngineering #TechLearning #Algorithms

𝐃𝐚𝐲 𝟏𝟒 of #50DaysOfDSA 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝟏𝟔𝟏𝟏. 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐎𝐧𝐞 𝐁𝐢𝐭 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐭𝐨 𝐌𝐚𝐤𝐞 𝐈𝐧𝐭𝐞𝐠𝐞𝐫𝐬 𝐙𝐞𝐫𝐨 (𝐇𝐚𝐫𝐝) 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐋𝐢𝐧𝐤 : https://lnkd.in/g9NsEW8F 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐢𝐧𝐤 : https://lnkd.in/gKZGpX2B Today’s problem was a real brain-teaser that beautifully connects 𝐛𝐢𝐭 𝐦𝐚𝐧𝐢𝐩𝐮𝐥𝐚𝐭𝐢𝐨𝐧 with 𝐆𝐫𝐚𝐲 𝐜𝐨𝐝𝐞 𝐥𝐨𝐠𝐢𝐜 𝐓𝐡𝐞 𝐜𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞: Transform an integer n → 0 using minimum operations, where each operation allows you to flip certain bits based on specific rules. At first, it looks like a simulation problem... but the real trick lies in understanding how Gray codes work — where consecutive numbers differ by exactly one bit.  𝐈𝐧𝐭𝐮𝐢𝐭𝐢𝐨𝐧: We keep 𝐗𝐎𝐑𝐢𝐧𝐠 𝐧 with its 𝐫𝐢𝐠𝐡𝐭-𝐬𝐡𝐢𝐟𝐭𝐞𝐝 𝐯𝐚𝐥𝐮𝐞 until it becomes 0 , this effectively computes the minimal number of bit flips required. #LeetCode #Java #BitManipulation #CodingChallenge #DSA #ProblemSolving #DeveloperJourney #CodeNewbie #50DaysOfCode #WomenInTech #LearningEveryday

🚀 Day 111 of #gfg160 – 160 Days of Coding Challenges ✅ Problem Solved: Longest String Chain 🟡 Difficulty: Medium 🧠 Approach: Used Dynamic Programming + Sorting to efficiently find the Longest Possible Word Chain. 🔹 Step 1: Sort all words by their length — shorter words come first. 🔹 Step 2: For each word, generate all possible predecessors by removing one character at a time. 🔹 Step 3: Use a HashMap dp where dp[word] represents the longest chain ending at that word. 🔹 Step 4: If a predecessor exists in the map → dp[word] = max(dp[word], dp[predecessor] + 1) Else → Start a new chain with length 1. 🔹 Step 5: Keep track of the global maximum chain length throughout the iteration. ✅ This approach efficiently checks possible chains by reusing previous computations instead of recomputing subsequences. ⚡ Complexity: 🕒 Time Complexity: O(N * L²) → For each word (N), we generate and check up to L possible predecessors. 💾 Space Complexity: O(N) → For the DP map storing longest chain lengths. 📊 Result: ✔️ 1114 / 1114 test cases passed 📈 Accuracy: 100% Dynamic Programming beautifully captures the “build-up” of word sequences — turning small steps into long, powerful chains! 💪 #Day111 #gfg160 #GeeksforGeeks #Java #DynamicProgramming #HashMap #Strings #ProblemSolving #DSA #CodingChallenge #LearnByDoing #160DaysOfCode #DailyDSA #SoftwareEngineering #CodingJourney #Consistency #StJosephsInstituteOfTechnology

🎯 Day 7 of #365DaysofDSA Today I solved “Maximum Depth of Binary Tree” (LeetCode #104) 🌳 💡 Concepts used: • Recursion • Depth Calculation in Binary Trees ✨ Approach Summary: Used a recursive approach to find the longest path from the root node down to the farthest leaf node. For each node: 1️⃣ Recursively find the maximum depth of its left and right subtrees. 2️⃣ The current node’s depth = max(leftDepth, rightDepth) + 1. This elegant recursive solution divides the problem into smaller subproblems — calculating depth for subtrees and combining the results. 🚀 Key takeaway: Recursive thinking simplifies complex tree problems by leveraging the natural hierarchical structure of binary trees. 🌱 #Day7 #DSA #LeetCode #Java #BinaryTree #Recursion #ProblemSolving #CodingJourney #Programming #LearnByDoing #MaximumDepthOfBinaryTree

NeetCode 20 | LeetCode #567 | Permutation in String Applied sliding window with character frequency tracking to efficiently check for permutations in a string. A great exercise in combining logic, hash maps, and window optimization. #NeetCode #LeetCode #Java #DSA #Algorithms #SlidingWindow #ProblemSolving #CodingJourney

🚀 Day 98 of #gfg160 – 160 Days of Coding Challenges ✅ Problem Solved: Find Median in a Stream 🟡 Difficulty: Medium 🧠 Approach: Used two heaps (Priority Queues) — a Max-Heap for the left half and a Min-Heap for the right half of the numbers. For every new number in the stream: 1. Inserted it into the appropriate heap based on its value. 2. Balanced both heaps so that their sizes differ by at most one. Calculated the median: If heaps are of equal size → median = average of both top elements. If not equal → median = top of the larger heap. Stored each median value after every insertion. ⚡ Complexity: Time Complexity: O(N log N) → Each insertion and balancing operation takes log N. Space Complexity: O(N) → For storing elements in both heaps and the result list. 📊 Result: ✔️ 1113 / 1113 test cases passed 📈 Accuracy: 100% Finding the median dynamically using heaps — an elegant real-time data structure application! 💪 #Day98 #gfg160 #GeeksforGeeks #Java #Heap #PriorityQueue #Median #ProblemSolving #DSA #CodingChallenge #LearnByDoing #TechJourney #160DaysOfCode #DailyDSA #Consistency #SoftwareEngineering #CodingJourney #StJosephsInstituteOfTechnology

📌 Day 18/100 - Valid Palindrome (LeetCode 125) 🔹 Problem: Determine whether a string reads the same forward and backward, ignoring case and non-alphanumeric characters. 🔹 Approach: Implemented a two-pointer technique. Skipped all non-alphanumeric characters. Compared characters from both ends in lowercase. Returned true if all matched, otherwise false. 🔹 Key Learning: Two-pointer method keeps logic clean and efficient. Character handling is key when data isn’t uniform. Time complexity: O(n), Space complexity: O(1). Sometimes, solving elegantly is better than solving fast. ✨ #100DaysOfCode #LeetCode #Java #ProblemSolving #DSA #CodingJourney

📘 Day 07/10 of Linked List Series: Delete a Node at the End 🧠 Algorithm (Step-by-Step Explanation) Let’s see how we can delete the last node from a linked list 👇 1️⃣ Check if the list is empty If head == null, there’s nothing to delete → return null. 2️⃣ Check if there’s only one node If head.next == null, deleting that node makes the list empty → return null. 3️⃣ Traverse the list Start from the head and move until you reach the second last node (the node before the last one). 4️⃣ Unlink the last node Make the next of the second last node null — this removes the last node from the list. 5️⃣ Return the updated head The list now has one node deleted from the end. 🪄 Simple Example If your list is → 10 -> 20 -> 30 -> null After deleting the last node → 10 -> 20 -> null 💡 Keep learning, keep building! follow my brand 👉#CodeWithLakkojuEswaraSai #CodeWithLakkojuEswaraSai_LinkedList #DSA #LinkedList #JavaDeveloper #CodingCommunity #100DaysOfCode #LearnDSA #Programming #Java #CodingJourney #TechWithPurpose #LeetCode #CodeNewbie #DevelopersCommunity