GATE CSE
Which one of the following is FALSE?
(Hint : Use a heap data structure)
double foo(int n){
int i;
double sum;
if(n == 0) return 1.0;
sum = 0.0;
for (i = 0; i < n; i++){
sum += foo(i);
}
return sum;
}
The space complexity of the above function is:10, 8, 5, 3, 2
Two new elements '1' and '7' are inserted in the heap in that order, The level order traversal of the heap after the insertion of the elements is:
double foo(int n){
int i;
double sum;
if(n == 0) return 1.0;
sum = 0.0;
for (i = 0; i < n; i++){
sum += foo(i);
}
return sum;
}
Suppose we modify the above function foo() and store the values of foo(i), $$0 \le i \le n$$, as and when they are computed. With this modification, the time complexity for function foo() is significantly reduced. The space complexity of the modified function would be:Consider the grammar
$$E \to E + n\,|\,E \times n\,|\,n$$For a sentence n + n × n, the handles in the right-sentential form of the reduction are
Consider the grammar
$$S \to \left( S \right)\,|\,a$$Let the number of states in SLR(1), LR(1) and LALR(1) parsers for the grammar be n1, n2 and n3 respectively.
The following relationship holds goodis not suitable for predictive-parsing because the grammar is
Consider the following expression grammar. The semantic rules for expression calculation are stated next to each grammar production.
$$\eqalign{ & E \to number\,\,\,\,\,E.val = number.val \cr & \,\,\,\,\,\,\,\,\,\,\,|E\,\,' + '\,\,E\,\,\,\,\,\,{E^{\left( 1 \right)}}.val = {E^{\left( 2 \right)}}.val + {E^{\left( 3 \right)}}.val \cr & \,\,\,\,\,\,\,\,\,\,\,|\,E\,\,' \times '\,\,E\,\,\,\,\,\,\,{E^{\left( 1 \right)}}.val = {E^{\left( 2 \right)}}.val \times {E^{\left( 3 \right)}}.val \cr} $$The above grammar and the semantic rules are fed to a yacc tool (which is an LALR (1) parser generator) for parsing and evaluating arithmetic expressions. Which one of the following is true about the action of yacc for the given grammar?
int main ( ) { /* Line 1 */
int I, N; /* Line 2 */
fro (I = 0, I < N, I++); /* Line 3 */
}
Identify the compiler's response about this line while creating the object-module Consider the following expression grammar. The semantic rules for expression calculation are stated next to each grammar production.
$$\eqalign{ & E \to number\,\,\,\,\,E.val = number.val \cr & \,\,\,\,\,\,\,\,\,\,\,|E\,\,' + '\,\,E\,\,\,\,\,\,{E^{\left( 1 \right)}}.val = {E^{\left( 2 \right)}}.val + {E^{\left( 3 \right)}}.val \cr & \,\,\,\,\,\,\,\,\,\,\,|\,E\,\,' \times '\,\,E\,\,\,\,\,\,\,{E^{\left( 1 \right)}}.val = {E^{\left( 2 \right)}}.val \times {E^{\left( 3 \right)}}.val \cr} $$Assume the conflicts in the previous question are resolved and an LALR(1) parser is generated for parsing arithmetic expressions as per the given grammar. Consider an expression
3 × 2 + 1.
What precedence and associativity properties does the generated parser realize?
The first operand (destination) ''$$A$$ $$\left[ {{R_0}} \right]''$$ uses indexed addressing mode with $${{R_0}}$$ as the index register. The second operand (source) $$''@B''$$ used indirect addressing mode. $$A$$ and $$B$$ are memory addresses residing at the second and the third words, respectively. The first word of the instruction specific the opcode, the index register designation and the source and destination addressing modes. During execution of $$ADD$$ instruction, the two operands are added and stored in the destination (first operand).
The number of memory cycles needed during the execution cycle of the instruction is
Consider the following sequence of instructions:
$$\eqalign{
& {{\rm I}_1}:L\,R0,\,\,Loc1;\,R0 < \,\, = M\,[Loc1] \cr
& {{\rm I}_2}:A\,R0,\,R0;\,\,\,\,\,\,R0 < \,\, = R0 + R0 \cr
& {{\rm I}_3}:A\,R2,\,R0;\,\,\,\,\,\,R2 < \,\, = R2 - R0 \cr} $$
Let each stage takes one clock cycle.
What is the number of clock cycles taken to complete the above sequence of instructions starting from the fetch of $${{\rm I}_1}?$$
The, $$ALU$$, the bus and all the registers in the data path are of identical size. All operations including incrementation of the $$PC$$ and the $$GPRs$$ are to be carried out in the $$ALU.$$ Two clock cycle are needed for memory read operation-the first one for loading address in the $$MAR$$ and the next one for loading data from the memory but into the $$MDR.$$
The instruction $$''call$$ $$Rn,sub''$$ is a two word instruction. Assuming that $$PC$$ is incremented during the fetch cycle of the first word of the instruction, its register transfer interpretation is
$$$\eqalign{
& Rn < = PC + 1; \cr
& PC < = M\left[ {PC} \right]; \cr} $$$
The minimum number of $$CPU$$ clock cycles needed during the execution cycle of this instruction is :
The, $$ALU$$, the bus and all the registers in the data path are of identical size. All operations including incrementation of the $$PC$$ and the $$GPRs$$ are to be carried out in the $$ALU.$$ Two clock cycle are needed for memory read operation-the first one for loading address in the $$MAR$$ and the next one for loading data from the memory but into the $$MDR.$$
The instruction $$''add$$ $$R0$$, $$R1''$$ has the register transfer interpretation $$R0 < = R0 + R1.$$ The minimum number of cycles needed for execution cycle of this instruction is
The normalized representation for the above format is specified as follows. The mantissa has an implicit preceding the binary (radix) point. Assume that only $$0's$$ are padded in while shifting a field. The normalized representation of the above $$\left( {0.239 \times {2^{13}}} \right)$$ is
Mantissa is a pure fraction in sign - magnitude form. The decimal number $$0.239 \times {2^{13}}$$ has the following hexadecimal representation without normalization and rounding off
struct node {
int value;
struct node *next;
};
Void rearrange (struct node *list ){
struct node *p, * q;
int temp;
if( !list || !list-> next) return;
p = list; q = list->next;
while (q) {
temp = p->value;
p-> value = q ->value;
q-> value = temp;
p = q-> next;
q = p ? p->next : 0;
}
}
Supply = (supplierid, itemcode)
Inventory = (itemcode, warehouse, stocklevel)
For a specific information required by the management, following SQL query has been written
Select distinct STMP.supplierid
From Supply as STMP
Where not unique (Select ITMP.supplierid
From Inventory, Supply as ITMP
Where STMP.supplierid = ITMP.supplierid
And ITMP.itemcode = Inventory.itemcode
And Inventory.warehouse = 'Nagpur');
For the warehouse at Nagpur, this query will find all suppliers whoTable: student
Roll | Name | Hostel | Marks |
---|---|---|---|
1798 | Manoj Rathod | 7 | 95 |
2154 | Soumic Banerjee | 5 | 68 |
2369 | Gumma Reddy | 7 | 86 |
2581 | Pradeep Pendse | 6 | 92 |
2643 | Suhas Kulkarni | 5 | 78 |
2711 | Nitin Kadam | 8 | 72 |
2872 | Kiran Vora | 5 | 92 |
2926 | Manoj Kunkalikar |
5 | 94 |
2959 | Hemant Karkhanis |
7 | 88 |
3125 | Rajesh Doshi | 5 | 82 |
Table: hobby
Roll | Hobbyname |
---|---|
1798 | chess |
1798 | music |
2154 | music |
2369 | swimming |
2581 | cricket |
2643 | chess |
2643 | hockey |
2711 | volleyball |
2872 | football |
2926 | cricket |
2959 | photography |
3125 | music |
3125 | chess |
The following SQL query is executed on the above tables:
Select hostel
From student natural join hobby
Where marks > = 75 and roll between 2000 and 3000;
Relations S and H with the same schema as those of these two tables respectively contain the same information as tuples. A new relation S’ is obtained by the following relational algebra operation:
$$\eqalign{ & S' = \prod\nolimits_{hostel} {(({\sigma _{S.roll = H.roll}}} \cr & ({\sigma _{marks > 75\,\,\,and\,\,roll > 2000\,\,and\,\,roll < 3000}}(S))X(H)) \cr} $$The difference between the number of rows output by the SQL statement and the number of tuples in S’ is
Let r be a relation instance with schema R = (A, B, C, D).
We define $${r_1} = {\pi _{A,B,C}}\left( r \right)$$ and $${r_1} = {\pi _{A,D}}\left( r \right)$$. Let $$s = {r_1}*{r_2}$$ where * denotes natural join. Given that the decomposition of r into r1 and r2 is lossy, which one of the following is TRUE?A company maintains records of sales made by its salespersons and pays them commission based on each individual’s total sales made in a year. This data is maintained in a table with following schema:
salesinfo = (salespersonid, totalsales, commission)In a certain year, due to better business results, the company decides to further reward its salespersons by enhancing the commission paid to them as per the following formula:
If commission < = 50000, enhance it by 2%
If 50000 < commission < = 100000, enhance it by 4%
If commission > 100000, enhance it by 6%
The IT staff has written three different SQL scripts to calculate enhancement for each slab, each of these scripts is to run as a separate transaction as follows:
T1: Update salesinfo
Set commission = commission * 1.02
Where commission < = 50000;
T2: Update salesinfo
Set commission = commission * 1.04
Where commission > 50000 and commission is < = 100000;
T3: Update salesinfo
Set commission = commission * 1.06
Where commission > 100000;
Which of the following options of running these transactions will update the commission of all salespersons correctly?Select title
From book as B
Where (select count(*)
From book as T
Where T.price > B.price) < 5;
$$\eqalign{ & \,\,\,A \to B \cr & \,\,\,A \to C \cr & CD \to E \cr & \,\,\,B \to D \cr & \,\,\,E \to A \cr} $$
Which of the following functional dependencies is NOT implied by the above set?
$$F1 \to F3.\,F2 \to F4.\,\,\,\left( {F1\,.\,F2} \right) \to F5$$ in terms of Normalization, this table is in
If we wish to store information about the rent payment to be made by person(s) occupying different hotel rooms, then this information should appear as an attribute of
The set of all tuples that must be additionally deleted to preserve referential integrity. When the tuple $$(2,4)$$ is deleted is:
$$2x1 - x2 + 3x3 = 1$$
$$3x1 + 2x2 + 5x3 = 2$$
$$ - x1 + 4x2 + x3 = 3$$
This system of equations has
Where $$a, b, c, d, e$$ and $$f$$ are real numbers and $$abc$$ $$ \ne \,\,0$$. Under the matrix multiplication operation, the set $$H$$ is:
where $$\left| x \right| < 1$$ What is $$g(i)$$?
The poset is:
Which one of the following is TRUE?
Every teacher is liked by some student
Which one of the following is a tautology?
$$16$$ surfaces, $$512$$ tracks/surface, $$512$$ sectors/track, $$1$$KB/Sector, rotation speed $$3000$$ rpm. The disk is operated in cycle stealing mode whereby whenever one $$4$$ byte word is ready it it's sent to memory; similarly, for writing, the disk interface reads a $$4$$ byte word from the memory in each $$DMA$$ cycle Memory cycle time is $$40$$nsec. The maximum percentage of time that the $$CPU$$ gets blocked during $$DMA$$ operation is:
if (fork() == 0)
{
a = a + 5;
printf("%d, %d \n", a, &a);
}
else
{
a = a - 5;
printf ("%d, %d \n", a, &a);
}
Let $$u,v$$ be the values printed by the parent process, and $$x,y$$ be the values printed by the child process. Which one of the following is TRUE?
int (*f)(int *);
double foo(double); /* Line 1 */
int main () {
double da, db;
//input da
db = foo(da);
}
double foo(double a){
return a;
}
The above code compiled without any error or warning. If Line 1 is deleted, the above code will show:void foo (int n, int sum) {
int k = 0, j = 0;
if(n==0) return;
k=n%10; j = n /10;
sum = sum + k;
foo(j, sum);
printf("%d",k);
}
int main () {
int a = 2048, sum = 0;
foo(a, sum);
printf("%d\n", sum);
}
What does the above program print?i) Abstraction and encapsulation
ii) Strictly-typedness
iii) Type-safe property coupled with sub-type rule
iv) Polymorphism in the presence of inheritance
$${L_1}\, = \left\{ {w\,{w^R}\,\left| {w \in \left\{ {0,1} \right\}{}^ * } \right.} \right\}$$
$${L_2}\, = \left\{ {w\, \ne {w^R}\,\left| {w \in \left\{ {0,1} \right\}{}^ * } \right.} \right\}$$ where $$ \ne $$ is a special symbol
$${L_3}\, = \left\{ {w\,w\,\left| {w \in \left\{ {0,1} \right\}{}^ * } \right.} \right\}$$
Which one of the following is TRUE?
$${L_1} = \left\{ {{a^n}{b^n}{c^m}\left| {n,m > 0} \right.} \right\}$$ and $${L_2} = \left\{ {{a^n}{b^m}{c^m}\left| {n,m > 0} \right.} \right\}$$
Which of the following statement is FALSE?