Object Oriented Programming

GATE

Data Structures

Data Structures in Python

Power BI

Data Science

Django

Data Structure and Algorithm

Python

Recursion

Arrays

Searching

Sorting

String

Linked List

Data Structures in C

Algebra

Maths

Strings

C++ Tricks

System Design

Theory of Computation

Computer Organization and Architecture

Operating System

Engineering Mathematics

Database

Digital Logic

Computer Networks

GATE 2022

Java

GeeksforGeeks School

Hashing

Competitive Programming

Problem of the Day

School

HTML

Javascript

Bootstrap

Web Development

Android

Excel

Microsoft Office

Machine Learning

Resume Builder

Miscellaneous

Gblog

TechTips

React

Advanced JavaScript

DSA Self Paced

CS-subjects

Data Structures and Algorithms

Operating Systems

C Language

DBMS

Basics of CPP

Data Structures ( Basics )

Object Oriented Design

Dynamic Programming

Data Interpretation and Logical Reasoning

Algorithms

Core Java

RESTful APIs

Spring Basics

CPP-Tricks

Basics of Java

Aptitude

GATE YT

Flutter

Application Development

Blockchain

GFG SDE Sheet

SDE Sheet

Deep Learning

Go Programming

Placement

C++ Programs

Data Visualisation

DevOps

Docker

Queue

Matrix

Trie

Stack

Graph

Tree

Magic Numbers

Divide and Conquer

React Native

React JS

Interview-Questions

Advanced Java

cloud-computing

income tax

Artificial Intelligence

Programming Languages

Computer Graphics

Cyber Security

Project Management

DSA / Placements

DA / Data Science & AI

Development

DevOps Course

All Courses

Courses

ML & Data Science

CS Subjects

Software and Tools

School Learning

Tutorials

Interview Corner

Practice DSA

GfG 160

Interview Prep

In this video, we will learn how to find the pair with the sum closest to a given target in an array. The task is to find a pair of integers in a sorted array whose sum is closest to the target. If multiple pairs have the same sum, we return the one with the maximum absolute difference between its elements. The solution explores three approaches: a naive approach using nested loops, a binary search technique for optimized performance, and a two-pointer technique that works efficiently by sorting the array first. We’ll see step-by-step how each approach works and the corresponding code implementation.Using the two-pointer technique, we efficiently find the pair with the closest sum by iterating through the sorted array with two pointers—one pointing to the beginning and the other pointing to the end of the array. This approach ensures we quickly find the pair closest to the target sum. The program outputs the closest pair, and handles cases where the array has only one element, returning an empty array in such cases. With time complexity O(n), this method offers a highly optimized solution for finding the pair sum closest to the target. For more details, please go through - <a href="https://www.geeksforgeeks.org/2-sum-pair-sum-closest-to-target/">2 Sum - Pair Sum Closest to Target</a>

2 Sum - Pair Sum Closest to Target

The task is to count triplets in a sorted array whose sum is equal to a given target. The approach uses the two-pointer technique, where the first element of the triplet is fixed, and two pointers are used to explore possible pairs. The algorithm iterates through each element and adjusts the left and right pointers based on the sum of the current triplet, either incrementing the left pointer or decrementing the right pointer to match the target. If a valid triplet is found, the frequencies of the current elements at the left and right pointers are counted to avoid duplicates and update the result accordingly.The provided C++ code demonstrates this approach, efficiently counting the number of valid triplets. It uses the two-pointer technique to traverse the array and finds triplets where the sum of the elements equals the target. The time complexity of this approach is O(n^2), as for each index, two pointers traverse the array. This method also handles duplicates by counting the frequency of elements at the left and right pointers. The program then returns the total number of triplets with a sum equal to the target. For more details, please go through - <a href="https://www.geeksforgeeks.org/3-sum-count-triplets-with-given-sum-in-sorted-array/">3 Sum - Count Triplets With Given Sum In Sorted Array</a>

Count Triplets With Given Sum In Sorted Array

The Trapping Rainwater Problem involves calculating the total amount of water that can be trapped between non-negative integers in an elevation map, where each number represents the height of a bar. The naive approach iterates through every element to compute left and right maximums for each index, with a time complexity of O(n^2). A better solution uses prefix and suffix arrays to store the maximum heights on the left and right, reducing the time complexity to O(n) and requiring O(n) space.The most efficient solution utilizes the two-pointer technique, achieving O(n) time and O(1) space. By comparing the maximum heights on the left and right, the algorithm decides whether to calculate water for the left or right pointer, updating the respective maximums and pointers accordingly. Alternate approaches, such as using a stack, offer O(n) time complexity but require O(n) space, leveraging next and previous greater elements to calculate trapped water efficiently. For more details, please go through - <a href="https://www.geeksforgeeks.org/trapping-rain-water/">Trapping Rain Water Problem – Tutorial with Illustrations</a>

Trapping Rain Water Problem

To find the subarray in an array that sums up to a given target, several approaches can be utilized. The naive approach involves iterating through all possible subarrays using nested loops and checking the cumulative sum for each. This approach is simple but has a time complexity of O(n^2). If the target sum is found, the starting and ending indices of the subarray are returned; otherwise, [−1] is returned.The expected approach leverages the sliding window technique for O(n) efficiency. Starting with an empty window, elements are added to the window until the sum equals or exceeds the target. If the sum exceeds the target, elements are removed from the start of the window until it is reduced to the target. This method is efficient for positive integers and ensures minimal computation with constant space usage. For more details, please go through - <a href="https://www.geeksforgeeks.org/find-subarray-with-given-sum/">Subarray with Given Sum</a>

Subarray with Given Sum | DSA

To find if a pair of elements in a sorted and rotated array sums up to a given target, a hashing-based approach can be used for O(n) time and space complexity. By iterating through the array, a set is used to store elements, and for each element, its complement with respect to the target is checked. If the complement exists in the set, the pair is found. Otherwise, the element is added to the set. This approach provides simplicity but requires additional space for the hash set.A more efficient approach is the two-pointer technique, which operates in O(n) time and O(1) space. First, the pivot (largest element) and the smallest element in the rotated array are identified. Pointers are initialized at the smallest and largest elements. The sum of the elements at these pointers is compared with the target, and the pointers are adjusted accordingly using modulo operations to handle the circular nature of the array. If the pair is found, the function returns true; otherwise, it returns false after the iteration completes. For more details, please go through -<a href="https://www.geeksforgeeks.org/given-a-sorted-and-rotated-array-find-if-there-is-a-pair-with-a-given-sum/"> Pair Sum in a Sorted and Rotated Array</a>

Pair Sum in a Sorted and Rotated Array

To find the minimum removals required to achieve a target sum k by removing elements from either end of an array, three approaches can be utilized. The naive approach uses recursion to explore all combinations of removals, calculating the sum for every possible path. Though straightforward, this method is highly inefficient with O(2^n) time complexity. A better approach leverages prefix arrays and hash maps to determine the longest subarray with a sum equal to total&nbsp;sum−k, reducing the problem to O(n) time complexity but requiring O(n) space for storing prefix sums.The optimized solution employs the sliding window technique, which uses two pointers to dynamically adjust a window representing the longest subarray with the desired sum. By maintaining a current sum and adjusting the window size, this method achieves O(n) time complexity and O(1) space usage. It ensures efficient computation by incrementing or decrementing the window while tracking the longest valid subarray. The result is derived as the difference between the array's size and the maximum subarray length found. For more details, please go through - <a href="https://www.geeksforgeeks.org/minimum-removals-for-target-sum/">Minimum Removals for Target Sum</a>

Minimum Removals for Target Sum

To find the count of subarrays with exactly k distinct elements, two approaches can be utilized. The naive approach involves iterating over all possible subarrays while using a hash set to track distinct elements. For each subarray, the result is incremented if the size of the hash set equals k. Though simple, this approach has a time complexity of O(n^2), which becomes impractical for large arrays.The optimized approach leverages the sliding window technique and the formula: K=atMostK−atMost(k−1). By calculating subarrays with at most k and k−1 distinct elements, their difference gives the count of subarrays with exactly k distinct elements. This method efficiently processes the array in O(n) time and O(n) space using frequency maps, making it more suitable for large datasets. For more details, please go through - <a href="https://www.geeksforgeeks.org/count-of-subarrays-having-exactly-k-distinct-elements/">Count Subarrays With Exactly K Distinct Elements</a>

Count Subarrays With Exactly K Distinct Elements

To find the count of subarrays with at most k distinct elements, two approaches can be applied. The naive approach involves exploring all possible subarrays using nested loops. For each subarray, a hash set is used to track distinct elements, and if the size of the set is less than or equal to k, the subarray is counted. Although straightforward, this approach has a time complexity of O(n^2), making it inefficient for larger arrays.The optimal approach uses the Sliding Window Technique with two pointers and a frequency map. As the window expands with the right pointer, the frequency of elements is tracked, and the left pointer shrinks the window when the distinct element count exceeds k. Each window contributes (right−left+1) subarrays to the result. This method efficiently counts subarrays in O(n) time and O(n) space, making it suitable for large datasets. For more details, please go through - <a href="https://www.geeksforgeeks.org/count-subarrays-with-at-most-k-distinct-elements/">Count Subarrays With At Most K Distinct Elements</a>

Count Subarrays With At Most K Distinct Elements

To find all unique quadruplets in an array that sum to a given target, various approaches can be employed. The naive approach involves generating all possible quadruplets using nested loops and checking their sums against the target. Though straightforward, this method has a time complexity of O(n^5), making it inefficient for larger arrays. A better approach uses hashing to identify the remaining two elements after generating pairs, ensuring distinct quadruplets while reducing time complexity to O(n^3).The optimal approach involves sorting the array and employing the two-pointer technique. By generating pairs and finding the remaining two elements using pointers, this method efficiently identifies quadruplets with a time complexity of O(n^3) and O(1) space complexity. Duplicate quadruplets are avoided by skipping repeated elements in the outer and inner loops, as well as during pointer adjustments. This ensures a streamlined and efficient solution for finding unique quadruplets. For more detail, please go through - <a href="https://www.geeksforgeeks.org/find-four-elements-that-sum-to-a-given-value-set-2/">4 Sum – All Distinct Quadruplets with given Sum in an Array</a>

4 Sum – All Distinct Quadruplets with given Sum in an Array

To find the triplet in an array whose sum is closest to a given target, two approaches can be utilized. The naive approach involves exploring all subsets of size three and calculating their sums to determine the closest to the target. Though straightforward, this method has a time complexity of O(n^3), making it less efficient for large arrays.The optimized approach employs sorting and the two-pointer technique. After sorting the array, the first element of the triplet is fixed, and two pointers are used to find the other two elements. This method ensures O(n^2) time complexity while maintaining O(1) space complexity, making it efficient for practical applications. If multiple triplets have sums equally close to the target, the maximum sum is selected. For more details, please go through - <a href="https://www.geeksforgeeks.org/find-a-triplet-in-an-array-whose-sum-is-closest-to-a-given-number/">3 Sum – Triplet Sum Closest to Target</a>

3 Sum – Triplet Sum Closest to Target

To find a triplet in an array that sums to a target, various approaches can be used. The naive approach generates all possible triplets and checks if their sum equals the target, with a time complexity of O(n^3). A better approach leverages a hash set to store potential complements while iterating, reducing the time complexity to O(n^2) and requiring O(n) space.The most efficient method uses sorting and the two-pointer technique, achieving O(n^2) time complexity with O(1) space. After sorting, the array is traversed, and for each element, two pointers identify a pair that sums to the required value. This approach ensures a quick and space-efficient solution to finding triplets with the desired sum. For more details, please go through - <a href="https://www.geeksforgeeks.org/find-a-triplet-that-sum-to-a-given-value/">3 Sum – Triplet Sum in Array</a>

3 Sum – Triplet Sum in Array

The problem of finding the maximum water that can be contained between vertical lines in an array involves identifying two lines that, together with the x-axis, form the container with the greatest area. A naive approach iterates over all pairs of lines, calculating the water area using the formula min(arr[i], arr[j]) * (j - i). While simple, this approach has a time complexity of O(n^2), making it less efficient for large arrays.An optimized solution uses the two-pointer technique to achieve O(n) time complexity. By initializing pointers at the start and end of the array, the method calculates the water area and adjusts the pointers based on the shorter line. This ensures the maximum area is computed efficiently by dynamically narrowing the width while seeking taller boundaries, leading to an optimal solution with constant space usage. For more details, please go through - <a href="https://www.geeksforgeeks.org/container-with-most-water/">Container with Most Water</a>

Container with Most Water