Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
15 views

5 Algorithm For Coding Interview

Algorithm

Uploaded by

Narendhiran “Narendhiran D” D
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
15 views

5 Algorithm For Coding Interview

Algorithm

Uploaded by

Narendhiran “Narendhiran D” D
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

1.

Top K Elements

Definition:
The "Top K Elements" problem involves finding the `k` largest or smallest elements in a
dataset. This is commonly used in scenarios where you want to quickly access the most
relevant or significant items, like the top 10 trending videos on YouTube.

Example:
Given an array `[3, 1, 5, 12, 2, 11]` and `k = 3`, the top 3 largest elements are `[12, 11, 5]`.

Explanation:
One efficient way to solve this problem is by using a Min Heap (for finding the largest
elements). You can maintain a heap of size `k` as you iterate through the array, ensuring
that only the largest `k` elements remain in the heap.

Diagram:
Imagine a Min Heap where each element is inserted. The smallest element at the root of
the heap is removed when the size exceeds `k`, ensuring that only the largest `k`
elements remain.

5
/\
12 11 (Min Heap with Top 3 Largest Elements)

2. Sliding Window

Definition:
The Sliding Window technique is used to solve problems involving a contiguous block of
elements in an array or string. It involves moving a window (of fixed size or dynamic)
across the data to process or calculate something efficiently.

Example:
Given an array `[1, 3, -1, -3, 5, 3, 6, 7]` and window size `k = 3`, find the maximum for each
sliding window position.

Explanation:
You move the window from the start to the end of the array, maintaining the maximum (or
any required computation) for the current window. This can be done using a deque to
keep track of maximums, leading to an O(n) solution.
Diagram:

Array: [1, 3, -1, -3, 5, 3, 6, 7]


Windows: [1, 3, -1] -> [3, -1, -3] -> [-1, -3, 5] -> ...
Max Values: 3 3 5 ...

3. Backtracking

Definition:
Backtracking is a recursive technique for solving problems incrementally, where you try
to build a solution piece by piece, and backtrack as soon as you realize that the current
piece cannot lead to a valid solution.

Example:
Finding all possible solutions to the N-Queens problem, where N queens are placed on
an NxN chessboard such that no two queens threaten each other.

Explanation:
Backtracking involves placing a queen in one column at a time and recursively trying to
solve the problem for the next column. If placing a queen in a particular position leads to
a conflict, you backtrack and try the next position.

Diagram:

N-Queens on 4x4 Board:


Q... ...Q
..Q. .Q..
.Q.. Q...
...Q ..Q.

(Backtrack when no valid moves are available)


4. Dynamic Programming (DP)

Definition:
Dynamic Programming is an optimization technique used to solve problems by breaking
them down into simpler subproblems, solving each subproblem once, and storing their
solutions to avoid redundant computations.

Example:
Finding the minimum number of coins needed to make a certain amount, given different
coin denominations.

Explanation:
The problem is broken down into smaller problems where you calculate the minimum
coins needed for smaller amounts and build up to the required amount using these
solutions.

Diagram:

Example for amount = 11 with coins [1, 5, 6, 8]:

DP Table:
[0, 1, 2, 3, 1, 2, 1, 2, 1, 2, 2, 3] (Each index represents the minimum coins for that amount)

Solution:
11 -> 6 + 5 -> Coin 6, Coin 5

5. Breadth-First Search (BFS)

Definition:
BFS is a graph traversal algorithm that explores all nodes at the present depth level
before moving on to nodes at the next depth level. It uses a queue to keep track of the
nodes to be explored.

Example:
Traversing a tree level by level or finding the shortest path in an unweighted graph.

Explanation:
Starting from the root node, you explore all its neighbors before moving to their
neighbors, ensuring that you visit nodes in a breadth-first manner.
Diagram:

Graph:
1
/\
2 3
/| |\
45 67

BFS Traversal:
1 -> 2, 3 -> 4, 5, 6, 7 (Level by level)

6. Depth-First Search (DFS)

Definition:
DFS is a graph traversal algorithm that explores as far as possible along a branch before
backtracking. It uses a stack (either explicitly or via recursion) to keep track of the path.

Example:
Traversing a tree or graph in depth-first order, or solving maze problems.

Explanation:
Starting from the root node, DFS explores each branch to its deepest point before
backtracking to explore the next branch. It can be implemented either iteratively using a
stack or recursively.

Diagram:

Graph:
1
/\
2 3
/| |\
45 67

DFS Traversal:
1 -> 2 -> 4 -> Backtrack -> 5 -> Backtrack -> 3 -> 6 -> Backtrack -> 7

You might also like