values

points

scores

instructions

O(n)

O(m)

O(n+m)

O(n*m)

constant

polynomial

exponential

none of the mentioned

O(n)

O(2ⁿ)

O(log n)

O(n²)

O(1)

O (n)

O (n^2)

O (n!)

O (2^n)

Greedy

Integer Programming

Dynamic Programming

Divide and Conquer

$$O\left(\lg\ n\right)$$

$$O\ \left(n\ \lg\ n\right)$$

$$O\ \left(n^2\right)$$

$$O\ \left(n\right)$$

Dijkstra's Algorithm

Bellman-Ford Algorithm

Floyd-Warshall Algorithm

Kruskal's Algorithm

n

n-1

n^2

logn

Bellman–Ford Algorithm for single source shortest path

Floyd Warshall Algorithm for all pairs shortest paths

0-1 Knapsack problem

Prim's Minimum Spanning Tree

We need an optimal solution

The solution has optimal substructure

The given problem can be reduced to the 3-SAT problem

It's faster than Greedy

Dijkstra's shortest path algorithm

Prim's algorithm

Huffman Coding

Bellmen Ford Shortest path algorithm

The division of problems and combination of subproblems

Whether the sub problems overlap or not

The way we solve the base case

The depth of recurrence

0/1 knapsack problem

Matrix chain multiplication problem

Edit distance problem

Fractional knapsack problem

O(n)

O(log n)

O(n2)

O(n log n)

Exponential Time

Linear Time

Polynomial Time

Constant Time

space complexity of algo

time complexity of algo

both a and b

none of the above

lower bound

upper bound

middle bound

none of the above

Quick Sort

Merge Sort

Selection

Counting Sort

$$O\left(n\right)$$

$$O\left(n\log_2n\right)$$

$$O\left(1\right)$$

$$O\left(n^2\right)$$

170

200

160

90

0/1 knapsack problem

Matrix chain multiplication problem

Edit distance problem

Fractional knapsack problem

A -> B -> D -> F

A -> C -> B -> E -> F

A -> F

A -> C -> E -> F

Using outdated data structures, implementing outdated algorithms, increasing unnecessary computations or iterations, and optimizing code poorly

Using random data structures, implementing random algorithms, increasing unnecessary computations or iterations, and optimizing code randomly

Using inefficient data structures, implementing inefficient algorithms, increasing unnecessary computations or iterations, and optimizing code poorly

Using efficient data structures, implementing efficient algorithms, reducing unnecessary computations or iterations, and optimizing code

Using data structures that require less memory, implementing in-place operations, applying dynamic programming techniques, utilizing compression algorithms

Using data structures that require more memory, avoiding in-place operations, ignoring dynamic programming techniques, not utilizing compression algorithms

shortest path from one source to multiple destinations

A salesman is expected to start from one source and by visiting all locations he/she should come back to the source in minimum time

longest available path in the graph

A Salesman is expected to complete the task in given deadline

single-source shortest path problem

multiple-source shortest path problem

multiple-destination shortest path problem

single-destination shortest path problem

Divide and Conquer

Dynamic Programming

Greedy Algorithm

Branch and Bound

output

Input

User Instruction

Lines

Shapes

A semiformal, English-like language with limited vocabulary that can be used to design and describe algorithms.

A formal language that is specifically used to write program.

A graph used to depict or show a step by step solution using symbols which represent a task.

A series of steps or statements that are executed in the order they are written in an algorithm.

Bubble

Merge

Insertion

The process of assigning value to a variable.

The process of taking out unnecessary details from problems.

The process of breaking down problems into smaller problems.

The process of coding a problem.

True

False

True

False

O(n)

O(2ⁿ)

O(log n)

O(n²)

O(1)