Competitive Programming: Counting Nice Subarrays with Hashing + Prefix Sum

I just pushed the first meaningful commit to "RecomS6" — my recommendation system project. It's a structured, engineered system comparing multiple approaches: SVD, collaborative filtering, and a few ML models — built to understand what actually works and why. 🔎 One decision I made early that I think matters: Most recommendation system tutorials split data randomly just because it is fast and clean. But unfortunately useless for this type of project. If my model sees a user's future interactions during training (due to random split), my evaluation metrics will look great. ... Until production 🫡 So I went with per-user temporal split. Sort each user's interactions by timestamp, take the last 20% as test. Every user gets a realistic evaluation. No leakage. Small decision. Big difference in how much you can trust your results. The repo also follows proper ML project structure — data and models gitignored, clean separation of raw/processed/splits, reproducible from scratch. This is the beginning. SVD implementation is in. More algorithms coming. A full video walkthrough is planned. If you're into recommendation systems, ML engineering, or just building things — follow along. GitHub: https://lnkd.in/dcPjjNd6 #MachineLearning #RecommenderSystems #Python #MLEngineering #OpenSource

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 | 𝐂𝐚𝐧 𝐖𝐞 𝐅𝐨𝐫𝐦 𝐚𝐧 𝐀𝐫𝐢𝐭𝐡𝐦𝐞𝐭𝐢𝐜 𝐏𝐫𝐨𝐠𝐫𝐞𝐬𝐬𝐢𝐨𝐧 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: A sequence is called an Arithmetic Progression (AP) if the difference between consecutive elements is constant. 👉 Given an array arr, determine whether it can be rearranged to form an AP. 💡𝐊𝐞𝐲 𝐈𝐝𝐞𝐚 (𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡): Instead of sorting (O(n log n)), we can optimize using hashing 👇 🔹 Find minimum and maximum values 🔹 Compute expected difference: diff = (max - min) / (n - 1) 🔹 Store all elements in a hash set 🔹 Check if every expected element exists: min, min+diff, min+2*diff, ... ⚡ 𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐰𝐨𝐫𝐤𝐬? If the array can form an AP, all expected values must exist in the set —> no missing elements allowed. ⏱️ Complexity Analysis ✔️ Time Complexity: O(n) ✔️ Space Complexity: O(n) 🔗 Optimal Approach Code: https://lnkd.in/geaya_QQ 📊 Example Input: [3,5,1] → Output: ✅ True Input: [1,2,4] → Output: ❌ False 🔥 Key - Takeaway Hashing helps eliminate sorting and reduces time complexity — a powerful trick in competitive programming! #CompetitiveProgramming #DSA #Hashing #Algorithms #Coding #ProblemSolving #Cpp

My AI agent spent 20 minutes debugging the wrong file. I only know because I built the thing that caught it. A few weeks ago I built agent-replay-debugger - a CLI that turns agent session traces into interactive timelines. v1 was basically a fancy log viewer. It told you what happened (the agent read 40 files) but not why it read 40 files when it only needed 3. So I added --analyze. One flag, and every reasoning block gets classified by an LLM: is the agent planning? investigating? implementing? Or - my personal favorite - is it backtracking because it just realized it's been editing the wrong file for the last 15 minutes? On a real 2-hour session with 600+ events, I got exactly 2 red flags. Those 2 flags were worth more than the other 598 events combined. Total cost of running the analysis: 2 cents. What else is new: The viewer used to show one flat blob per session. Now each user message creates its own span - a 2-hour session becomes 33 clickable nodes in the DAG, each showing how long the agent spent and how many tool calls it made. You can instantly see that "PR 1" took 2 hours and 83 tool calls while "list issues" took 10 seconds and 1 call. Also shipped a pick command because I got tired of copy-pasting UUIDs: ard view $(ard pick chore-champions) Still zero runtime dependencies. Still pure Python stdlib. 188 tests, 100% coverage enforced in CI. The --analyze flag talks to the Anthropic API using urllib - no SDK needed. Live demo (real session, LLM-annotated, all secrets auto-scrubbed): https://lnkd.in/gRFB7uWf Code: https://lnkd.in/gPTUt4ue  #buildInPublic #AIAgents #LLM #Python #OpenSource #DevTools #AIEngineering

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐂𝐨𝐧𝐭𝐫𝐢𝐛𝐮𝐭𝐢𝐨𝐧 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 | 𝐂𝐡𝐚𝐫𝐚𝐜𝐭𝐞𝐫 𝐂𝐨𝐧𝐭𝐫𝐢𝐛𝐮𝐭𝐢𝐨𝐧 𝐢𝐧 𝐀𝐥𝐥 𝐒𝐮𝐛𝐬𝐭𝐫𝐢𝐧𝐠𝐬 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given a string, for every character calculate how many times it appears across all possible substrings of the original string. Then: ✅ Find the character with the highest total contribution ✅ If multiple characters have the same highest contribution, return the lexicographically smallest character Example: s = "abca" Contribution: 🔹 a = 10 🔹 b = 7 🔹 c = 7 Answer = a 🎯 𝐁𝐫𝐮𝐭𝐞 𝐅𝐨𝐫𝐜𝐞 𝐈𝐝𝐞𝐚: Generate all possible substrings, then iterate through every character inside each substring and maintain frequency using hashing. Time Complexity: O(N^3) ⏳ Brute Force Code Link: https://lnkd.in/gH3Bev66 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Instead of generating all substrings, observe how many substrings include a character at index i. If: x = number of characters on the left side y = number of characters on the right side Then total substrings containing s[i] are: (x + 1) * (y + 1) This can also be written as: x*y + x + y + 1 We use hashing to accumulate the total contribution of every character and then find the character with maximum contribution. Time Complexity: O(N) ⚡ Optimal Code Link: https://lnkd.in/gPrTXDbS 💡 This problem is a great example of contribution technique + hashing where we reduce an O(N^3) brute force solution to an O(N) optimal solution. #CompetitiveProgramming #DSA #Hashing #Algorithms #Cpp #Programming #Coding #ProblemSolving #DataStructures

🚀 𝐒𝐮𝐛𝐚𝐫𝐫𝐚𝐲 𝐌𝐄𝐗𝐞𝐬 — 𝐀 𝐏𝐨𝐰𝐞𝐫𝐟𝐮𝐥 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐂𝐨𝐦𝐛𝐢𝐧𝐚𝐭𝐨𝐫𝐢𝐜𝐬 𝐈𝐧𝐬𝐢𝐠𝐡𝐭 𝐏𝐫𝐨𝐛𝐥𝐞𝐦!! 🔍 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐮𝐦𝐦𝐚𝐫𝐲: Given an array arr containing all integers from 1 to n and an integer k, we need to find the k-th smallest MEX among all possible subarrays. 👉 MEX (Minimum EXcluded) = smallest positive integer not present in a subarray 👉 A subarray = contiguous segment of the array 💡𝐛𝐫𝐮𝐭𝐞-𝐟𝐨𝐫𝐜𝐞 𝐚𝐩𝐩𝐫𝐨𝐚𝐜𝐡: (checking all subarrays) would take O(n²) or worse — clearly not feasible for large inputs. So how do we optimize? 🤔 ⚡ 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 :(Hashing + Smart Range Expansion) 🔥 Key idea: Instead of generating subarrays, we count how many subarrays have MEX = i for each i. 🧠 Core Steps: 1️⃣ Store Positions Using Hashing Map each number → its index in the array. 2️⃣ Process Numbers from 1 → n Maintain a segment [L, R] that contains all numbers from 1 → i. 3️⃣ Expand the Segment As you add each number: Update the current range [L, R] Count how many new subarrays can be formed 4️⃣ Count Subarrays for Each MEX Use combinatorics: 👉 (left_free + 1) × (right_free + 1) 5️⃣ Build Frequency Array Store how many subarrays have MEX = i 6️⃣ Prefix Sum Trick Find the smallest i such that cumulative count ≥ k 📊 Complexity ⏱️ Time: O(n) 📦 Space: O(n) 🎯 𝐖𝐡𝐲 𝐭𝐡𝐢𝐬 𝐚𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐬𝐭𝐚𝐧𝐝𝐬 𝐨𝐮𝐭? No brute force use of hashing Combines math + logic common pattern in advanced CP problems 💻 Optimal Code Link: 🔗 https://lnkd.in/gQKqh394 💬 Key - Takeaway This problem teaches one thing that: 👉 Sometimes, counting is more powerful than constructing. #CompetitiveProgramming #DSA #Hashing #Algorithms #Coding #ProblemSolving #Cpp #Codeforces #Learning

🚀 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐏𝐫𝐞𝐟𝐢𝐱/𝐬𝐮𝐟𝐟𝐢𝐱 𝐒𝐮𝐦 𝐏𝐨𝐰𝐞𝐫𝐟𝐮𝐥 𝐏𝐚𝐭𝐭𝐞𝐫𝐧 𝐢𝐧 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given an integer array nums and an integer k, return true if there exists a continuous subarray of length at least 2 such that the sum of the subarray is a multiple of k. Example: nums = [23, 2, 6, 4, 7], k = 6 Output: true Because the entire array sum becomes 42 and 42 is divisible by 6. 🔥 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐈𝐝𝐞𝐚: Instead of checking every possible subarray using brute force O(N²), we can use: • Prefix Sum • Modulo Arithmetic • Hash Map 𝐊𝐞𝐲 𝐎𝐛𝐬𝐞𝐫𝐯𝐚𝐭𝐢𝐨𝐧: If two prefix sums give the same remainder when divided by k, then the subarray between them has a sum divisible by k. Suppose: prefixSum[i] % k == prefixSum[j] % k Then: (prefixSum[j] - prefixSum[i]) % k == 0 That means the subarray from i+1 to j is divisible by k. 💡 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Maintain running prefix sum Compute prefixSum % k Store first occurrence of every remainder in a hash map If same remainder appears again and distance between indices is at least 2, return true Why store only first occurrence? Because we want the maximum possible subarray length and earliest index gives larger distance. ⏱ Time Complexity: O(N) 📦 Space Complexity: O(N) This is one of the most important hashing concepts because the exact same logic is used in: • Count subarrays divisible by k • Longest subarray with equal 0s and 1s • Longest subarray with given sum • Continuous subarray sum problems • Prefix remainder based problems Optimal approach code link: https://lnkd.in/g5u3vPhd #CompetitiveProgramming #DSA #Hashing #PrefixSum #Cpp #Coding #Leetcode #Algorithms #Programmer #ProblemSolving

🚀𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝: 𝐂𝐨𝐩𝐲 𝐋𝐢𝐬𝐭 𝐰𝐢𝐭𝐡 𝐑𝐚𝐧𝐝𝐨𝐦 𝐏𝐨𝐢𝐧𝐭𝐞𝐫 Solved one of the most interesting and tricky Linked List problems that tests deep understanding of pointers and space optimization 🔍 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: Given a linked list where each node has: • next pointer • random pointer (can point to any node or NULL) Create a deep copy of the list. 💡𝐊𝐞𝐲 𝐈𝐧𝐬𝐢𝐠𝐡𝐭: The challenge is to copy both: • structure (next) • arbitrary connections (random) 👉 And do it without using extra space (like hashmap). ⚙️ 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐈 𝐔𝐬𝐞𝐝 (𝟑-𝐒𝐭𝐞𝐩 𝐎𝐩𝐭𝐢𝐦𝐢𝐳𝐞𝐝 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧): ✅ 𝐒𝐭𝐞𝐩 𝟏: 𝐂𝐫𝐞𝐚𝐭𝐞 𝐂𝐥𝐨𝐧𝐞𝐝 𝐍𝐨𝐝𝐞𝐬 𝐈𝐧-𝐏𝐥𝐚𝐜𝐞 • For each node A, create its clone A' • Insert it right after the original node 👉 A → A' → B → B' → ... ✅ 𝐒𝐭𝐞𝐩 𝟐: 𝐀𝐬𝐬𝐢𝐠𝐧 𝐑𝐚𝐧𝐝𝐨𝐦 𝐏𝐨𝐢𝐧𝐭𝐞𝐫𝐬 • Use original node relationships • A'->random = A->random->next 👉 Because cloned nodes are placed next to original ones ✅ 𝐒𝐭𝐞𝐩 𝟑: 𝐒𝐞𝐩𝐚𝐫𝐚𝐭𝐞 𝐭𝐡𝐞 𝐓𝐰𝐨 𝐋𝐢𝐬𝐭𝐬 • Restore original list • Extract cloned list 🧠 𝐖𝐡𝐲 𝐓𝐡𝐢𝐬 𝐖𝐨𝐫𝐤𝐬: By interleaving cloned nodes with original nodes: • We avoid extra space • We get direct access to corresponding cloned nodes This is a clever trick that reduces space complexity from O(n) → O(1) 🧾 𝐂𝐨𝐫𝐞 𝐋𝐨𝐠𝐢𝐜: clonedNode->random = it->random ? it->random->next : nullptr; 📈 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: • Time Complexity: O(n) • Space Complexity: O(1) (excluding output list) ✨ 𝐖𝐡𝐚𝐭 𝐈 𝐋𝐞𝐚𝐫𝐧𝐞𝐝: • Smart pointer manipulation can eliminate extra space • Visualizing the structure helps solve complex problems • This is one of the most important Linked List interview questions 🔥 From basic linked lists to advanced pointer problems — consistency is key! #LeetCode #DSA #LinkedList #Coding #CPP #ProblemSolving #Algorithms

OpenDataLoader PDF is an open-source tool from the OpenDataLoader Project (backed by Hancom) that converts PDFs into AI-ready Markdown and JSON with exceptional accuracy. It ranks #1 in benchmarks (0.907–0.91 overall, 0.928 table accuracy) across 200 real-world documents. Key features include deterministic local mode (no GPU), hybrid AI mode for complex pages, bounding boxes for every element, OCR for 80+ languages, formula extraction as LaTeX, chart/image descriptions, and auto-tagging for PDF accessibility (PDF/UA). Outputs support RAG pipelines, LangChain integration, and safe extraction (filters hidden text to prevent prompt injection). Ideal for document AI, RAG, and compliance. Apache 2.0 license. Install via pip or use Python/Node/Java SDKs. #OpenDataLoader #PDFParser #RAG #DocumentAI #OpenSource

📣 We ran chunk_size=300 on the same document across three frameworks. SynapseKit: 12 chunks. LangChain: 12 chunks. LlamaIndex: 2 chunks. Same parameter. Same document. Order of magnitude difference in output. Zero error messages. Here's what's happening: LlamaIndex's SentenceSplitter interprets chunk_size as tokens, not characters. chunk_size=300 means 300 tokens — roughly 1,200 characters. On a 1,972-character document that gives you 2 chunks averaging 986 characters each instead of the 12 chunks averaging 163 characters you'd expect. This is documented behavior. It is also the most common source of confusion when engineers copy parameters from a LangChain tutorial into LlamaIndex. Same parameter name. Completely different semantics. Your retrieval quality changes by an order of magnitude and nothing tells you why. The rule: never copy chunk parameters across frameworks without checking the unit. chunk_size=300 means... SynapseKit → 300 characters → 12 chunks LangChain → 300 characters → 12 chunks LlamaIndex → 300 tokens (~1,200 chars) → 2 chunks ⚠ A few other things worth knowing from this benchmark: LangChain ships 8 built-in splitters. LlamaIndex ships 9. SynapseKit ships 2. But two of LlamaIndex's splitters — SentenceWindowNodeParser and HierarchicalNodeParser — have no equivalent in the other frameworks and solve real production problems that the others don't address at all. LangChain's standalone splitter API is the most debuggable. You can inspect chunks before indexing. SynapseKit's chunking is opaque — parameters live on the Retriever and you can't see the split before it's indexed. Chunking is not configuration. It's architecture. The split you choose affects embedding quality, retrieval precision, and whether your LLM gets enough context. The tutorials that sprint past it in two lines are the same tutorials whose RAG demos fall apart on real documents. Full benchmark + reproducible Kaggle notebook → engineersofai.com #Python #AI #LLM #RAG #MLEngineering #OpenSource #AIEngineering #EngineersOfAI #SynapseKit

I finally understood KMP..... 🥹 First of all, this algorithm is used to find out some pattern in a string. ⬛ The Old Way (Naive Approach): --> Imagine searching for the word "ABC" in a long paragraph. You'd check position 0: "ABC" vs "ABX...." → mismatch at 3rd letter Then move to position 1: start comparing from scratch again Then position 2, then 3... so on. Problem: You keep re-checking the same letters over and over. Time complexity: O(n × m) 🟨 The KMP Way: --> It uses LPS (Longest Prefix that is also a Suffix) array. This array tells KMP --> When a mismatch happens, don't start from zero instead, jump back to this position. How KMP Works (Simple Terms): Step 1: Build LPS array for your search word (done once) Step 2: Walk through your text with two "pointers" One pointer moves through the text (always forward, never back!) One pointer moves through your search word (pattern) Step 3: When characters match --> both move forward Step 4: When mismatch happens: Instead of going back to start of search word Jump the search word pointer back to LPS[previous position] Keep the text pointer where it is The Magic: The text pointer NEVER goes backward! Time Complexity: O(n + m) & This is LINEAR! 🟦Real World Example: |++| Ever wondered how Google finds your search in milliseconds? --> Pattern-matching algorithms like KMP (and its faster cousins like Boyer-Moore) are working behind the scenes. Also used in: |++| Ctrl+F in browser/document |++| Plagiarism detection software It’s actually not that scary 😄 Share your views below and follow for more. #KMP #Algorithms #StringMatching #DataStructures #Coding #Programming #ComputerScience #TechEducation #ProblemSolving #DSA #CodingInterview #SoftwareEngineering #LearnToCode #Python #Java #Efficiency #AlgorithmDesign #TechLearning #DeveloperCommunity #100DaysOfCode #CodeNewbie