/ Interview Guides / DAA MCQ

DAA MCQ

Last Updated: Jan 08, 2024

Share with :

Algorithm

The algorithm is a step-by-step process to solve any problem and is a sequence of instructions that act on some input data to produce some output in a finite number of steps. The algorithm is independent of any programming language.

Why analysis of algorithms?

For a given problem, there are many ways to design algorithms for it
Analysis of algorithms to determine which algorithm should be chosen to solve the problem.

The complexity of algorithm on performance analysis of algorithm:

Time complexity: time complexity of an algorithm is the total time required by the program to run till its completion
Space complexity: Space complexity is the total space required by an algorithm to run till its completion.

Time and space complexity depends on lots of things like hardware, OS, processes, etc.

The analysis is of two types:

Posteriori analysis: In Posteriori analysis, Algorithm is implemented and executed on certain fixed hardware and software. Then the algorithm is selected which takes the least amount of time to execute. Hence, the time used is given in time units like ms, ns, etc.
Priori analysis: In Priori analysis, The time of the algorithm is found prior to implementation. Here time is not in terms of any such time units. Instead, it represents the number of operations that are carried out while executing the algorithm.

Asymptotic notations:

Asymptotic notations are used to represent the complexity of an algorithm
With the help of asymptotic notations, we can analyze the time performance of the algorithm.

There are three types of asymptotic notations:

Theta notation
Omega notation
Big Oh Notation

Design and Analysis of Algorithms MCQ

BFS

Djikstra’s Algorithm

Prims Algorithm

Kruskal’s Algorithm

Create a free personalised study plan Create a FREE custom study plan

Get into your dream companies with expert guidance

Get into your dream companies with expert..

Real-Life Problems

Prep for Target Roles

Custom Plan Duration

Flexible Plans

Create My Plan

n - 1

n - 2

Stable

Unstable

In-place

In-partition

O(1)

O(N)

O(logN)

O(NlogN)

O(n)

O(1)

O(log2n)

O(n^2)

Learn via our Video Courses

What is the time complexity of the following code snippet in C++?

void solve() {
    string s = "scaler";
    int n = s.size();
    for(int i = 0; i < n; i++) {
        s = s + s[i];
    }
    cout << s << endl;
}

O(n)

O(n^2)

O(1)

O(log n)

O(nlog(logn)) Precomputation, O(1) for check.

O(n) Precomputation, O(1) for the check.

O(n * logn) Precomputation, O(logn) for check.

O(n) Precomputation, O(logn) for check.

Advance your career with Mock Assessments Refine your coding skills with Mock Assessments

Real-world coding challenges for top company interviews

Real-world coding challenges for top companies

Real-Life Problems

Detailed reports

O(n)

O(1)

O(logn)

O(n * logn)

If this software is used correctly

In the hardware is used correctly

If there is more than one way to solve the problem

All of the above are correct

Bubble Sort

Merge Sort

Counting Sort

Heap Sort

Overflow

Underflow

Syntax Error

Garbage Value

Z Algorithm

Rabin Karp Algorithm

KMP Algorithm

All of the above

O(n^3)

O(n^2)

O(n)

O(n^4)

Sentence Ordering

Course Scheduling

OS Deadlock Detection

All of the above

Linked list

Array

Queue

Stack

f1(n) = n^(3/2)

f2(n) = n^(logn)

f3(n) = nlogn

f4(n) = 2^n.

Bubble Sort

Selection Sort

Heap Sort

Merge Sort

As programs

As flow charts

As syntax

As pseudo-codes

Vertex Cover Problem

0/1 Knapsack Problem

Maximal Independent Set Problem

Travelling Salesman Problem

Greedy algorithm

Dynamic programming

Backtracking

Sorting

Merge Sort

Quick Sort

Bubble Sort

Selection Sort

The difference between the heights of left and right nodes cannot be more than 1.

The height of an AVL Tree always remains of the order of O(logn)

AVL Trees are a type of self-balancing Binary Search Trees.

All of the above.

O(n)

O(n * logn)

O(1)

O(logn)

O(V + E)

O(V)

O(E)

O(V * logE)

A problem

A procedure for solving a problem

A real-life mathematical problem

None of the above

Non-continuous knapsack problem

Divisible knapsack problem

0/1 knapsack problem

Continuous Knapsack Problem

Network lock

Single source shortest path

All pair shortest path

Sorting

NP problem

P class problem

NP-complete problem

N class problem

Tree structure

Complete binary tree

Binary tree

None of the above

Linear programming

Dynamic Programming

Greedy Technique

Backtracking

O(nlogn)

O(n^2)

O(n)

O(1)

pop()

peek()

push()

findTop()

Merge Sort

Quick Sort

Bubble Sort

Selection Sort

Merge Sort

Quick Sort

Bubble Sort

Selection Sort

Exactly 1

At most 1

At most 2

Depending on the graph

Merge Sort

Insertion Sort

Bubble Sort

Selection Sort

DP Problem

Greedy Algorithm

Adhoc Problem

None of the above

Storage structure

File structure

Recursive

Abstract Data Type

T(N) = 2T(N-1)+1

T(N) = 2T(N/2)+1

T(N) = 2T(N-1)+N

T(N) = 2T(N-2)+2

String

Boolean

Double

Integer

O(n)

O(1)

O(nlog2n)

O(n^2)

O(N)

O(M * N)

O(M)

O(log N)

O(n)

O(1)

O(log2n)

O(n^2)

O(n)

O(1)

O(log2n)

O(n^2)

Time and space complexity

Data and space

Processor and memory

Complexity and capacity

O(1)

O(n)

O(log2n)

O(n^2)