Solution

Solution

Solution

The given series is in a pattern of

1 x 2, 2 x 3, 3 x 4, 4 x 5, 5 x 6, 6 x 7, 7 x 8, 8 x 9

The correct series is: 2, 6, 12, 20, 30, 42, 56, 72.

Solution

Solution

Solution

Solution

Deduction 1 can't be taken because in the statements it's given some toys are Cows, some are Rabbits, there is nothing said about the remaining toys, it could be anything but no information is given.

Deduction 2 cannot be taken because Cows and Rabbits are separate entities.

Solution

Here the relationship is between larva form of the insect to the insect. The larva form of Butterfly is known as Caterpillar. The larva form of Cockroach is known as Nymph.

Solution

Moulding is the process of shaping liquid or pliable raw material into a frame.

Solution

To take the bull by the horns means to tackle a difficult or challenging situation bravely.

Solution

Option ‘(cursor = cursor->link())’ is not a boolean expression; it is an assignment; hence it is straight away discarded. If the cursor is pointing to the tail node or last node then there is no node after the tail node. In other words (cursor->link( ) == NULL). Hence this is the correct answer.

Solution

QMNPRO

Solution

Before deleting the parent node we should delete its children first, hence if do post-order traversal the leave nodes will be covered before the root and hence it will be useful.

Solution

result = find_missing_number([3, 4, -1, 1])

The function rearranges the array such that each positive number x appears at index x-1.

The first index where this condition isn't met gives the missing number. For the array [3, 4, -1, 1], the missing number is 2.

Solution

result = longest_unique_substring("abcabcbb")

The function uses a sliding window to track the longest substring without repeating characters. For "abcabcbb", the longest substring is "abc" with a length of 3.

Solution

result = find_median_sorted_arrays([1, 3], [2])

The function merges two sorted arrays and calculates the median. For [1, 3] and [2], the merged array is [1, 2, 3], and the median is 2.

Solution

result = search_rotated_array([4, 5, 6, 7, 0, 1, 2], 6)

The function uses binary search with additional logic to account for rotation. For the array [4, 5, 6, 7, 0, 1, 2], the target 6 is found at index 2.

Solution

df['B'] can be used to select a specific column from a Pandas DataFrame

Solution

LCS of X = bcadsce and Y = csadesg

Note: If string length is small better to go for brute force method, and start with tracing X array. We can also follow row major order or column major order.

X = bcadsce

Y = csadesg

So, the total length is 4 and the string is cade.

The optimal substructure of the LCS problem gives the recursive formula

Solution

We sort the objects based on profit/Weight Ratio in descending order and place it accordingly in the knapsack.

The objects are in sorted order according to their profits are: V,Q,X,R,P,S,T,W

Object V, Knapsack Capacity = 60-4=56, Profit=15

Object Q, Knapsack Capacity = 56-10=46, Profit=25

Object X, Knapsack Capacity = 46-8=38, Profit=18

Object R, Knapsack Capacity = 38-15=23, Profit=30

Object P, Knapsack Capacity = 23-20=3, Profit=36

Object S, Knapsack Capacity = 3-3=0, Profit=5.4

Weight of the object s is greater than Knapsack capacity. So, just add a part of object s is 3.

The profit will be 1.8*3=5.4

The Knapsack bag capacity=0

Then the total profit= 15+25+18+30+36+5.4=129.4

Solution

=Θ(n^4)

let c1=2 and c2=3

Solution

Time complexity of merge sort = O(n log n) = an log n

where c is some constant

It is given that for n = 64,

cn log n = 30

c × 64 log 64 = 30

c × 64 × 6 = 30

c = 5/64

Now, the value of n for

c n log n = 360

5/64 × n log n = 360

n log n = 360×64/5

= 72 × 64 = 2^9 × 9

So for n = 2^9, it satisfies.

So, n = 2^9 = 512

Solution

You can traverse either left or right but be in a min-heap.

Solution

(i) TRUE: A complete Binary Tree in a min heap tree if every parent node is minimum compared with its children.

(ii) FALSE: A complete Binary tree is a min heap tree if every parent node is greater than its left child and less than or equal to its right child.

(iii) TRUE: Heap sort is an inplace sorting technique because the space complexity is O(1).

(iv) FALSE: Heap sort is not stable

Solution

NULL is used if a column in a table is optional, we can insert a new record or update an existing record without adding a value to this column.

Solution

If T1, T2 and T3 are transactions with p, q and r operations respectively

Number of concurrent schedules

=(p+q+r)!/p!q!r!=(2+3+4)!/2!3!4!=9!/(2×6×4!)=(9×8×7×6×5)/(2×6)=63×20=1260

Solution

According to 2PL, if lock conversion is allowed, then upgrading of locks must be done during the expansion phase, and degrading of locks must be done in the shrinking phase.

∴ S2 is true.

Lock upgradation is not allowed in the shrinking phase therefore S1 is False.

Solution

Given relation R(MNPQT) and FD set

F₁ = {M → TN, P → QM} and

F₂ = {M → N, P → Q, P → MT, MN → T}

F₁ and F₂ are equivalent if F₁ can cover F₂ and F₂ can cover F₁

Check whether F₂ can cover F₁:

In F₁ first FD is M → TN

∴ find (M)+ in F₂

⇒ (M)+ = MNT

∴ M → TN can be covered by F₂

Second FD is P → QM

find (P)+ in F₂

(P)+ = PQMNT

∴ P → QM can be covered by F₂

∴ We can say that F₂ can cover F₁ → (1)

Check whether F₁ can cover F₂:

In F₂ first FD is M → N

∴ find (M)+ in F₁

⇒ (M)+ = MNT

∴ M → N can be covered by F₁

Second FD is P → Q

find (P)+ in F₁

(P)+ = PQMNT

∴ P → Q can be covered by F₁

Third FD is P → MT

find (P)+ in F₁

(P)+ = PQMNT

∴ P → MT can be covered by F₁

Fourth FD is MN → T

find (MN)+ in F₁

(MN)+ = MNT

∴ MN → T can be covered by F₁

∴ We can say F₁ can cover F₂ → (2)

From (1) & (2) we can say that F₁ and F₂ are equivalent.

So, (a) is correct answer.

∴ We can say that F₂ can cover F₁ → (1)

Solution

The multidimensional model organizes data into "cubes," enabling analysis across multiple dimensions like time, product, and location.

Solution

In a star schema, joining the fact table with dimension tables does not change the number of rows in the fact table. The number of rows returned will be:

1,200,000 rows

Solution

Since PCA reduces the dimensionality while retaining most of the variance, all 10 principal components would explain 100% of the variance.

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Every square matrix ‘P’ can be decomposed to symmetric and skew-symmetric parts.

Solution

Solution

Solution

Solution

Solution

Solution

Solution

The eigen values and eigen vector are complex.

Solution

Solution

Solution

Solution

Solution

Solution

Solution

Solution

IV.

As you can see for all x < there exists a y fails for N.

From III, second part can be proven True

(False AND True) is False

Solution

Informed search algorithms such as A* can guarantee finding the shortest path if the heuristic function used is both admissible (it never overestimates the cost to reach the goal) and consistent (it satisfies the triangle inequality).

Solution

For h1 and h2 to be admissible heuristics, they must never overestimate the true cost to reach the goal. The absolute difference |h1 - h2| will not overestimate the true cost, thus it is always admissible

Solution

Probabilistic reasoning accommodates uncertainty and incomplete information, enabling models to make more realistic predictions in complex environments, unlike deterministic reasoning, which requires complete certainty.

Solution

To find (P(X=1)):

[

P(X=1) = P(X=1, Y=1) + P(X=1, Y=0) = 0.2 + 0.1 = 0.3

]

Solution

Solution

Each sample is used as a test set once, and the remaining samples are used for training. Thus, models are trained.

Solution

Total variance = 5+3+2+1=11

5+3/11 =80%

Solution

The graphical structure of Bayesian networks allows for efficient inference by exploiting independence assumptions, which can significantly reduce computational complexity.

Solution

Information Gain, IG = Ebefore – Esplit

= 1 – 0.47

= 0.53

Solution

In decision trees among all the possible splits, it chooses the one that maximizes the gain not the one that minimizes it. Or it chooses not to split the leaf at all. All other three are the correct statements about the Decision tree.