ISRO CS 2013

Number of elements in first dimension of array = upper limit - lower limit + 1 = 8 - 1 + 1 =8 Number of elements in second dimension of array = 5 - (-5) + 1 = 11 Number of elements in third dimension of array = 15 - (-10) + 1 = 16 total number of elements = 8 * 11 * 16 = 1408 So, Answer (B) is correct.

The insertion and rotation of the various elements are shown in the following figure: So, the total number of rotations are 3.

Opportunistic reasoning is a method of selecting suitable logical inference strategy from the knowledge base of the AI system. Blackboard is an AI model of opportunistic reasoning where a common knowledge base is updated frequently by diverse knowledge sources. So, (B) is the correct option.

p = getnode() // getnode() allocates the space which is equal to the size of the node type structure and returns a pointer. info (p) = 10 // value of the new node is equal to 10 next (p) = list // adding new node to the list. Clearly, through these steps, insertion of a node is performed. Option (C) is correct.

Shift reduce are the class of parsers which built a parse tree in bottom-up manner and scans it from left to right.

In these parsers, through shift step, a single character from the token stream is pushed on the parse stack and becomes a new single-node parse tree.

A reduce step applies a complete grammar production rule to the recent parse trees, joining them together as one tree with a new root symbol.

These parsers include LR parsers which are non-backtracking in nature. Examples: SLR, CLR, LALR etc.

To remove left recursion from the grammar of the
form :  A → Aα | β
We rewrite the production rules as:
           A → βA'
           A'→ αA'| ε

Given Grammar: S → Aa | b
               A → Ac | Sd | ε

after finding indirect left recursion, grammar:

               S → Aa | b
               A → Ac | Aad | bd | ε

here, α = c, ad, β = bd

So, Grammar after removing left recursion = 
               S → Aa | b
               A → A' | bdA'
               A'→ CA'| ada'| ε 

So, option (B) is correct.

In 2's complement numbers, we can check whether there's an overflow or not by taking the XOR of carry in and carry out of the most significant bit. If XOR value = 0, then no overflow. If XOR value = 1, then overflow.

An array can be termed as 2-ordered array, if it contains an element which is atmost two positions away from its original position in a sorted array. So the maximum number of positions that an element can be from its position if the array were 1-ordered = 1 Option (A) is correct.

Number of indexes the framebuffer = 2⁸ = 256 Size of each entry = 8 bits for R component + 8 bits for G component + 8 bits for B component = 24 bits = 3 Bytes Size of frame buffer = 256 * 3 = 768 Bytes Option (C) is correct.