Count Number of Pairs With Absolute Difference K

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐄𝐟𝐟𝐢𝐜𝐢𝐞𝐧𝐭 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 | 𝐊-𝐃𝐢𝐟𝐟 𝐏𝐚𝐢𝐫𝐬 𝐢𝐧 𝐚𝐧 𝐀𝐫𝐫𝐚𝐲💡 🧠 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given an integer array nums and an integer k, find the total number of unique pairs such that: [|nums[i] - nums[j]| = k] where: i != j Only unique pairs should be counted. 📌 Example: Input: nums = [3,1,4,1,5], k = 2 Output: 2 Valid pairs: (1,3) (3,5) ⚡ 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 (𝐇𝐚𝐬𝐡𝐢𝐧𝐠) Instead of checking every pair using brute force O(n²), we can: 1️⃣ Store frequency of every element in an unordered_map. 2️⃣ Traverse the map: If k == 0, check elements having frequency > 1. Otherwise, check whether (current_element + k) exists in the map. 3️⃣ Count only unique valid pairs. ⏱️ Complexity Analysis Time Complexity: O(n) average Space Complexity: O(n) 🔗 Optimal Approach Code: https://lnkd.in/gm63ATx7 💡 Key Learning from this Problem ✅ Frequency maps help avoid duplicate pair counting. ✅ Hashing reduces unnecessary nested loop comparisons. ✅ Special handling is required when k = 0. ✅ Excellent problem to strengthen concepts of: Hash Maps Frequency Counting Unique Pair Logic ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “All” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- 🏷️ #CompetitiveProgramming #DSA #Hashing #Cpp #LeetCode #Coding #ProblemSolving #Algorithms #DataStructures

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 |𝐒𝐮𝐛𝐚𝐫𝐫𝐚𝐲 𝐒𝐮𝐦𝐬 𝐃𝐢𝐯𝐢𝐬𝐢𝐛𝐥𝐞 𝐛𝐲 𝐊 | 𝐄𝐟𝐟𝐢𝐜𝐢𝐞𝐧𝐭 𝐏𝐫𝐞𝐟𝐢𝐱 𝐒𝐮𝐦 + 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐚𝐩𝐩𝐫𝐨𝐚𝐜𝐡 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given an integer array nums and an integer k, return the number of non-empty subarrays whose sum is divisible by k. This problem looks tricky at first, but with the right observation, it can be solved in linear time ⚡ 🔍 𝐊𝐞𝐲 𝐎𝐛𝐬𝐞𝐫𝐯𝐚𝐭𝐢𝐨𝐧: If two prefix sums have the same remainder when divided by k, then the subarray between them will have a sum divisible by k. Mathematical Insight: If: prefixSum[i] % k == prefixSum[j] % k Then: (prefixSum[j] - prefixSum[i]) % k == 0 Which means the subarray between i+1 and j is divisible by k. ✅ 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 : 🔹 Prefix Sum + Hashing (Unordered Map) Steps: ✔️ Maintain running prefix sum ✔️ Compute remainder rem = sum % k ✔️ Handle negative remainders carefully ✔️ Store frequency of each remainder in hash map ✔️ If same remainder appears again → add previous frequency to answer ⏱️ Complexity Analysis Time Complexity: O(N) Space Complexity: O(K) (or O(N) in worst case) 💻 Optimal Code Link: https://lnkd.in/gvGn4E_7 ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “All” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- #PrefixSum #Hashing #ModuloArithmetic #SlidingWindow #CompetitiveProgramming #DSA #Cpp #ProblemSolving #Algorithms #Coding #DataStructures #Programmer

Spent 3 hours debugging why my agent kept calling the wrong tool. LLM wasn't broken. My tool description was. The model doesn't read your code. It reads the docstring. Thats it. I had a tool described as "fetch campaign data." Agent kept calling it for everything remotely "data" related. User info, account stuff, random metadata.. anything that smelled like data. Fix wasnt a smarter model. Was a sharper description. Changed it to: "Fetch performance metrics (impressions, clicks, spend) for ONE campaign by campaign_id. Does NOT return audience or account data." Tool selection went from ~60% correct to 95%+. Same model. Same graph. One sentence. 3 things I do now for every MCP tool I write: → Say what it does AND what it doesn't do → Put the actual inputs in the description, not just in the schema → Test the description alone — if a junior dev cant tell when to use it, neither can the LLM The model isnt picking tools. Your docstrings are. #AIEngineering #MCP #LangGraph #LLM #AIAgents #GenAI #MachineLearning #AI #BuildInPublic #Python

🚀 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐅𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐂𝐨𝐮𝐧𝐭 = 𝐏𝐨𝐰𝐞𝐫𝐟𝐮𝐥 𝐒𝐭𝐫𝐢𝐧𝐠 𝐏𝐫𝐨𝐜𝐞𝐬𝐬𝐢𝐧𝐠 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 𝐢𝐧 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given an array of strings, return all characters that appear in every string, including duplicates. Example: Input: ["bella","label","roller"] Output: ["e","l","l"] 🔍 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 (𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐅𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐂𝐨𝐮𝐧𝐭): Instead of comparing every character manually between strings, we use: ✅ Frequency Map (Hashing) ✅ Minimum Frequency Tracking ✅ Character-wise Processing from 'a' to 'z' 💡 Core Idea: Count frequency of each character in every word. Maintain the minimum occurrence of every character across all words. The minimum frequency tells how many times a character should appear in the final answer. ⚡ Why This Approach is Efficient? ✔ Avoids unnecessary comparisons ✔ Works efficiently even for larger inputs ✔ Uses constant alphabet size (26 lowercase letters) ⏱ Time Complexity: O(N * L) Where: N = number of words L = average length of each word Since alphabet size is fixed (26), the solution remains highly optimized 🚀 🧠 𝐊𝐞𝐲 - 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠: This problem is a great example of: Hashing Frequency Counting String Processing Minimum Frequency Logic Efficient Data Structure Usage 🔗 Code Link: https://lnkd.in/gqnyiFVJ #CompetitiveProgramming #DSA #Hashing #Cpp #Coding #ProblemSolving #Algorithms #Programming #Codeforces #DataStructures #SoftwareEngineering #Coding #Strings

🚀𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 | 𝐅𝐢𝐧𝐝 𝐭𝐡𝐞 𝐃𝐮𝐩𝐥𝐢𝐜𝐚𝐭𝐞 𝐍𝐮𝐦𝐛𝐞𝐫 𝐩𝐫𝐨𝐛𝐥𝐞𝐦 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭 Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive. There is only one repeated number in nums, return this repeated number. ⚠️ Constraints: Do not modify the original array Use only constant extra space (optimal requirement) 🧪 Example Example 1 Input: nums = [1,3,4,2,2] Output: 2 Example 2 Input: nums = [3,1,3,4,2] Output: 3 ⚡ 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐔𝐬𝐞𝐝 — 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 ✔️ Traverse the array ✔️ Store frequency of every element using unordered_map ✔️ The first element whose frequency becomes greater than 1 is the duplicate number 📈 Complexity Analysis ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(n) 🔗 Optimal Approach Code Link: https://lnkd.in/gJAbVvSz ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “𝐀𝐥𝐥” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- #CompetitiveProgramming #DSA #Hashing #Cpp #Coding #Programming #LeetCode #DataStructures #Algorithms #ProblemSolving

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐌𝐚𝐱 𝐍𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐊-𝐒𝐮𝐦 𝐏𝐚𝐢𝐫𝐬 𝐮𝐬𝐢𝐧𝐠 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐅𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐂𝐨𝐮𝐧𝐭𝐢𝐧𝐠  Instead of checking every pair using brute force O(n²), we can optimize the solution using Hash Maps / Hashing and solve it in O(n) time complexity ⚡ 🔹 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐏𝐨𝐢𝐧𝐭𝐬: ✅ Frequency counting using hashing ✅ Complement technique (partner = k - number) ✅ Handling duplicate values efficiently ✅ Avoiding double counting of pairs ✅ Optimized competitive programming approach 📌 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐔𝐬𝐞𝐝: • Store frequency of each element in an unordered map • For every number x, find its partner k - x • If both exist, form valid pairs • Special handling when x == partner • Count maximum operations efficiently ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 🧠 Problem Solving Pattern: Hashing + Frequency Array + Pair Matching 💻 Optimal Approach Code Link: https://lnkd.in/gnPgiymY ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “𝐀𝐥𝐥” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- #CompetitiveProgramming #Coding #DSA #Hashing #Cpp #LeetCode #Programming #ProblemSolving #Algorithms #DataStructures #SoftwareEngineer #Developer #CodingJourney

🚀 𝟒𝐒𝐔𝐌 – 𝐂𝐨𝐮𝐧𝐭 𝐐𝐮𝐚𝐝𝐫𝐮𝐩𝐥𝐞𝐭𝐬 𝐰𝐢𝐭𝐡 𝐆𝐢𝐯𝐞𝐧 𝐒𝐮𝐦 | 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 🔹 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given an array and a target value, count all unique quadruplets such that: arr[i] + arr[j] + arr[k] + arr[l] = target where all indices are distinct. 📌 Example: Input: arr[] = [1, 5, 3, 1, 2, 10] target = 20 Output: 1 Because: 5 + 3 + 2 + 10 = 20 ✅ ⚡ 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Instead of using the brute force O(n⁴) approach, we optimize the solution using Hash Maps. ✅ Key Idea: Store pair sums in a hash map and use them to efficiently find complementary sums for the remaining two elements. 🔥 Steps: 1️⃣ Traverse the array and treat arr[i] as the 3rd element. 2️⃣ For every arr[j] (4th element), calculate: required = target - (arr[i] + arr[j]) 3️⃣ Check if this required sum already exists in the hash map. 4️⃣ Add its frequency to the answer. 5️⃣ Store pair sums of previous elements into the hash map. ⏱ Time Complexity: O(n²) 📦 Space Complexity: O(n²) 🔗 Optimal Approach Code: https://lnkd.in/gDnVuEQQ ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “All” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- #CompetitiveProgramming #DSA #Hashing #Cpp #Coding #LeetCode #ProblemSolving #Algorithms #Programming #SoftwareEngineering #DataStructures #Developer #Tech #LinkedInCoding

Most people use Binary Search. Few truly understand when to use it. 🚀 Binary Search is not just for searching. It’s a pattern that optimizes problems from O(n) to O(log n). ━━━━━━━━━━━━━━━━━━ 📌 When to Use Binary Search Use Binary Search when: ✅ The search space is sorted ✅ The answer follows a monotonic pattern ✅ You can eliminate half of the search space ━━━━━━━━━━━━━━━━━━ ⚡ Why It’s Powerful Instead of checking every element, Binary Search cuts the search space in half at every step. That’s why it scales so efficiently. ━━━━━━━━━━━━━━━━━━ 📌 Time Complexity Binary Search → O(log n) For n = 10⁵ Only ~17 operations That’s the advantage of logarithmic growth. ━━━━━━━━━━━━━━━━━━ 🎯 Common Variations • Classic Binary Search • Lower Bound • Upper Bound • First / Last Occurrence • Search in Rotated Sorted Array • Binary Search on Answer ━━━━━━━━━━━━━━━━━━ 💡 Golden Rule Whenever you see: • Sorted array • First / Last occurrence • Minimum / Maximum • Large constraints Think Binary Search. ━━━━━━━━━━━━━━━━━━ Binary Search is not just an algorithm. It’s a way of thinking: Eliminate half, move closer, repeat. Follow for more DSA and interview prep content. #DataStructures #Algorithms #BinarySearch #DSA #LeetCode #CodingInterview #Programming #SoftwareEngineer

Telling an LLM to "respond in JSON" is like asking someone to speak French — they might try, but you'll get random grammar errors that break your code at 2am. The difference between hoping for JSON and guaranteeing it comes down to one thing: schema validation at the token level. When you use OpenAI's response_format parameter with Structured Outputs, or Anthropic's Tool Use feature, the model literally cannot generate tokens that would violate your schema. It's not following instructions — it's constrained. Here's what this looks like in practice: 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝘀𝗰𝗵𝗲𝗺𝗮 𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻: "Extract the product name and price as JSON" → Sometimes returns {price: "$29"}, sometimes {"Price": 29.00}, sometimes adds unexpected fields 𝗪𝗶𝘁𝗵 𝘀𝗰𝗵𝗲𝗺𝗮 𝘃𝗮𝗹𝗶𝗱𝗮𝘁𝗶𝗼𝗻: Define a schema requiring product_name (string) and price_usd (number), pass it via the API's structured output parameter → Always returns {"product_name": "Widget Pro", "price_usd": 29.00} The mechanical reason this works: the API restricts token sampling to only valid next tokens according to your schema. The model can't close a JSON object until required fields exist. Schemas only enforce shape, not meaning. That's where the self-healing pattern comes in — when 𝗣𝘆𝗱𝗮𝗻𝘁𝗶𝗰 catches a semantic edge case, the error feeds back to the LLM for auto-correction. Two layers of safety: 1. Structured Outputs guarantees the JSON shape is correct 2. Pydantic validators catch the semantic edge cases the schema can't express (like "category must be one of these four values") When layer 2 fails, the ValidationError becomes the next prompt — turning the LLM into its own debugger. What's your retry strategy when structured outputs still occasionally fail validation? Do you cap retries, swap models, or fall back to a human review queue? #PromptEngineering #LLM #JSON #AIEngineering #LearningInPublic