Scribd
Upload
6 views

Array_Leetcode.pdf

The document categorizes various algorithms based on difficulty levels: Basic, Intermediate, Advanced, and Expert. Each category includes specific problems along with the techniques recommended for solving them, such as iteration, two-pointer approach, dynamic programming, and sliding window. It emphasizes that optimal approaches may vary depending on problem constraints.

Uploaded by

mailtoviveksingh1302
Copyright
© © All Rights Reserved
Available Formats
Download as RTF, PDF, TXT or read online on Scribd
6 views

Array_Leetcode.pdf

The document categorizes various algorithms based on difficulty levels: Basic, Intermediate, Advanced, and Expert. Each category includes specific problems along with the techniques recommended for solving them, such as iteration, two-pointer approach, dynamic programming, and sliding window. It emphasizes that optimal approaches may vary depending on problem constraints.

Uploaded by

mailtoviveksingh1302
Copyright
© © All Rights Reserved
Available Formats
Download as RTF, PDF, TXT or read online on Scribd
You are on page 1/ 4

Basic Level:

Find the maximum element in an array.


Technique: Iteration through the array.

Find the minimum element in an array.


Technique: Iteration through the array.

Calculate the sum of all elements in an array.


Technique: Iteration through the array.

Reverse an array.
Technique: Two-pointer approach or iterative swapping.

Check if an array is sorted.


Technique: Iteration through the array.

Remove duplicates from a sorted array.


Technique: Two-pointer approach.

Rotate an array to the right by k steps.


Technique: Basic array manipulation.

Implement an algorithm to find the "Kth" largest element in an


array.
Technique: Sorting or use of max heap.

Implement an algorithm to find the "Kth" smallest element in an


array.
Technique: Sorting or use of min heap.

Move all zeroes to the end of the array.


Technique: Two-pointer approach.
------------------------------------------------------------------------------------------------
-------

Intermediate Level:

Implement an algorithm to rotate an NxN matrix by 90 degrees.


Technique: Transpose and reverse or use of extra space.

Implement an algorithm to find pairs in an array that sum up to a


specific target.
Technique: Two-pointer approach or hash table.
Implement an algorithm to perform a cyclic rotation in a given array.
Technique: Cyclic Sort.

Find the "celebrity" in a party using a given array of people.


Technique: Two-pointer approach.

Implement an algorithm to find the contiguous subarray with the


largest sum (Kadane's algorithm).
Technique: Dynamic Programming.

Implement an algorithm to merge two sorted arrays.


Technique: Merge Sort or Two-pointer approach.

Implement an algorithm to search for an element in a rotated sorted


array.
Technique: Modified Binary Search.

Implement an algorithm to find the intersection of two arrays.


Technique: Hashing or Two-pointer approach.

Implement an algorithm to find the majority element in an array.


Technique: Boyer-Moore Voting Algorithm.

Implement an algorithm to find the longest increasing subsequence


in an array.
Technique: Dynamic Programming.
------------------------------------------------------------------------------------------------
-------

Advanced Level:

Implement an algorithm to find the first missing positive integer in


an unsorted array.
Technique: Cyclic Sort.

Implement an algorithm to sort an array of 0s, 1s, and 2s (Dutch


National Flag problem).
Technique: Dutch National Flag algorithm or Two-pointer
approach.

Implement an algorithm to find the longest subarray with at most


two distinct elements.
Technique: Sliding Window.

Implement an algorithm to find the median of two sorted arrays.


Technique: Binary Search.

Implement an algorithm to rotate an array to the right by k steps


without using extra space.
Technique: Reverse the array in parts.

Implement an algorithm to find the shortest subarray with a sum at


least K.
Technique: Sliding Window.

Implement an algorithm to find the equilibrium index of an array.


Technique: Prefix Sum.

Implement an algorithm to find the peak element in an array.


Technique: Binary Search.

Implement an algorithm to count the number of subarrays with a


given sum.
Technique: Prefix Sum.

Implement an algorithm to find the contiguous subarray with equal


numbers of 0s and 1s.
Technique: Prefix Sum or Hashing.
------------------------------------------------------------------------------------------------
-------

Expert Level:

Implement an algorithm to efficiently find the maximum product of


three numbers in an array.
Technique: Sorting or finding max/min elements.

Implement an algorithm to find the length of the longest subarray


with sum divisible by k.
Technique: Prefix Sum and Hashing.

Implement an algorithm to find the minimum window in an array


that contains all elements of another array.
Technique: Sliding Window.

Implement an algorithm to find the longest increasing subarray with


absolute difference less than or equal to a given number.
Technique: Sliding Window.

Implement an algorithm to find the smallest subarray with sum


greater than a given value.
Technique: Sliding Window.

Implement an algorithm to find the minimum number of platforms


needed for a set of train arrivals and departures.
Technique: Merge Intervals or Sorting.

Implement an algorithm to find the maximum length subarray with


sum less than or equal to a given sum.
Technique: Sliding Window.

Implement an algorithm to find the subarray with the least average.


Technique: Sliding Window.

Implement an algorithm to efficiently rotate an NxN matrix by 90


degrees in place.
Technique: Transpose and reverse.

Implement an algorithm to find the longest subarray with at most K


distinct elements.
Technique: Sliding Window or Hashing.

These categorizations should provide you with an overview of


the types of techniques commonly used for each question at
different difficulty levels. Keep in mind that the optimal
approach might vary based on specific constraints and
requirements of the problem.
*****
*****
eee*****eee
*****
*****

You might also like