SOLUTION

Base address B = 250
Element size w = 2 bytes
No. of columns n = 6
L_r = 1; L_c =0
Location R[3,2] = 250 + 2 (6(3-1)+(2-0))
                         = 250 + 2 (6(2)+(2))
                         = 250 + 2 (12+2)
                         = 250 + 2 (14)
                         = 250 + 28
                         = 278  

SOLUTION

Base address B = 500
Element size w = 1 byte
r (number of rows) are 20-(-20)+1=40+1=41
I_r = -20; I_c = 10
Address of A[0,20] = 500 + 1(0-(-20)+41(20-10))]
                              = 500 + 1(20 + 41 x 10)
                              = 500 + (20+410)
                              = 500 + (430)
                              = 930. 

SOLUTION

Base address B = 220
Element size w = 2 bytes
number of columns = 4 
L_r = 1 ; L_c = 1
Location R [6,2] = 220 + 2 (4 (6-1)+(2-1))
                          = 220 + 2 (4 (5) + (1))
                          = 220 + 2 (21)
                          = 220 + 42
                          = 262.    

SOLUTION

This linearization technique stores first the first column, then the second column, then the third column and so forth. The formula for address calculation of (I, J)th element in array X(L_r : U_r, L_c : U_c) with base address B and element size w is given below:
Address(I,J) = B + w[r(J-L_c)+(I-L_r)]
where r is the number of rows i.e. length of a column array L_r : U_r i.e., U_c - L_c +1.

SOLUTION

This linearization technique stores first the first row of the array, then the second row, then the third column and so forth. The formula for address calculation of (I, J)th element in array of m x n elements with base address B and element size W bytes is given below:

Address of (I,J) in Row-major order = B + W[n(I-1)+(J-1)]
where m are the number of rows and n are the number of columns.

More generalized form of formula for address calculation of [I,J] element of array AR[(L_r : U_r, L_c : U_c) with base address B and element size w is given below:
Address(I,J)th element = B + W[n(I-L_r)+(J-L_c)]
where n is the number of columns i.e. length of array [L_c : U_c] i.e., U_c - L_c +1:L_r is first row number, L_c is first column number.

SOLUTION

In insertion sort, each successive element is picked and inserted at an appropriate position in the previously sorted array. This sorting algorithm is frequently used when n is small.

SOLUTION

In bubble sort, the adjoining values are compared and exchanged if they are not in proper order. This process is repeated until the entire array is sorted.

SOLUTION

In selection sort, the smallest (or largest depending upon the desired order) key from the remaining unsorted array is searched for and put in the sorted array. This process repeats until the entire array is sorted.

SOLUTION

Merging means combining elements of two arrays to form a new array. Simplest way of merging two arrays is that first copy all the elements of one array into new array and then copy all the elements of other array into new array. If you want the resultant array to be sorted, you can sort the resultant array.

SOLUTION

Binary search can work for only sorted arrays whereas linear search can work for both sorted as well as unsorted arrays. The element to be deleted is first searched for in the array using one of the search techniques i.e., either linear search or binary search. If the search is successful, the element is removed and rest of the elements are shifted so as to keep the order if array undisturbed.

SOLUTION

The subscript or index of an element designates its position in an array.

SOLUTION

Binary Search searches for the given item in a sorted array. The search segment reduces to half at every successive stage.

SOLUTION

In linear search, each element of the array is compared with the given Item to be searched for, one by one.

SOLUTION

8*10*(6-4)+28 = (810*)*(64-)28+ = 810 * 64-*28+.

SOLUTION

Front stores the index of first element in the queue. In a queue deletion is always takes place at the front end.

SOLUTION

Rear stores the index of last element in the queue. In a queue insertion of elements is always takes place at the rear end.

SOLUTION

Infix notation is the common arithmetic and logical notation where operators are placed in between the operands.

SOLUTION

Push is to insert an element in a stack, whereas pop is to delete an element from the stack.

SOLUTION

Deletion takes place at the front end which increase the value of front. Thus deletion of 2 elements cause front to increase by 2 and rear remains same.

SOLUTION

Linked queues have links among its elements and it maintains two pointers to store the "front" position and "rear" position.

SOLUTION

The operator comes in between operands in infix expression. Example: a, b, AND, a, c, AND, OR = (a AND b a AND c) OR = a AND b OR a AND c.

SOLUTION

Circular queues are implemented in circular forms rather than in straight lines. That is why, if space is there in the beginning, the rear shifts back to the beginning after reaching the maximum possible index number.

SOLUTION

It is just like the simple queue where front end gets modified when deletion takes place.

SOLUTION

It is like a simple queue where rear end gets modified when insertion takes place.

SOLUTION

At every insertion, value of rear increases by 1 and front remains the same. Here rear will be increases by 2 and front will remain the same.

SOLUTION

Linked queues have links among its elements, and it maintains two pointers to store the "front" position and "rear" position.

SOLUTION

Deletion takes place at the front end, and always increases value of front according to the number of deletions.

SOLUTION

To delete an element in a stack, we use pop operation. We can pop the top most elements in a stack.

SOLUTION

To add an element in a stack, we use push operation.Thus the process refers to "pushing"

SOLUTION

Dequeue is a queue in which elements can be added or removed at either end.

SOLUTION

A free pool is a list keeping account of available free memory. It is a data structure used in a scheme for dynamic memory allocation. It operates by connecting unallocated regions of memory.

SOLUTION

The other name for free storage list is free pool and it keeps an account of the freely available memory.

SOLUTION

Prefix expression(also called polish notation of an expression). It is an expression where operators are placed before operands.

SOLUTION

(P-Q)*(M/N) +R = (PQ-)*(MN/) R+ = PQ-MN/*R+.  

SOLUTION

In prefix expression, operators are placed before the operands.
Here, the expression (A+B) / (C*D)- Z = (+AB / *CD )-Z = -/+AB*CDZ

SOLUTION

In prefix expression, operators are placed  before the operand. Here, A+B-D/X I= +AB - /DX = -+AB/DX.

SOLUTION

In an infix expression, operators are placed between its operands.  

SOLUTION

Step 1: A, B, C, D, E, F (on top). Step 2: A, B, C, D, E (on top). Step 3: A, B, C, D (on top). Step 4: A, B, C (on top).

SOLUTION

[(85+) * (69*)]+(63-) = (85+69**) + (63-) = 85+69**63-+.  

SOLUTION

It would be (20+45) *((20-10) + 15) = 65 * 25 = 1625.

SOLUTION

Push and Pop operations can take place only at one end.
It would be Step 1: A, B, C, D, E, F. Step 2: A, B, C, D, E, F, K. Step 3: A, B, C, D, E, F, K, M.

SOLUTION

As a stack is implemented in LIFO manner, so the last element to be pushed in the stack is first element to be popped up.

SOLUTION

In an infix expression, operators are placed between operands.

SOLUTION

In postfix expression, operator comes after the operand. Here, the expression (A+B) / (C*D)- Z = AB+ / CD* Z- = AB+CD*/Z-

SOLUTION

In postfix expression, operator comes after the operand. Here, A+B-D/X = AB+ - DX/ = AB+DX/-.

SOLUTION

Insertion always takes place at the rear end. front             rear

SOLUTION

Front stores the index of first element in the queue. Rear stores the index of last element in the queue. The formula to calculate the number of elements in a queue is = front - rear + 1

SOLUTION

AVAIL list keeps account of the available memory locations.  It is used when memory is allocated during run time.               

SOLUTION

Stages are:-                                                     

SOLUTION

Stages are:-

SOLUTION

:  Input expression :         (true AND false) OR  NOT(false OR True)                              

SOLUTION

In a linear queue, insertions are at the rear and deletions are from the front.  As more elements are added, rear keeps moving ahead and ultimately reaches the last location of the array.  As more elements are deleted, front also moves ahead, leaving behind locations from which values have been extracted.  An attempt to insert another value at this stage would give an error, “Overflow” , as the queue is considered full if  rear has reached the last array location, even if there is space available before front. 

In case of circular queue, this space is utilized.  When rear is at the end of the array, it moves to the first location and stores a value.  Thus, the array is considered full when front is at the first position and rear is at the last, or, when rear lies just before front.

                                                              front                       rear

 
Q[0]                                Q[1]                        Q[2]                          Q[3]

Consider the above example where front is at index number 2 and rear is at index 3.  In a linear queue, no more elements can be added. 

But in a circular queue,  read would become 0 and store a value.  Thus, the 2 locations before front will be used.           

SOLUTION

Deque or double-ended queue, is a special kind of queue in which elements can be inserted and deleted from either end, but not in the middle. 

The deque can be of two types – input restricted deque and output restricted deque. 

An input restricted deque is a dequeue which allows insertions are allowed at one end but allows deletions at both ends of the list.

SOLUTION

Two or more functions can share the same name as long as their parameter declarations are different. This could include:

• different data types or
• different number of arguments

SOLUTION

Polymorphism is the ability of an object to behave differently in different circumstances can effectively be implemented in programming through function overloading.

SOLUTION

Constant arguments prevent temporary modification of the argument. The keyword const added in the beginning of an argument declaration, to prevent the argument from being modified within the body of the called function.

SOLUTION

Default arguments are useful in situation where some arguments always have the same value. It provides greater flexibility to the programmer. It can be used to add new parameters to an existing function.

SOLUTION

They are the values given in the function declaration that compiler automatically inserts during the function call. Such insertion is done when the caller does not provide a value for that argument in the function call.

SOLUTION

Function overloading reduces number of comparisons in a program and thereby making the program run faster.

SOLUTION

Late binding is also known as dynamic binding. In late binding, the binding is done at the run time (during program execution).

SOLUTION

Early binding is also known as static binding. In early binding, the binding of identifiers is done at the compile time.

SOLUTION

Binding is of two types – early binding and late binding. In early binding, the binding of identifiers is done at the compile time. In late binding, the binding is done at the run time (during program execution).

SOLUTION

Function overloading can be achieved by passing different number of arguments and by passing different types of arguments.

SOLUTION

C++ implements polymorphism through overloaded functions. The overloaded functions are invoked by matching arguments, both type of arguments and number of arguments.

SOLUTION

Method with the same name and different signature result in function overloading. Function overloading is used to enhance the readability of the program. It also reduces number of comparisons in a program and thereby makes the program run faster.

SOLUTION

Method overriding or function overriding occurs has the same name and same signature in both the base and derived class.

SOLUTION

A function is a collection of statements grouped together. The methods or functions are the main building blocks of a program.

SOLUTION

A function is a collection of statements grouped together. The methods or functions are the main building blocks of a program.

SOLUTION

Method/function overriding

SOLUTION

Binding refers to the linking of a procedure call to the code to be executed in response to the call.

SOLUTION

A function is a collection of statements that is grouped together to perform an operation.

SOLUTION

Late Binding or Dynamic Binding

SOLUTION

Function overloading is the process of using the same name for two or more functions.

SOLUTION

All default arguments must be the rightmost arguments. The following program works fine and produces 10 as output.

#include

using namespace std;

int fun(int x, int y = 0, int z = 0)

{ return (x + y + z); }

int main()

{

cout << fun(10);

return 0;

}

SOLUTION

When the same function name has different definitions, it is known as function overloading. The definitions differ in the number and data types of the arguments.

Note:

The overloaded functions must have different arguments lists. Overloading functions with the same argument list but different return type is not allowed. Member functions cannot be overloaded by making one static and the other not, arguments being the same. There should be no ambiguity.

SOLUTION

• Function overloading reduces the number of comparisons in a program; thereby making the program run faster.
• If we need to perform a complex mathematical operation, then function overloading is the easiest form to solve the problem.
• With function overloading, the programmer is relieved from the burden of choosing the right function for a given set of values.

SOLUTION

// overloaded functions

#include

int sum (int a, int b)

{

return a+b;

}

double sum (double a, double b)

{

return a+b;

}

int main ()

{

cout << sum (10,20) <<“n”;

cout << sum (1.0,1.5) <<“n”;

return 0;

}

SOLUTION

When a function name is declared more than once in a program, the compiler interprets the declaration in following manner:

1. Firstly, if the signatures of subsequent functions match the previous functions, then, the second function is treated as a re-declaration of the first.
2. Secondly, if the signature of the two functions matches exactly but the return types differ, the second declaration is treated as an erroneous re-declaration of the first and flags error.
3. Lastly, if the signatures of the two functions differ in either the number or type of their arguments, the two functions are considered to be overloaded.

SOLUTION

The union compatibility is defined as such :
(1) the two relations have the same degree n (number of attributes) , and (2) domain (Ai) = domain (Bi) for 1<= i <=n, where domain stands for data type.

SOLUTION

Data independence is the type of data transparency that matters for a centralized DBMS. It refers to the immunity of user applications to make changes in the definition and organization of data, and vice-versa.

SOLUTION

A check constraint is the most generic constraint type. The value in certain column should satisfy a truth-value expression. There is no limit to the number of check constraints that one can define on a column.

SOLUTION

The size of database is measured in gigabytes. Gigabyte is a multiple of the unit byte for digital information storage. Since the giga prefix means 10⁹, gigabyte means 1,000,000,000 bytes (1000³, 10⁹).

SOLUTION

The logical data independence ensures that the application program remains the same. Modifications at the conceptual level are necessary whenever a logical structure of the data gets altered.

SOLUTION

In physical data independence, the application programs remain the same even though the scheme at physical level gets modified. This is done in order to improve the performance of the system.

SOLUTION

Cost of hardware is one of the most important things for a database system. Its hardware configuration cost is high.

SOLUTION

DBA is a person who checks the authenticity of the database. He insures the database is secure and functioning properly.

SOLUTION

DROP TABLE table_name; is the command used to remove the table.We should not get confuse with delete command, as delete is use to delete some rows.

SOLUTION

In the simplest form the join operation is just the cross product of two relations. Two interrelated tuples from two different relations are joined by this function.

SOLUTION

A table is said to be in 3NF, if it is in 2NF and transitively dependency is removed from the table.

SOLUTION

A table is said to be in 2NF, if it is in 1NF and all non-key attributes are totally dependent upon primary key.

SOLUTION

1NF is used to remove the redundancy in the system. Therefore, delicacy and repetition of values is not allowed.

SOLUTION

Primary key is a key, which uniquely identifies, a specific instance of an entity. Therefore, the value of the primary key can never be null.

SOLUTION

DDL stands for data definition language. It provides statement for creating and deleting the database.

SOLUTION

Elements of an array can be accessed and processed in any order.

In a stack, data can be inserted (push) and deleted (pop) at one end, called the top.  These are the only operations possible in a stack. Stack is a LIFO structure where the element that comes last must be removed first. 

SOLUTION

1.  SET  X = Start

2.  REPEAT STEPS 3 to 4 UNTIL X = NULL

3.  X->info = X->info + NUM

4.  X = X->next

5.  END                          

SOLUTION

When the stack is implemented as an array, there is a limited size beyond which it cannot store elements.  Trying to push when the stack is full would give an error ‘Overflow’.  In case of linked implementation, whenever an element is to be stored a new node is created in memory. 

SOLUTION

1.  SET  X = Start

2.  SET num = 0

3.  REPEAT STEPS 4 to 6 UNTIL X = NULL

4.  IF  X->info !=0 THEN

5.      num = num + 1

6.      X = X->next

7.      PRINT “Number of Non Zero values”, num

8.  END                                

SOLUTION

1.  SET  X = Start

2.  SET P = NULL

3.  REPEAT STEPS 4 to 7 UNTIL X = NULL

4.  IF EL = X->info THEN

5.      {P = X

6.         Go To 8 }

7.      X = X->next

8.     IF P = NULL THEN

            PRINT “Not Found”

       ELSE

            PRINT “Found At “, P

9.  END                                                                   

SOLUTION

Queue is a FIFO (First In First Out) structure. This means that elements that enter the queue first, leave it first.  All insertions are at the rear end and deletions are at the front end.  The value of front and rear are maintained to keep track of these operations. 

A queue can be visualized as queue of people waiting to buy a ticket. A queue can be implemented as an array or a linked list.   

SOLUTION

Overflow is a situation that occurs when we try to insert a value in an array when there is no space available. This situation is faced in stacks or queues.  Once the available space is occupied or full, any attempt to push or insert, arises the ‘Overflow’ condition.

Underflow occurs when we try to extract or remove a value when there are none. Any attempt to extract from an empty list in stack or queue, implemented as array, arises ‘Underflow’ condition.