Practice Test: Computer Science Engineering (CSE) - 1 - Computer Science Engineering (CSE) MCQ

While X runs 1000 metre, Y runs (1000-52) = 948 metre and Z runs (1000-83) = 917 metre
i.e., when Y runs 948 metre, Z runs 917 metre

⇒ When Y runs 1000 metre, Z runs 917/948 x 1000 = 967.30 metre

i.e., Y can give Z (1000-967.30) = 32.7 metre

Let the age of youngest brother be x Then, x + (x + 3) + (x + 6) + (x + 9) + (x + 12) = 100 => 5x = 70 => x = 14 Therefore, age of 2nd most elder brother = 14 + 9 = 23.

In 1 hour, ½ + ¼ + ⅕ +⅙ + ⅛ = 149/120 = 1.24 is the work done. Hence, total time to complete the work would be = 1/1.24 = 0.80 hours

Let length of park = L and breadth of park = B Original Area = BL m2 New Length = 120L/100 = 6L/5 New Breadth = 120B/100 = 6B/5 New Area = 36LB/25 m2 so, Change in area = New – Original = 11LB/25 m2 % increase = Change / original * 100 = 44%

Required sum = 3!(3 + 4 + 5 + 6) = 108 [If we fix 3 of the unit place, other three digits can be arranged in ways similarly for 4, 5, 6.]

The state’s duty is to ensure the safety of its citizen.

Pernicious means harmful effect.

The path of glory lead but to the grave 

The appropriate speech is:

Gardner forbade me to pluck the flowers.

I haven’t had a call from the office about the meeting since last Monday.

Insertion sort is directly proportional to number of inversions present in the list.

Consider the while loop condition => i + 1 ? --i : j++ In first iteration : i + 1 = 3 (true) So ternary operator will return --i i.e. 1, condition part is 1 means true so while condition is true. Hence printf statement will print 1 In second iteration : i + 1 =2 (true) So ternary operator will return --i i.e 0, condition part is 0 means false so while condition is false. Hence program control will come out of the while loop.

In this structure, Node (C) (B) and (A) not having difference between left subtree and right subtree -1, 0, 1. Therefore 3 nodes become unbalanced.

Important observation is Break statement terminates the innermost loop. So “*” is printed only n times.

Statement 1 is true as in the nth iteration of Bellman Ford, if the length of the path of any node reachable from the source is decreased, that means we are having negative edge weight cycle in the graph. Statement 2 is false as no algorithm can give give correct answer if the Graph is having negative edge weight cycle.

if f(n) = n and g(n) = 2n. then f(n) = O(g(n)) here, 2^n = O(2^(2n)) = O(4^n), but not vice versa. Hence, I is true. II is false. -------------- Now, if f(n) = 2n and g(n) = n then also f(n) = O(g(n)) because we can ignore constant but, 2^(2n) != O(2^n), hence I is false, but II is true. In both of the above cases, f(n) = O(g(n)). But both the cases are counter of each other. Hence both I and II are wrong.

Number of simple graphs possible with n labeled vertices is 2^(n(n-1)/2). Number of simple graphs possible with n unlabeled vertices is n+1. Number of spanning tree possible with n vertices complete graph n^(n-2) X =8 Y = 4 X-Y=4 Therefore required answer is 4^2=16.

Statement S1 : consider the graph

Starting with A (source vertex ) we will get 2 edges Starting with B will get only 1 edge Starting with C we will get no edge Therefore DFS on directed graph may not give same number of edges. Statement S2 : Back edges are those edges (u,v) connecting a vertex u to an ancestor u in a depth-first tree. Self-loops are considered to be back edges. Back edges describe descendant-to-ancestor relations, as they lead from “high” to “low” nodes. Suppose that there is a back edge (u, v). Then vertex v is an ancestor of vertex u in the depth-first forest. There is thus a path from v to u in G, and the back edge (u,v) completes a cycle. Removing the back edge will break the cycle. Therefore removing all the back edges will make the graph acyclic. So the statement is true.

Head and tail pointers in singly link list will make the insertion and deletion in O(1) time complexity if we are accessing the elements in FIFO order. In doubly link list since only head pointer is given then for insertion we have to traverse the complete link list so insertion will be O(n) so not appropriate. In binary tree we have only a pointer to the root. Insertion and deletion in binary tree will be O(log n) so not appropriate. In hash table accessing the data in FIFO order will not be possible.

Follow these steps to print bac.
1) POP element ‘a’ from stack A, push ‘a’ to Stack B.
2) POP element ‘b’ from A, print it.
3) POP element ‘a’ from B, and print it.
4) POP element ‘c’ from A, and print it. Now, perumtation bac has been printed. Similarly, we can print bca and abc, but can’t print cab.

permutations which start with D:
to print D first , all a,b,c must be pushed on to stack before popping D and the only arrangement possible = D C B A
permutations start with C:
you need to push a and b from stack A to stack B , now print C
content of stack B= b a (from top to bottom)
content of stack A = d
permutations possible = 3!/2! = 3 = they are c d b a, c b d a, c b a d --> 3 permutations here
permutations starting with b :
to print b first, a will be pushed onto stack B
content of stack B= a
content of stack A= c d
you can bring these out in (3! -1) as (d a c) is not possible--> 5 possible
permutations starting with a:
fix ab
a b _ _
in this a b c d or a b dc
fix ac
a c _ _
a c b d or a c d b
fix ad
a d _ _
a d c b
total 5
total = 1+3+5+5= 14

Probability of one particular slot = 1/m ( because total m slots) Probability that a value should not go in one particular slot = 1 – (1/m) For n values (keys) probability = [1 – (1/m)]ⁿ

Since (X,Y) is a point on circle, the general form of the point is X = 2 + 5*cost, y = 3 + 5*sint We need to maximise the value of x+y+k x+y+k = 2 + 5*cost + 3 + 5*sint + k = (5+k) + 5*(cost+sint) Here, k is a constant. The maximum value of c + acost + bsint is equals to c + sqrt (a*a +b*b). Maximum value of (5+k) + 5*(cost+sint) (5+k) + 5*sqrt(2) The result is (5+k) + 5*sqrt(2).

“⟺” mean equal. ifA⟺B means A is equal to B.
Option (a); (p→(q⋁r) )⟺(~p⋁(q⋁r) ) ⟺((~p⋁q)⋁r) ⟺(~(p⋀~q)⋁r) [∵De morgan’s law] ⟺(p⋀~q)→r ∴(p→(q⋁r) )⟺((p⋀~q)→r)

Option (b); (p→r)⋀(q→r)⟺(~p⋁r)⋀(~q⋁r) ⟺(~p⋀~q)⋁r [∵ De morgan’s law] ⟺~(p⋁q)⋁r ⟺(p⋁q)→r ∴(p→r)⋀(q→r)⟺(p⋁q)→r

Option (c): p→(q→r)⟺~p⋁(q→r) ⟺ ~p⋁(~q⋁r) ⟺~q⋁(~p⋁r) ⟺~q⋁(p→r) ⟺q→(p→r)

Option (d): (p↔q)⟺(p→q)⋀(q→p) ⟺(~p⋁q)⋀(~q⋁p) ⟺(~p⋁q)⋀(p⋁~q) ⟺(~p⋀~q)⋁(p⋀q) ⟺ ~(p⋁q)⋁(p⋀q) (p↔q)⟺(p⋁q)⋁(p⋀q) is wrong.

Clearly S1 is wrong because in distributive lattice a element may have zero complement. Rest other statements are properties of the corresponding lattices.