Competitive Programming Prefix Sum Hashing Problem

🚀𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 | 𝐅𝐢𝐧𝐝 𝐭𝐡𝐞 𝐃𝐮𝐩𝐥𝐢𝐜𝐚𝐭𝐞 𝐍𝐮𝐦𝐛𝐞𝐫 𝐩𝐫𝐨𝐛𝐥𝐞𝐦 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭 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

🚀 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 + 𝐅𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐂𝐨𝐮𝐧𝐭 = 𝐏𝐨𝐰𝐞𝐫𝐟𝐮𝐥 𝐒𝐭𝐫𝐢𝐧𝐠 𝐏𝐫𝐨𝐜𝐞𝐬𝐬𝐢𝐧𝐠 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 𝐢𝐧 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: 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 arr[] and an integer target, determine whether there exists a triplet in the array such that: arr[i] + arr[j] + arr[k] = target Return: true → if such a triplet exists false → otherwise 💡 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 ✅ Sorting + Two Pointer Technique The idea is: Sort the array. Fix one element arr[i]. Use two pointers (left and right) on the remaining subarray. Compare the current sum with the target: If sum matches → triplet found. If sum is smaller → move left pointer. If sum is larger → move right pointer. This approach avoids unnecessary computations and works efficiently for large constraints. ⚡ Time Complexity Sorting: O(n log n) Two Pointer Traversal: O(n²) Overall Complexity: O(n²) 📦 Space Complexity O(1) (excluding sorting space) 📘 Example Input: arr[] = [1, 4, 45, 6, 10, 8] target = 13 Output: true Explanation: Triplet {1, 4, 8} gives the required sum 13. 🔗 Optimal Approach Code https://lnkd.in/gF3Nk6Mj ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “All” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- #CompetitiveProgramming #DSA #CPP #Coding #LeetCode #ProblemSolving #Algorithms #DataStructures #Coding #Programmer

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 + 𝐅𝐫𝐞𝐪𝐮𝐞𝐧𝐜𝐲 𝐌𝐚𝐩 | 𝐂𝐨𝐮𝐧𝐭 𝐍𝐮𝐦𝐛𝐞𝐫 𝐨𝐟 𝐏𝐚𝐢𝐫𝐬 𝐖𝐢𝐭𝐡 𝐀𝐛𝐬𝐨𝐥𝐮𝐭𝐞 𝐃𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐜𝐞 𝐊 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭:  Count Number of Pairs With Absolute Difference K Given an integer array nums and an integer k, we need to count the number of pairs (i, j) such that: i < j |nums[i] - nums[j]| == k At first glance, a brute-force solution using nested loops seems straightforward, but it results in O(n²) time complexity, but it is not efficient for larger constraints. 💡 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 𝐔𝐬𝐢𝐧𝐠 𝐇𝐚𝐬𝐡𝐢𝐧𝐠 To optimize the solution, I used a Hash Map / Frequency Map approach. ✅ Key Idea: While traversing the array: Check whether (currentElement - k) already exists. Check whether (currentElement + k) already exists. Add their frequencies to the answer. Store/update the current element frequency in the hash map. ⚡ Time Complexity O(n) — Single traversal using hashing. ⚡ Space Complexity O(n) — For storing frequencies in the hash map. 🧠 Concepts Used ✔️ Hashing ✔️ Frequency Map ✔️ Array Traversal ✔️ Optimization from Brute Force to Optimal 🔗 Optimal Approach Code Link 👉 https://lnkd.in/gBe4ubet ------- 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 #Programming #Coding #ProblemSolving #DataStructures #Algorithms #FrequencyMap #SoftwareEngineering

🚀 𝐂𝐨𝐦𝐩𝐞𝐭𝐢𝐭𝐢𝐯𝐞 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 | 𝐋𝐢𝐧𝐞𝐚𝐫 𝐒𝐞𝐚𝐫𝐜𝐡 + 𝐆𝐫𝐞𝐞𝐝𝐲 𝐓𝐡𝐢𝐧𝐤𝐢𝐧𝐠 | 𝐌𝐢𝐧𝐢𝐦𝐮𝐦 𝐂𝐚𝐩𝐚𝐜𝐢𝐭𝐲 𝐁𝐨𝐱 📦 📌 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐭𝐚𝐭𝐞𝐦𝐞𝐧𝐭: You are given: An integer array capacity[] An integer itemSize Each box can store the item only if: capacity[i] >= itemSize We need to return: ✅ The index of the box with the minimum valid capacity ✅ If multiple boxes have the same minimum capacity, return the smallest index ✅ Return -1 if no valid box exists 🧠 𝐊𝐞𝐲 𝐎𝐛𝐬𝐞𝐫𝐯𝐚𝐭𝐢𝐨𝐧𝐬 🔹 We only care about boxes whose capacity is greater than or equal to itemSize 🔹 Among all valid boxes, we need the one with: Minimum capacity Smallest index in case of ties 🔹 This can be solved efficiently using a single traversal ⚡ 𝐎𝐩𝐭𝐢𝐦𝐚𝐥 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Steps: 1️⃣ Traverse the array 2️⃣ Check whether the current box can store the item 3️⃣ Maintain: Minimum valid capacity found so far Corresponding index 4️⃣ Update answer whenever a smaller valid capacity is found ⏱️ Complexity Analysis ✅ Time Complexity: O(N) ✅ Space Complexity: O(1) 🔗 Optimal Approach Code https://lnkd.in/gGSb83Hh ------- I post DSA problems (1x daily) Hit the 🔔 icon → Select “𝐀𝐥𝐥” to get the link first Follow ( Krupesh Patil ) 💙 Like | ♻️ Repost | 💬 Comment ------- #CompetitiveProgramming #CPP #DataStructures #Algorithms #Coding #ProblemSolving #DSA #Programming #CodeNewbie #Developer

🌳 Vertical Sum in a Binary Tree — Mapping Nodes by Horizontal Distance! Today’s problem was a beautiful combination of trees + mapping concepts 👀 Instead of traversing level by level, we group nodes based on their vertical alignment. 🔥 Day 104/60 📌 Today's Problem: Vertical Sum in a Binary Tree 💡 Approach: ✔️ Use DFS traversal with a concept called:   👉 Horizontal Distance (HD) ✔️ Rules:   • Root node → "HD = 0"   • Left child → "HD - 1"   • Right child → "HD + 1" ✔️ Store vertical sums using a map: 👉 "map<HD, Sum>" ✔️ During traversal:   👉 Add current node value to its corresponding vertical line ✔️ Finally traverse the map in sorted order to get answers 💯 ✔️ Clean recursive traversal with ordered mapping 🔥 ⚡ Complexity: ⏱️ Time: O(n log n) 📦 Space: O(n) 💭 Key Learning: 👉 Trees can also be visualized using coordinates/distances 👉 Maps help maintain ordered traversal automatically 👉 DFS + extra state is a very common tree pattern 👀 🤔 Let’s Make This Interactive: For Tree: 1 / \ 2 3 / \ \ 4 5 6 👉 What will be the vertical sum for "HD = 0" ? 👇 Consistency Still Unbreakable ✔ 104 Days and Counting 🔥 Tree Intuition Becoming Stronger Daily 📈🚀 #geekstreak60 #npci #tcsnqtwithgfg #geeksforgeeks #DSA #coding #programming #algorithms #datastructures #cpp #interviewprep #problemSolving #softwaredeveloper #tech #learning #consistency #growthmindset #developers #trees #dfs #binarytree

🌳 Subtree Checking Using Recursion & Tree Matching! Today’s problem was a beautiful combination of recursion and tree comparison logic. Instead of generating traversals, we directly matched trees node by node 💯 🔥 Day 83/60 📌 Today's Problem: Check if One Tree is a Subtree of Another 💡 Approach: ✔️ First, create a helper function to check if two trees are identical ✔️ Conditions for identical trees:   👉 Both nodes are NULL → true   👉 One NULL and one not NULL → false   👉 Current node values must match   👉 Left subtrees must match   👉 Right subtrees must match ✔️ Then traverse the main tree ✔️ At every node:   👉 Check if subtree starts from here ✔️ If not:   👉 Search in left subtree   👉 Search in right subtree ✔️ Elegant recursive decomposition 🌳 ⚡ Complexity: ⏱️ Time: O(n × m) in worst case 📦 Space: O(h) recursive stack space 💭 Key Learning: 👉 Many tree problems become easier with helper functions 👉 Break the problem into:   • “Check current”   • “Search recursively” 👉 Recursion makes hierarchical structures intuitive 🤔 Let’s Make This Interactive: If both trees are exactly the same, what will the function return? 👀 And what happens when subtree is NULL? Consistency Unstoppable ✔ Tree Concepts Becoming Stronger 🌳 Recursive Thinking Improving Daily 🔁📈 #geekstreak60 #npci #tcsnqtwithgfg #geeksforgeeks #DSA #coding #programming #algorithms #datastructures #cpp #interviewprep #problemSolving #softwaredeveloper #tech #learning #consistency #growthmindset #developers #trees #recursion

🌳 Size of Binary Tree — Classic Recursion Insight! A simple problem on the surface, but a great reminder of how powerful recursion can be when working with trees. 🔥 Day 82/60 📌 Today's Problem: Size of Binary Tree 💡 Approach: ✔️ Use recursion to traverse the tree ✔️ Base Case:   👉 If node is NULL → return 0 ✔️ For every node:   👉 Count current node = 1   👉 Add size of left subtree   👉 Add size of right subtree ✔️ Final Formula: 👉 Size = 1 + Left + Right ✔️ Clean and intuitive tree traversal 💯 ⚡ Complexity: ⏱️ Time: O(n) → Visit each node once 📦 Space: O(h) → Recursive stack (height of tree) 💭 Key Learning: 👉 Tree problems often break into smaller subtrees 👉 Think in terms of divide & combine 👉 Recursion mirrors the structure of trees perfectly 🤔 Let’s Make This Interactive: If a binary tree has 7 nodes, what will the function return? 👉 Too easy? Then think: what if the tree is skewed? 👀 Consistency Still Going Strong ✔ Recursion Becoming Natural 🔁 Tree Thinking Getting Better 🌳📈 #geekstreak60 #npci #tcsnqtwithgfg #geeksforgeeks #DSA #coding #programming #algorithms #datastructures #cpp #interviewprep #problemSolving #softwaredeveloper #tech #learning #consistency #growthmindset #developers #trees #recursion

Most people think Dynamic Programming is a “hard algorithm topic.” But the real idea behind DP is surprisingly simple: Solve smaller problems once. Remember the answers. Reuse them instead of solving again. That’s it. Dynamic Programming is essentially: Breaking a complex problem into reusable subproblems Avoiding repeated work Building larger solutions from smaller solved states The biggest mindset shift for me was this: ❌ Brute Force mindset: “Let me solve this big problem directly.” ✅ DP mindset: “Let me solve ALL smaller versions first, then combine them.” Once you start seeing: overlapping subproblems repeated recursion branches reusable states …you start recognizing DP everywhere: route optimization scheduling systems stock trading logic caching layers AI planning path finding resource allocation One of the best “tests” for DP: 👉 Draw the recursion tree. If the same subproblem appears multiple times, DP is probably the answer. The fascinating part is that DP is less about coding tricks and more about: state design information compression decision modeling remembering history efficiently In many ways, DP teaches a broader engineering lesson: “Efficient systems don’t recompute reality from scratch.” That applies to software, distributed systems, transportation networks, and even human decision-making. Keep calm and DP on 🚀 #DynamicProgramming #Algorithms #DSA #SoftwareEngineering #Programming #CodingInterview #SystemDesign #ComputerScience #Tech #Learning

🚀 Built an Autonomous Multi-Agent for doing EDA on CSV file using vLLM and Gemma 4 26B. ⚙️ Tech Stack • vLLM • Gemma 4 26B A4B • Python 3.12 • T4×2 GPUs 🔹 Supported Operations • Missing Value Handling • Outlier Detection • Univariate Analysis • Bivariate Analysis • Multivariate Analysis • Feature Selection • Feature Transformation • Ensemble Exploration (Bagging, Boosting, Stacking) • Hyperparameter Tuning (Grid, Random, Bayesian Search) • New Attribute Addition • Row Deletion • Attribute Deletion The system can autonomously analyze CSV datasets through: • staged reasoning 🧠 • dynamic Python code generation ⌨️ • safe subprocess execution 🛡️ • parallel agent workflows ⚡ • structured insight generation 📊 🔹 Supports regression, classification, clustering, and association analysis 🔹 Generates 40–80 actionable EDA insights per dataset 🔹 Designed with a modular multi-agent architecture 🔹 Uses /dev/shm based safe execution to protect original datasets 🙏 Special thanks to Rahul Sharma for technical guidance and support throughout the project. #AI #LLM #MachineLearning #DataScience #MultiAgentSystems #EDA #Python #GenerativeAI #vLLM