Optimize Gaussian Blur in Java with Separable Filters and Central Limit Theorem

🚀 Solved: Maximum Subarray Problem (Kadane’s Algorithm) Today, I solved the classic Maximum Subarray problem from LeetCode using an efficient approach. 🔍 Problem Statement Given an integer array, find the contiguous subarray with the largest sum and return that sum. 💡 Approach Used: Kadane’s Algorithm Instead of checking all possible subarrays (which would take O(N²)), I used an optimized linear approach: -> Keep a running sum of elements -> If the sum becomes negative, reset it to 0 -> Track the maximum sum encountered so far ⚡ Time Complexity: O(N) 📦 Space Complexity: O(1) 💻 Java Implementation: class Solution { public int maxSubArray(int[] nums) { int sum = 0; int max = nums[0]; for (int i = 0; i < nums.length; i++) { sum = sum + nums[i]; if (sum > max) { max = sum; } if (sum < 0) { sum = 0; } } return max; } } 🎯 Key Insight: Even if a running sum becomes negative, continuing it will only decrease future subarray sums—so it's better to restart. This problem is a great example of how understanding patterns can reduce complexity from brute force to optimal. #Java #DataStructures #Algorithms #LeetCode #CodingInterview #SoftwareEngineering #ProblemSolving

🚀 Day 27 of #100DaysOfCode Solved Single Element in a Sorted Array 🔍 Today’s problem was a great mix of binary search + pattern observation. Instead of checking every element, I used index parity (even/odd) to eliminate half of the search space each time — achieving O(log n) time complexity ⚡ 🔍 Key Learnings: How sorted structure helps optimize search Using index parity to detect the correct half Writing clean edge-case handling for boundaries 💻 Implemented in Java with optimal approach 📈 Runtime: 0 ms | Beat 100% #DSAwithEdSlash #LeetCode #BinarySearch #100DaysOfCode

🚀 Day 80 — Kadane’s Algorithm (Maximum Subarray) Continuing the Kadane pattern — today I implemented the classic Maximum Subarray Sum problem. This is where the “ending at index i” logic truly shines. 📌 Problem Solved: LeetCode 53 – Maximum Subarray 🧠 Kadane’s in Action: java int max = nums[0], gmax = nums[0]; for (int i = 1; i < nums.length; i++) { max = Math.max(nums[i], max + nums[i]); gmax = Math.max(gmax, max); } return gmax; Step‑by‑step logic: max = best sum of subarray ending at current index. At each i, we choose: extend previous subarray (max + nums[i]) or start fresh (nums[i]). gmax tracks the global maximum across all endings. Why this works even with negatives: Because we always have the option to discard the past and start fresh, Kadane’s never gets stuck with a losing streak. 💡 Takeaway: Three lines of code, but behind them lies a powerful pattern. Understanding the why (the decision at each index) makes it easy to adapt to variations like minimum subarray or maximum product. No guilt about past breaks — just building pattern recognition one day at a time. #DSA #KadaneAlgorithm #MaximumSubarray #LeetCode53 #CodingJourney #Revision #Java #ProblemSolving #Consistency #GrowthMindset #TechCommunity #LearningInPublic

🚀 Day 32 of #128DaysOfCode Today I explored an efficient way to find the square root of a number without using built-in functions. Instead of the usual brute force or binary search, I implemented Newton’s Method (Babylonian Method) — a powerful mathematical approach that converges very fast. 🔹 The idea is to continuously improve our guess using: r = (r + x / r) / 2 This method quickly narrows down to the correct integer square root, making it both optimized and elegant. 💡 Key Takeaways: - Learned how mathematical concepts can optimize coding problems - Understood the importance of avoiding overflow using "long" - Practiced writing clean and efficient Java code 🔥 Consistency is the real game changer. Step by step, improving logic and problem-solving skills! #Java #DSA #CodingJourney #ProblemSolving #Consistency #LearnInPublic

✅ Solved: Anagram Palindrome Another step forward in sharpening problem-solving skills 🚀 🔍 Problem Insight: A string can be rearranged into a palindrome if at most one character has an odd frequency. Simple idea, but powerful when applied efficiently. 💡 Implemented using an optimized approach in Java: - Time Complexity: O(n) - Space Complexity: O(1) 📊 Result: ✔️ Test Cases Passed: 1113 / 1113 ✔️ Accuracy: 100% ✔️ Time Taken: 0.52s Small problem, but a good reminder that the right observation beats brute force every time ⚡ #DataStructures #Algorithms #Java #ProblemSolving #CodingJourney #DSA #TechGrowth

🚀 Prim’s Algorithm in Java – Building Minimum Spanning Trees (MST) Continuing my deep dive into graph algorithms, I recently implemented Prim’s Algorithm for finding a Minimum Spanning Tree (MST) in a weighted undirected graph. 🧩 What I Implemented Graph using Adjacency List Min-Heap (PriorityQueue) for greedy selection inMST[] array to avoid cycles Computation of total MST cost This version follows the lazy approach, where: 👉 we push edges into the heap and skip already visited nodes ⚡ Core Idea Always pick the minimum weight edge that connects the current MST to a new vertex. Unlike Dijkstra: ❌ No cumulative distance ✔ Only edge weight matters 🧠 Key Learning The most important distinction I understood: Dijkstra → shortest path from source Prim’s → minimum cost to connect all nodes Even though both use a min-heap, their purpose and logic are completely different. 🔥 Why This Matters MST is widely used in: Network design Infrastructure optimization Clustering problems Understanding Prim’s builds a strong foundation for: Kruskal’s Algorithm Advanced graph problems 📌 Example Result For a sample graph: MST Cost = 21 🚀 Next Step I’ll be implementing Kruskal’s Algorithm with Union-Find to complete my understanding of MST approaches. #Java #DSA #Graphs #PrimsAlgorithm #MST #Algorithms #ProblemSolving #CodingJourney #BackendDevelopment

Day 4 of my DSA Journey 🚀 Today’s challenge: The classic Palindrome Number problem. For today's solution, I focused on an intuitive approach using String manipulation in Java. Sometimes the best way to solve a problem is to break it down into steps that make logical sense right out of the gate! 🧠 My Approach: Handle the edge case: Negative numbers can never be palindromes, so return false immediately. Convert the integer to a String. Use a for loop to iterate backwards through the string, building a new reversed string character by character. Compare the original string with the reversed string to determine if it's a palindrome. ⚡ Key Learnings & Java Gotchas: String Iteration: In Java, strings aren't exactly like arrays, so I had to use .charAt(i) instead of standard bracket notation [i] to grab individual characters. The Comparison Trap: I learned the crucial difference between == and .equals(). In Java, == compares memory locations, but .equals() checks if the actual text values are the same. A huge "aha!" moment for handling Strings! Edge Case Handling: Always check for negative numbers first to save processing time. 📌 Complexity: Time: O(n) — where n is the number of digits, since we loop through the string once. Space: O(n) — for storing the string representations of the number. Every bug is a lesson, and every solved problem is a step forward. On to the next one! 💪 #DSA #DataStructures #Algorithms #ProblemSolving #CodingJourney #Java #TechJourney#DSAJourney #LeetCode #Coding #LearnInPublic #GrowthMindset

🚀 How LinkedList Solves What Arrays Cannot. (https://lnkd.in/g_8fWXFq ) ➡️ An array demands contiguous memory — every element must sit next to the other. But what if memory is scattered? That's exactly where LinkedList steps in, connecting nodes across RAM using addresses. Here are the key takeaways from the LinkedList session at TAP Academy by Sharath R sir : 🔹 The Node: Every element lives in a node — an object with a data field and the address of the next (and previous) node. It's not magic, it's just object references. 🔹 Singly vs Doubly: Singly LL has one link — forward traversal only. Doubly LL has two links — bidirectional. Java's LinkedList class uses Doubly LL internally. 🔹 Initial Capacity = 0: Unlike ArrayList (initial capacity 10), LinkedList pre-allocates nothing. Every add() creates a fresh node dynamically — no contiguous block needed. 🔹 Polymorphism hiding in plain sight: new LinkedList(arrayList) works because ArrayList IS-A Collection. Parent reference + child object = loose coupling. The same concept from OOP, live inside Collections. 🔹 Iterator vs ListIterator: Iterator moves forward only. ListIterator moves both ways — but declaring it as Iterator type blocks access to hasPrevious(). That's Inheritance at work — parent references can't reach specialized child methods. Visit this Interactive webpage to understand the concept by visualization : https://lnkd.in/g_8fWXFq #Java #LinkedList #CoreJava #TapAcademy #DataStructures #OOP #Collections #LearningEveryDay #SoftwareDevelopment #Programming

🚀 LeetCode Problem of the Day 📌 Problem: Minimum Distance to Target Element Given an integer array nums (0-indexed) and two integers target and start, we need to find an index i such that: nums[i] == target |i - start| is minimized 👉 Return the minimum absolute distance. 💡 Key Idea: We simply scan the array and track the minimum distance whenever we find the target. 🧠 Approach Traverse the array Whenever nums[i] == target, compute abs(i - start) Keep updating the minimum result 💻 Java Solution class Solution { public int getMinDistance(int[] nums, int target, int start) { int res = Integer.MAX_VALUE; for (int i = 0; i < nums.length; i++) { if (nums[i] == target) { res = Math.min(res, Math.abs(i - start)); } } return res; } } 📊 Complexity Analysis ⏱ Time Complexity: O(n) → single pass through the array 🧠 Space Complexity: O(1) → no extra space used ⚡ Simple linear scan, optimal solution — sometimes brute force is already the best solution! #LeetCode #Coding #Java #ProblemSolving #DataStructures #Algorithms #InterviewPrep

Just built Linear Regression from scratch in Java! Instead of using libraries, I implemented the core math behind the algorithm to truly understand how it works. This project helped me explore concepts like slope, intercept, and the least squares method in a practical way. 🔹 No external ML libraries 🔹 Pure Java implementation 🔹 Focus on fundamentals This was a great step in strengthening my machine learning basics. 🔗 Check out the project here: [https://lnkd.in/gp7RWNmk] #Java #MachineLearning #LinearRegression #Coding #AI #LearningByDoing