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

Look at the above link on how algo works.

Lets consider there are 'K' buckets (as given).

Now, for each digit you repeat the following:

1) place the digit of each number in the appropriate bin.  -  ø(n)

2) append all the 'K' bins sequentially.

Thus, for a single digit, its ø(n+k),

For 'd' digits, its ø(d(n+k))

The correct answer is option 2.

Concept:

Order or SQL query evaluation:

1. From: Cartesian product of tables.
2. Where: Select the rows.
3. Group by: Divide the rows into groups.
4. Having: Select the groups.
5. Expressions: Expressions In select are evaluated.
6. Distinct: Distinct in select (Eliminate the duplicates).
7. Ser-Operations: (Union, intersect, Except)
8. Order By: Sort the rows.

The given data,

SQ1:

SELECT R.B,AVG(S.B)
FROM R, S
WHERE R.A=S.C AND S.D<7
GROUP BY R.B;

For 1st query it will select 6 tuples by joining R and S, where R.A and S.C are equal. Among that 5 are S.D<7

The relation R is,

The relation S is,

Output: Four tuples selected M=4.

SQ2:

SELECT DISTINCT S.B,MIN(S.C)
FROM S GROUP BY S.B
HAVING COUNT (DISTINCT S.D)>1;

Here we are selecting distinct value of S.D>1. In the table, we can see only one value is not distinct here. So, getting 5 tuples

The relation S is,

Output: Only two tuples selected N=2.

Effort (person per month) = α.(kDSI)ⁿ

kDSI = Kilo LOC

= 2.8*(40)^1.2

= 2.8*83.6511

= 234.22 (person per month)

Block no. 3 i.e. 4th block.

Explanation

From the table it is clear that fork is called 9 times

number of child processes created = 29 - 1 = 512

The formula to calculate the total number of child processes created by successive fork() calls is derived from the exponential nature of fork().

Formula:

Total processes = 2ⁿ

• n: Number of fork() calls.
• Each fork() doubles the number of processes.

To find child processes:
Child processes = 2ⁿ - 1

• Subtract 1 for the original parent process.

Calculation:

Since n = 9

• Therefore, 9 fork() calls: 2⁹−1 = 511 child processes.

The correct answer is option 3.

Concept:

Basic idea of syntax directed translation:
Syntax-Directed Constructing a parse tree or syntax tree and computing the values of attributes at the nodes of the tree by visiting them in some order is the definition of translation. In many circumstances, translation can be done without creating an explicit tree during parsing.

Evaluation Orders for syntax directed translation:

• Dependency Graphs.
• Ordering the Evaluation of Attributes.
• S-Attributed Definitions.
• L-Attributed Definitions.
• Semantic Rules

​

Note:

• Evaluation of the semantic rules may generate code, save information in a symbol table, issue error messages, or perform any other activities.
• Special cases of syntax-directed definitions can be implemented in a single pass by evaluating semantic rules during parsing, without explicitly constructing a parse tree or a graph showing dependencies between attributes.

Hence the correct answer is the Conceptual view of syntax-directed translation.

The correct answer is option 3.

Concept:

Fork ():

Fork () is a system call that creates a new process. After the new child process is created, both processes will execute the next instruction.

If fork() returns a negative value, the creation of the child process was unsuccessful. Return zero to the newly created process.

Explanation:

If we add the levels of the above tree for I = 0 to p-1, we get 2ⁿ-1. So there will be 2^p – 1 child processes.

On the other hand, the total number of processes created is (number of child processes)+1.

Total number of child processes created= 2^p-1 for p iterations.

Hence the correct answer is 2^p-1.

Internal Fragmentation: This type of fragmentation occurs when a process is allocated a memory partition than what is required by the process. This creates a lack of memory availability when total memory is still more than required by upcoming processes. Hence, reducing system performance.

Paging: It is a static memory allocation scheme that permits the physical address space of a process to be non contiguous. CPU generated logical address is mapped to physical address and this is called as paging. It suffers from internal fragmentation.

Dynamic Partitioning: In this, partitioning of memory is done dynamically when the process arrives during run time. It then allocates it the memory large enough to accommodate it. It suffers from external fragmentation.

Segmentation: This technique solves the problem of paging where user's view of memory allocation is not followed. Instead of dividing the memory into equal sized pages, virtual address space is divided into variable length segments. This suffers from external fragmentation.

Fixed Partitioning: In this partitioning, memory is divided into fixed size partitions before run time. Then during runtime, if a process needs memory and large enough memory is available, then it is placed in that hole. It suffers from internal fragmentation.

Network security audit is a information security audit. A network security audit should include review of following:

1) Firewalls: It should check for firewall configuration and vulnerabilities.

2) Antivirus software: Check that system is virus free. All systems should have updates antivirus software.

3) Password approach: Should check the password policies of company so that there will not be misuse of passwords.

4) Backups: There must be backing up of crucial data in organizations to overcome the loss in case of failure.

5) Active directory: All the information must be saved in a centralized directory. Directory must be managed on regular basis.

The correct answer is "option 1".

CONCEPT:

Network address or First address is used for network identification.

The Network address is calculated by Bitwise AND operation of corresponding binary bits of IP Address & Subnet mask.

CALCULATION:

Hence, IP Address 125.134.96.0 is the First address.

The implementation of JK flip flop from SR latch is shown

From figure

S = JQ'

R = KQ

The correct answer is option 3.

Concept:

In compiler design, every phase takes inputs from its previous stage and feeds its output to the next phase of the compiler. There are 7 phases in a compiler.

• Lexical analysis
• Syntax analysis
• Semantic analysis
• Intermediate code generator
• Code independent optimizer
• Code dependent optimizer
• Code generator

Machine-dependent optimization is done after the target code has been generated and when the code is transformed according to the target machine architecture. It involves CPU registers and may have absolute memory references rather than relative references.

Machine-independent optimization attempts to improve the intermediate code to get a better target code. The part of the code which is transformed here does not involve any absolute memory location or any CPU registers.

Machine independent phases are

• Lexical analysis,
• Syntax analysis,
• Semantic analysis,
• Intermediate code generation and
• sometimes code optimization.

Hence the correct answer is A and C.

Concept:

Abelian Group: Let {G=e, a, b} where e is identity. The operation 'o' is defined by the following composition table. Then(G, o) is called Abelian if it follows the following property-

1. Closure Property
2. Associativity
3. Existence of Identity
4. Existence of Inverse
5. Commutativity

Cyclic Group- A group a is said to be cyclic if it contains an element 'a' such that every element of G can be represented as some integral power of 'a'. The element 'a' is then called a generator of G, and G is denoted by <a> (or [a]).

Theorem:

(i) All cyclic groups are Abelian, but an Abelian group is not necessarily cyclic.

(ii) The order of a cyclic group is the same as the order of its generator.

Thus it is clear that A and B both are true.

Key Points

The precedence graph of the above schedule is,

And apply Topological Sort, T1→T3→T2

The serial schedules T1, T3, T2 is satisfying all the above conditions. Directed graph for the non-serial schedule will also give the same sequence.

Hence the correct answer is T1 → T3 → T2.

Given:

P(A) = 0.7, P(B) = 0.5 and P(B/A) = 0.3

Formula:

P(A/B) = P(A ∩ B)/P(B)

P(B/A) = P(A ∩ B)/P(A)

P(A ∪ B) = P(A) + P(B) - P(A ∩ B)

Calculation:

(i) ∵ P(B/A) = P(A ∩ B)/P(A)

⇒ P(A ∩ B) = 0.21

∴ P(A/B) = P(A ∩ B)/P(B)

= 0.21/0.5

= 0.42

(ii) P(A ∪ B) = P(A) + P(B) - P(A ∩ B)

⇒ P(A ∪ B) = 0.7 + 0.5 - 0.21

= 0.99

Hence, (i) P(A/B) = 0.42 (ii) P(A ∪ B) = 0.99

Note:

The option in the official paper was incorrect, however we have modified the option.

• The verification and the validation techniques are two different types of bug filters
• To achieve high product reliability in a cost-effective manner, a development team needs to perform both verification and validation activities
• The activities involved in these two types of bug detection techniques together are called the “V and V” activities
• Based on the above discussions, it can conclude that:

Error detection techniques = Verification techniques + Validation techniques

E = V1 + V2 ∴ V1 = E – V2

Depth first search algorithm is used to traverse the vertices of a graph. It uses the concept of back tracking. Depth first search uses a data structure for its implementation which is known as stack.

Application of depth first search:

1) It is used to find the strongly connected components.

2) It helps in topological sorting.

3) to check the bipartiteness of a graph.

4) It helps in detecting cycles in a graph.

5) To find articulation points in a graph.

Example:

DFS traversal for this: 1 2 4 5 3 6 7

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

Here, 1 is added to include the root node.

N(0) = 1,

N(1) = 2,

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.

Top-Down Parsing: Involves searching a parse tree to find the left-most derivations of an input stream by using a top-down expansion. Parsing begins with the start symbol which is transformed into the input symbol until all symbols are translated and a parse tree for an input string is constructed. Examples include LL parsers and recursive-descent parsers. Top-down parsing is also called predictive parsing or recursive parsing.

Bottom-Up Parsing: Involves rewriting the input back to the start symbol. It acts in reverse by tracing out the rightmost derivation of a string until the parse tree is constructed up to the start symbol This type of parsing is also known as shift-reduce parsing. One example is an LR parser.

Backtracking uses depth-first node generation with bounding functions. It traverses all the nodes by starting from the root node and covers the nodes possible before backtracking. Backtrack means when you are moving forward and find no more nodes in that path then start moving in backward direction to traverse the remaining nodes.

Depth first search uses stack to implement this process.

Algorithm:

1. Pick the root node
2. Push all the adjacent nodes to the stack
3. Pop the node from stack to select next node to visit
4. Go to step 2
5. Terminate when all nodes visited

Given, f(x)=x−[x]

f(x)=x−[x]={x}⇒ fractional part of a integer

It is well known that the fractional part function always between 0 and 1 and {x} can also be zero.

⇒ 0≤{x}<1

∴ the range of f(x) is [0,1)

Heap allocation is required for languages that support dynamic data structures.

In many situations, it is not possible to allocate data in a LIFO fashion with a stack. In this case, data is dynamically allocated from a pool of memory commonly called the heap. Heap allocation is considerably slower and more complex than stack allocation and may also result in allocations scattered all over memory. Such scattered allocations can lead to a loss of coherence and a reduction in memory access efficiency. A parallelized heap allocator should be used when writing parallel programs that use dynamic data structures.

In using the mathematical programming methods the process of optimization begins with an acceptable design point and new point is selected suitability so as to minimize the objective function and the search for another new point is continued is continued from the previous point until the optimum point is reached and there are several well established techniques for selecting a new point and to proceed towards the optimum point, depending upon the nature of the problem, such as linear and non linear programming.