UGC NET Paper 2 Computer Science Mock Test - 8 - UGC NET MCQ

This function is automatically called when no catch handler can be found for a thrown exception, or for some other exceptional circumstance that makes impossible to continue the exception handling process.

Dependency Preserving Decomposition:

Decomposition of R into R₁ and R₂ is a dependency preserving decomposition if closure of functional dependencies after decomposition is same as closure of of FDs before decomposition.

A simple way is to just check whether we can derive all the original FDs from the FDs present after decomposition.

In the above question R(A, B, C, D) is decomposed into R₁ (A, B) and R₂(C, D) and there are only two FDs A -> B and C -> D. So, the decomposition is dependency preserving

Lossless-Join Decomposition:

Decomposition of R into R₁ and R₂ is a lossless-join decomposition if at least one of the following functional dependencies are in F+ (Closure of functional dependencies)

R₁ ∩ R₂ → R₁

OR

R₁ ∩ R₂ → R₂

In the above question R(A, B, C, D) is decomposed into R₁(A, B) and R₂(C, D), and R₁ ∩ R₂ is empty. So, the decomposition is not lossless.

F₀₀(2)=  =110

F₀₀(3)=  = 1200

So, Option (A) is correct.

Key Points
L = {anbmcn+m | m ≥ 0, n ≥ 0}

L₁ is the language when n = 0, m = 0 = {λ}

L₂ is the language when only n = 0 = { bc, bbcc , bbbccc,..}

L₃ is the language when only m = 0 = { ac, aacc, aaaccc,..}

L₄ is the language when n ! = 0 and m ! = 0 = { abcc, aabbcccc, aaabbbcccccc,...}

L= {L₁U L₂ U L₃ U L₄}

L accepts the strings like, {{λ, bc, bbcc, bbbccc, ac, aacc, aaaccc, abcc, aabbcccc, aaabbbcccccc,...}

Option 1: S → aSc | S1 ; S1 → bS1c | λ

False, The above doesn't accept the strings of L3 is the language when only m=0= { ac, aacc, aaaccc,..}

Option 2: S → aSc | S1 | λ ; S1 → bS1c

False, The above doesn't accept the strings of L2 is the language when only n = 0 = { bc, bbcc, bbbccc,..}

Option 3: S → aSc | S1 | λ ; S1 → bS1c | λ

True, it can generate all the strings generated by the language L.

Option 4: S → aSc | λ ; S1 → bS1c | λ

False, state S1 is unreachable in it. And option 4 can't generate strings like { bc, bbcc, bbbccc, abcc, aabbcccc, aaabbbcccccc,... }

Hence the correct answer is S → aSc | S1 | λ; S1 → bS1c | λ.

The correct answer is option 1.

Key Points

The regular expressions accept the strings with a minimum length is "aba". It accepts the strings {aba ,aaba ,baba ,abbaba,... }. And also we can say the regular grammar which accepts every string with ending with "aba".

Option 1: (a + b)*aba

True, It accepts all string which generated by above automata.

Option 2: aba(a + b)*aba

False, It can not accept the string "aba" and this grammar minimum string is "abaaba".

Option 3: (a + b)aba(b + a)*

False, It accepts the string "aabab" and "aabab" is not accepted by the above automata.

Option 4: aba(a + b)*

False, It accepts the string "aabab" and "aabab" is not accepted by the above automata.

Option 5: (ab)*aba

False, It can not accept the string "baba" and "baba" is accepted by the above automata.

The correct answer is option 1.

Key Points

• The degree to which the elements within a module belong together is referred to as cohesion.
• The degree of interdependence between software modules is referred to as coupling. A measure of how closely two routines or modules are linked.

Coupling between M1 and M2 =

The cohesion of M1 =

After moving method m to M2, we get the following graph as

Hence the correct answer is There is no change.

The correct answer is option 4.

Concept:

Statement 1: Depth First Search uses the stack data structure.

True, When a dead end occurs in any iteration, the Depth First Search (DFS) method traverses a graph in a depth ward motion and utilizes a stack to remember to acquire the next vertex to start a search.

Statement 2: Breadth First Search uses the queue data structure.

True, When a dead end occurs during any iteration, the Breadth First Search (BFS) algorithm uses a queue to keep track of where to get the next vertex to begin a search.

Statement 3: Depth First Search uses a backtracking technique.

True, Depth First Search uses a backtracking technique. Backtracking is a method for problem-solving based on an algorithm. It constructs a solution step by step, increasing values over time, and then employs recursive calling to discover the answer. Based on the limitations provided to answer the problem, it eliminates solutions that don't lead to the solution.

Statement 4: Breadth-first search uses the Branch-and-Bound traverse technique.

True, Breadth-first search uses the Branch-and-Bound traverse technique. Branch and bound is an algorithm design paradigm that is generally used for solving combinatorial optimization problems.

Hence the correct answer is only 1, 2, 3, and 4.

Three address code: In this a type of intermediate code which is easy to generate and can be easily converted to machine code uses at most three addresses and one operator to represent an expression and the value computed at each instruction is stored in temporary variable generated by compiler.

Calculation:

The correct answer is option 4.

Key Points

S1: Regular languages are a subset of the set of languages accepted by TMs which do not write anything on the tape.

True, Regular languages are a subset of the set of languages accepted by TMs Which do not write anything on the tape. The subset of regular languages is not closed under regular grammar.

S2: The set of languages accepted by halting TMs with a bidirectional infinite tape is a proper superset of decidable language.

False, The set of languages accepted by halting TMs with a bidirectional infinite tape is a proper superset of decidable language. Halting Turing machine accepts recursive languages. Proper superset of recursive languages is an undecidable language.

S3: Every decidable language can be accepted by a DFA with a priority queue.

True, Every decidable language can be accepted by a DFA with a priority queue.

Essential prime implicant means implicant which can not be replaced by any another implicant.

Key Points

In RSA encryption, the ciphertext (C) is computed using the public key (e, n) and the original message (M) as follows:

Here, e is the public exponent, and n is the product of the two prime numbers (p and q) used to generate the keys.

Given that the participant's public key is e = 11, and the product of the two prime numbers n = pq = 5 times 13 = 65, and the ciphertext C = 8, we can set up the equation:

Now, we need to find the value of M.

To solve this equation, we can use the Chinese Remainder Theorem or simply try different values of M until we find one that satisfies the congruence.

Let's check each option:

1)
2)
3)
4)

Therefore, the correct answer is 4) 57.

Here, longest common subsequence is PQPS.

The correct answer is 2 KB.

The steps to find the page table size are:

Concept Used:

P(A) represents the Powerset of A i.e., the set of all subsets of A.

|P(A)| = 2^|A|

A - B = {x| x ∈ A and x ∉ B}

Calculation:

|A| = 50, |A ∩ B| = 45 and |B| = 48

⇒ A and B have 45 elements in common.

Hence, A - B must have only 5 elements i.e., |A - B| = 5

Hence, |P(A − B)| = 2^{|(A − B)|} = 2⁵

Calculation:

(A ∩ B' ∩ C')' = A' U B U C

∴ (A U B U C) ∩ (A ∩ B' ∩ C')'

= (A U B U C) ∩ (A' U B U C)

= (A ∩ A') U (B U C) [By distributivity of U over ∩]

= ϕ U (B U C) = B U C

Hence,

(A U B U C) ∩ (A ∩ B' ∩ C')' U C'

⇒ (B U C) ∩ C' = (B ∩ C') U (C ∩ C') = B ∩ C'

∴ Correct answer is option 1.

Statement 1: Greedy technique solves the problem correctly and always provides an optimized solution to the problem.

This Statement is False. Since the Greedy technique does not always solve a problem correctly.

Statement 2: Bellman ford, Floyd-warshal, and Prim’s algorithms use the Dynamic Programming technique to solve the Path problems.

This Statement is also False Since Prim's algorithm does not use the Dynamic Programming technique.

Prim's algorithm is a greedy algorithm that finds a minimum spanning tree for a weighted undirected graph.

• COCOMO prescribes a three stages process for project estimation
• In the first stage, an initial estimate is arrived at; Over the next two stages, the initial estimate is refined to arrive at a more accurate estimate
• COCOMO uses both single and multivariable estimation models at different stages of estimation
• The three stages of COCOMO estimation technique are basic COCOMO, intermediate COCOMO, and complete COCOMO

Note:

COCOMO stands for Constructive Cost Estimation Model.

for a)

for b)

So, 2 3 5 4 1

for c)

so, 4 3 5 2 1

for d)

So, the permutation 3, 4, 1, 5, 2 is invalid

A procedural abstraction is a named sequence of instructions that has a specific and limited function.

A data abstraction is a named collection of data that describes a data object.

Concept:

Fork system call is used to create a new process also called as child processes.

Formula:

With n fork system calls, number of child processes created are 2ⁿ – 1.

Printf statement will be executed 2ⁿ times with n system calls.

Explanation:

Here there are 3 fork system calls in the given program.

So, 2³ times printf statement will be executed.

Given:

abelian groups of order 108

Concept:

the number of abelian groups of order n is p(n) ( no of partition of n )

Calculation:

108 = 2²⋅3³.

Now, p(2) = 2 because 2 = 2 and 2 = 1 + 1,

whereas p(3) = 3 because 3 = 3, 3 = 1 + 2, and 3 = 1 + 1 + 1.

Hence, the number of abelian groups of order 108 up to isomorphism is p(2) × p(3) = 2 × 3 = 6.

Hence the option (3) is correct.

I. If two regular expressions denote the same language, then both are said to be equivalent.

Given statement is true. There can be more than one regular expression for a language. But if two regular expressions denote same language then it means both are equivalent. Example: (a*b*)* and (a + b)* both represent same language. They both are equivalent.

II. The regular expression a* denotes the set of all strings of one or more a’s

This statement is incorrect. The regular expression a* generates the strings of type {ϵ, a, aa, aaa, aaaa,….} i.e. 0 or more occurrences of a. To generate set of all strings of one or more a’s , regular expression used is : a⁺.

Minimum number of nodes of height h, N(h) = N(h-1) + N(h-2) + 1

Where, N(0) = 1 and N(1) = 2

So,

N(2) = N(1) + N(0) + 1 = 2 + 1 + 1 = 4,

N(3) = N(2) + N(1) + 1 = 4 + 2 + 1 = 7,

N(4) = N(3) + N(2) + 1 = 7 + 4 + 1 = 12,

N(5) = N(4) + N(3) + 1 = 12 + 7 + 1 = 20.

Therefore, to find the minimum number of nodes of an AVL tree of height 5, the values of N(2), N(3) and N(4) must be found. So, the values of 3 nodes have to be found.

Push 6 into the stack, Push 2 into the stack, Push 3 into the stack.

Now we encounter an operator. So, pop top 2 elements and apply the operator between them, it should be like:

( second_pop operator first_pop ) ==> 2 * 3 but not 3 * 2

result is 6 ==> push into the stack.

Now we encounter an operator. So, pop top 2 elements and apply the operator between them, it should be like:

( second_pop operator first_pop ) ==> 6 / 6

result is 1 ==> push into the stack.

Push 4 into the stack, Push 2 into the stack.

Now we encounter an operator. So, pop top 2 elements and apply the operator between them, it should be like:

( second_pop operator first_pop ) ==> 4 * 2

result is 8 ==> push into the stack.

question is asking about till evaluate up to 2nd * evaluated, ==> our task complete.

The top of the two elements of our stacks is 8,1 in the order from top to bottom.

The best way to solve game playing problem is Heuristic approach. You use a Heuristic approach, as it will find out brute force computation, looking at hundreds of thousands of positions. e.g Chess competition between Human and AI-based Computers. A heuristic, or a heuristic technique, is an approach to problem-solving that uses a practical method or various shortcuts in order to produce solutions that may not be optimal but are sufficient given a limited timeframe or deadline.

A language is regular if and only if it can be accepted by a finite automaton. Secondly, It supports no concept of auxiliary memory as it loses the data as soon as the device is shut down.