Explore topic-wise InterviewSolutions in .

(a) bubble sort

Algorithm for the above said task is as follows: -

Let us denote the pointer to an item in the original linked list as P

Then the data and consequent pointers will be denoted as P->data and P->next respectively.

We assume that the functions list1.add (x), list2.add (x), list3.add (x) and list4.add (x) is defined to insert the “item x” into the linked list list1, list2, list3 and list4 respectively. 

start

set i = 1

while ( P->next != NULL )

Do

If (i % 4 = 1)

List1.add (P->data)

Else if (i % 4 = 2)

List2.add (P->data)

Else if (i % 4 = 3)

List3.add (P->data)

Else

List4.add (P->data) 

P = P->next //increment P to point to its next location i++ // increment i to count the next node in sequence. 

Done

End

Algorithm to add two polynomials using linked list is as follows:- 

Let p and q be the two polynomials represented by the linked list. 

1. while p and q are not null, repeat step 2. 

2. If powers of the two terms ate equal then if the terms do not cancel 

then insert the sum of the terms into the sum Polynomial 

Advance p 

Advance q

Else if the power of the first polynomial> power of second

Then insert the term from first polynomial into sum polynomial

Advance p

Else insert the term from second polynomial into sum polynomial 

Advance q

3. copy the remaining terms from the non empty polynomial into the sum polynomial.

The third step of the algorithm is to be processed till the end of the polynomials has not been reached.

loops is used to read and display array elements.

Adjacent elements are checked and inter changed in bubble sort.

(i) This is a valid representation of sequence. 

(ii) This is also a valid representation of sequence.

(iii)This could not be the sequence since 240 is encountered after 911 so it must be its left child, and any other node henceforth must be less than 911(parent). But the node 912 breaks this sequence, which is greater than 911 and lies on the left subtree of 911, which violates the basic rule of a Binary Search Tree.

(iv)This is also a valid representation of sequence. 

(v)This could not be a valid sequence since 621 is encountered after 347 so 621 must be its right child, and any other node henceforth must be greater than 347(parent). But this sequence is broken by the node 299 < 347 and lies on the right subtree of 347 which violates the basic rule of a Binary Search Tree.

Algorithm to add two polynomials using linked liLet p and q be the Let p and q be the two polynomials represented by linked lists

1. while p and q are not null, repeat step 2.

2. If powers of the two terms ate equal 

then if the terms do not cancel

then insert the sum of the terms into the sum Polynomial

Advance p 

Advance q

Else if the power of the first polynomial> power of second

Then insert the term from first polynomial into sum polynomial 

Advance p

Else insert the term from second polynomial into sum polynomial

Advance q

3. copy the remaining terms from the non empty polynomial into the sum polynomial. 

The third step of the algorithm is to be processed till the end of the polynomials has not been reached. 

1. Bubble sort: 

It is a simple sorting method. In this sorting considering two adjascent elements if it is out of order, the elements are interchanged. After the first iteration the largest(in the case of ascending sorting) or smallest (in the case of descending sorting) will be the end of the array. This process continues.

2. Selection sort: 

In selection sort the array is divided into two parts, the sorted part and unsorted part. First smallest element in the unsorted part is searched and exchanged with the first element. Now there is 2 parts sorted part and unsorted part. This process continues.

The algorithm to reverse the direction of a singly link list is as follows: 

reverse (struct node **st) 

{

struct node *p, *q, *r;

p = *st; 

q = NULL;

while (p != NULL)

{ 

r =q; 

q = p; 

p = p → link; 

q → link = r;

}

*st = q; 

}

1. Linear search: 

In this method each element of the array is compared with the element to be searched starting from the first element. If it finds the position of the element in the array is returned. 

2. Binary search: 

It uses a technique called divide and conquer method. It can be performed only on sorted arrays. First we check the element with the middle element. There are 3 possibilities. The first possibility is the searched element is the middle element then search can be finished. 

The second possibility is the element is less than the middle value so the upper bound is the middle element. The third possibility is the element is greater than the middle value so the lower bound is the middle element. Repeat this process.

The O (n) time non-recursive procedure that reverses a singly linked list of n nodes is as follows.

reverse (struct node **st) 

{ 

struct node 

*p, *q, *r; p = *st; 

q = NULL; 

while (p != NULL) 

{

 r =q; 

q = p; 

p = p → link; 

q → link = r; 

} 

*st = q; 

}

Height(Left,Right,Root,height)

1. If Root=Null then height=0; 

return; 

2. height(Left,Right,Left(Root),heightL) 

3. height(Left,Right,Right(Root),heightR) 

4. If heightL≥heightR then 

height=heightL+1; 

Else 

height=heightR+1; 

5. Return 

Structures and union

A structure contains an ordered group of data objects. Unlike the elements of an array, the data objects within a structure can have varied data types. Each data object in a structure is a member or field. A union is an object similar to a structure except that

1. In union, one block is used by all the member of the union but in case of structure, each member has their own memory space. All of union members start at the same location in memory. A union variable can represent the value of only one of its members at a time.

2. The size of the union is equal to the size of the largest member of the union where as size of the structure is the sum of the size of all members of the structure.

For example

struct book

[

char name;

int pages;

float price;

};

Now if we define struct book book 1, then it will assign 1+2+4=7 bytes of memory for book 1.

If we define it as union like

union book

{

char name;

int pages;

float price;

};

The compiler allocates a piece of storage that is large enough to store the largest variable types in union. All three variables will share the same address and 4 bytes of memory is allocated to it. This program of structure will read name, roll no and marks in 6 subject of 3 students & then display name and roll of student who scored more than 70% marks in total.

#include<stdio.h>

#include<conio.h>

struct student

{

char name[10];

int roll_no;

int marks[6];

int total;

int per;

};

void main()

{

struct student stu[3];

int i,j,req;

clrscr();

for(i=0;i<3;i++)

{

stu[i].total=0;

printf("enter data for %d students :",i+1);

printf("\nenter name");

scanf("%s",stu[i].name);

printf("\nenter roll no ");

scanf("%d",&stu[i].roll_no);

printf("\nenter marks in subjects\t");

for(j=0;j<6;j++)

{

printf("\nenter marks in %d subject\t",j+1);

scanf("%d",&stu[i].marks[j]);

stu[i].total=stu[i].total+stu[i].marks[j];

}

stu[i].per=stu[i].total/6;

printf("\n");

}

for(i=0;i<3;i++)

{

if(stu[i].per>70)

{

printf("\nSTUDENT %d",i+1);

printf("\nname :");

printf("%s",stu[i].name);

printf("\nroll no");

printf("%d",stu[i].roll_no);

for(j=0;j<6;j++)

{

printf("\nmarks in %d subject\t",j+1);

printf("%d",stu[i].marks[j]);

}

printf("\nTOTAL :%d",stu[i].total);

}

}

getch();

}

A program to concatenate two strings is given below: 

#include < stdio . h>

#include < stdio . h>

void main() 

{

char a[100],b[100];

int i=0,j=0; 

clrscr();

printf("enter the set of lines"); 

gets(a);

while(a[i]!='\0') 

{ 

while(a[i]!=' '&&a[i]!='\t'&&a[i]!='\0')

{

b[j]=a[i];

j++; 

i++; 

} 

while(a[i]==' '||a[i]=='\t') 

i++; 

}

b[j]='\0';

printf("%s",b); 

getch();

} 

Recursion: - Recursion is defined as a technique of defining a set or a process in terms of itself. 

There are two important conditions that must be satisfied by any recursive procedure. They are: -

1. A smallest, base case that is processed without recursion and acts as decision criterion for stopping the process of computation and 

2. A general method that makes a particular case to reach nearer in some sense to the base case.

For eg the problem of finding a factorial of a given number by recursion can be written as 

Factorial (int n)

{ 

int x; 

if n = 0

return (1);

x = n - 1;

return ( n* factorial (x) );

}

in this case the contents of stack for n and x as [n, x] when first pop operation is carried out is as follows 

 [4, 3] [3, 2] [2, 1] [1, 0] [0, -] → top of stack.

Here the relation is simple enough to be represented in an iterative loop, and moreover it can be done without taking the help of stack. So such kind of recursive procedures can always be converted into an iterative procedure. 

The iterative solution for the above problem would be 

Factorial (int n) 

{

int x, fact = 1; 

for ( x = 1 ; x <= n ; x++ )

fact = fact * x;

return fact;

]

If there are no statements after the recursion call, that recursion can be converted to iterative programme very easily.for example:

void fff (parameters) 

{ 

if (condition) 

{ 

step1 

step2 

step3

fff (parameter)

} 

}

whereas, if there are statements after a recursive call, a user stack will be required to convert them into iterative programme. for example:

void fff (parameters)

{

if (condition)

{

step1 

step2 

fff (parameters) 

step3 

step4 

fff (parameter)

}

}

A B-Tree of order M is either the empty tree or it is an M-way search tree T with the following properties:

(i) The root of T has at least two subtrees and at most M subtrees. 

(ii) All internal nodes of T (other than its root) have between [M / 2] and M subtrees.

(iii) All external nodes of T are at the same level. 

Just as AVL trees are balanced binary search trees, B-trees are balanced M-way search trees. By imposing a balance condition, the shape of an AVL tree is constrained in a way which guarantees that the search, insertion, and withdrawal operations are all O(log n), where n is the number of items in the tree. The shapes of B-Trees are constrained for the same reasons and with the same effect. 

Depth-first search is different from Breadth-first search in the following ways: A depth search traversal technique goes to the deepest level of the tree first and then works up while a breadth-first search looks at all possible paths at the same depth before it goes to a deeper level. When we come to a dead end in a depthfirst search, we back up as little as possible. We try another route from a recent vertex-the route on top of our stack. In a breadth-first search, we want to back up as far as possible to find a route originating from the earliest vertices. So the stack is not an appropriate structure for finding an early route because it keeps track of things in the order opposite of their occurrence-the latest route is on top. To keep track of things in the order in which they happened, we use a FIFO queue. The route at the front of the queue is a route from an earlier vertex; the route at the back of the queue is from a later vertex.  

Step Wise Refinement

Refinement is a process of elaboration. Here one begins with a statement of function that is defined at a high-level abstraction. That is the statement describes the program/function conceptually but provides no information about internal working. Refinement causes the programmer to elaborate on the original statement providing more and more detail. In a stepwise refinement, at each step of refinement one or several instructions of the given program are decomposed into more detailed instructions. The successive refinement terminates when all the instructions are expressed in terms of atomic expressions of the language. 

The recursive function printast () for the required task is as follows:- 

void printast (int a) 

{

if (a > 0)

{

printf ("*");

a--;

printast (a); 

}

if (a!=0)

printf ("!");

}

Let G = (v,e) be a simple graph. Let a & z be any two vertices of the graph. Suppose L(x) denotes the label of the vertex z which represents the length of the shortest path from the vertex a to the vertex z. W_ij denotes the weight of the edge e_ig = (V_i , V_j)

1. let P = Q where p is the set of those vertices which have permanent labels & T = {all vertices of the graph G} 

Set L (a) = 0, L (x) = ∞for all x €T & x≠a

2. Select the vertex v in T which has the smallest label. This label is called the permanent label of v.

Also set P = P U {v} and T = T-{v} 

if v=z then L (z) is the length of the shortest path from the vertex a to z and stop. 

3. If v ≠z then revise the labels of vertices of T i.e. the vertices which do not have permanent labels. The new label of a vertex x in T is given by L (x) = min{old L(x),L(v)+w(y,x)} 

where w (v,x) is the weight of the edge joining the vertex v & x

If there is no direct edge joining v & x then take w(v,x) = ∞

4. Repeat steps 2 and 3 until z gets the permanent label. 

AVL Tree

An AVL tree is a binary tree in which the difference in heights between the left and the right subtree is not more than one for every node. 

We can insert a node into an AVL tree by using the insertion algorithm for binary search trees in which we compare the key of the new node with that in the root and then insert the new node into the left subtree or right subtree depending on whether it is less than or greater than that in the root. Insertion may or may not result in change in the height of the tree. While inserting we must take care that the balance factor of any node not changes to values other than 0, 1 and -1. A tree becomes unbalanced if and only if 

(i) The newly inserted node is a left descendant of a node that previously had a balance of 1.

(ii) The newly inserted node is a right descendent of a node that previously had a balance of -1. 

If the balance factor of any node changes during insertion than one of the subtree is rotated one or more times to ensure that the balance factor is restored to correct values. 

(i) Tree (recursive definition) 

A tree is a finite set of one or more nodes such that. 

(1) There is a specially designated node called the root. 

(2) The remaining nodes are partitioned into n>=0 disjoint sets 

T1, T2 ... Tn where each of these sets is a tree. T1, T2 ... Tn are called the subtree of the root.

(ii) Level of a node

The root is at level 0(zero) and the level of any node is 1 more than the level of its parent. 

(iii) Height of a tree

The length of the longest path from root to any node is known as the height of the tree. 

(iv) Complete Binary tree

A complete binary tree can be defined as a binary tree whose non leaf nodes have nonempty left and right sub tree and all leaves are at the same level. 

(v) Internal Path length

It is defined as the number of node traversed while moving through one particular node to any other node in the tree. 

The running time of an algorithm depends upon various characteristics and slight variation in the characteristics varies the running time. The algorithm efficiency and performance in comparison to alternate algorithm is best described by the order of growth of the running time of an algorithm. Suppose one algorithm for a problem has time complexity as c₃n² and another algorithm has c₁n³ +c₂n² then it can be easily observed that the algorithm with complexity c₃n² will be faster than the one with complexity c₁n³ +c₂n² for sufficiently larger values of n. Whatever be the value of c₁, c₂ and c₃ there will be an ‘n’ beyond which the algorithm with complexity c3n² is faster than algorithm with complexity c₁n ³ +c₂n ² , we refer this n as breakeven point.

Here running time of algorithms are 50*n³ and 3ⁿ ,if we compare both as shown in the following table, we find that 10 is the smallest value of n (9.8) for which 50*n³ will run faster than 3ⁿ .

A general polynomial A(x) can be written as a_n Xⁿ + a_{n- 1} X ^n-1 + ...+a₁x+a₀ where an ≠0 then we can represent A(x)

1. As an ordered list of coefficients using a one dimensional array of length n+2, A=(n, a_n, a_n-1,…,a₁, a₀) , the first element is the degree of A followed by n+1 coefficients in order of decreasing exponent. So the given polynomial can be represented as

i. (5,7, -8,5,1,2,15)

ii. (100,3,0,0,0,0…(45 times), -5, 0,0,0…(55 times),-10) 

Advantage of this method is simple algorithms for addition and multiplication as we have avoided the need to explicitly store the exponent of each term. However there is a major disadvantage of this method and that is wastage of memory for certain polynomial like example (ii) because we are storing more zero values than non-zero values. 

2. As an ordered list where we keep only non-zero coefficient along with their exponent like (m,e_m-1,b_m-1,e_m-2,b_m-2,…,e₀,b₀) where first entry is the number of nonzero terms, then for each term there are two entries representing an exponentcoefficient pair. So the given polynomial can be represented as 

i. (6,5,7,4,-8,3,5,2,1,1,2,0,15)

ii. (3,100,3,55,-5,0,-10)

This method is solves our problem of wasted memory like what happened in example 2. 

A two dimensional array is declared similar to the way we declare a one-dimensional array except that we specify the number of elements in both dimensions. For example,

int grades[3][4];

The first bracket ([3]) tells the compiler that we are declaring 3 pointers, each pointing to an array. We are not talking about a pointer variable or pointer array. Instead, we are saying that each element of the first dimension of a two dimensional array reference a corresponding second dimension. In this example, all the arrays pointed to by the first index are of the same size. The second index can be of variable size. For example, the previous statement declares a two-dimensional array where there are 3 elements in the first dimension and 4 elements in the second dimension.

Two-dimensional array is represented in memory in following two ways:

1. Row major representation: To achieve this linear representation, the first row of the array is stored in the first memory locations reserved for the array, then the second row and so on.

2. Column major representation: Here all the elements of the column are stored next to one another.

In row major representation, the address is calculated in a two dimensional array as per the following formula

The address of a[i] [j] =base (a) + (i*m+ j) * size

where base(a) is the address of a[0][0], m is second dimension of array a and size represent size of the data type. 

Similarly in a column major representation, the address of two dimensional array is calculated as per the following formula

The address of a[i] [j] = base (a) + (j*n +i) * size

Where base (a) is the address of a [0] [0], n is the first dimension of array a and size represents the size of the data type.

AVL tree definition: 

1. An empty binary tree a is an AVL tree 

2. If ‘B_t’ is the non-empty binary tree with ‘B_tL’ and ‘B_tR’ as its left and right sub trees, then ‘B_t’ is an AVL tree if only if:

• ‘B_tL’ and ‘B_tR’ are AVL trees and

• | h_L-h_R | ≤ 1 where h_L and h_R are the heights of ‘B_tL’ and ‘BtR’ respectively. | h_L-h_R | is called balance factor of a node, its value can be {-1, 0, 1}

The algorithm to determine whether an infix expression has a balanced parenthesis or not. 

Matching = TRUE 

Clear the stack; 

Read a symbol from input string 

While not end of input string and matching do

{

if (symbol= ‘(‘ or symbol = ‘{’ or symbol = ‘[’ )

push (symbol, stack)

else (if symbol = ‘)’ or symbol = ‘}’ or symbol = ‘]’ 

) 

if stack is empty 

matching = FALSE

write (“more right parenthesis than left parentheses”)

else

c=pop (stack)

match c and the input symbol 

if not matched 

{

matching = FALSE

write (“error, mismatched parentheses”)

}

read the next input symbol

}

if stack is empty then

write ( “ parentheses are balanced properly”) 

else

write (“more left parentheses then right parentheses”)

A Subscriber Identity Module (SIM) card is a portable memory chip used mostly in cell phones. These cards hold the personal information of the account holder, including his or her phone number, address book, text messages, and other data.

Array of structures and arrays within structures:

Structures variables are just like ordinary variables so we can create an array of structures. However arithmetic operations cannot be performed on structure variables. For example, we can create an array of structure student as shown below: 

struct student

{

char name[30]; 

int marks;

struct student list[4]={ { “aaa”,90},{“bbb”,80},{“ccc”,70}}; declare and initialize an array of structure student. 

A Structure is a heterogeneous collection of variables grouped under a single logical entity. An array is also a use-defined data type and hence can be used inside a structure just like an ordinary variable. As in the above example, name is a char array within the structure student. 

A stack is an abstract data type in which items are added to and removed only from one end called TOP. For example, consider the pile of papers on your desk. Suppose you add papers only to the top of the pile or remove them only from the top of the pile. At any point in time, the only paper that is visible is the one on the top. This structure is called stack. The six various application of stack in computer application are:

1. Conversion of infix to post fix notation and vice versa. 

2. Evaluation of arithmetic expression.

3. Problems involving recursion are solved efficiently by making use of stack. For example-Tower of Hanoi problem 

4. Stack is used to maintain the return address whenever control passes from one point to another in a program. 

5. To check if an expression has balanced number of parenthesis or not. 6. To reverse string. 

Here there are 4 operations 

1. q insert front 

2. q insert rear 

3. q delete front 

4. q delete rear

when front = rear = -1, queue is empty when (rear+1) mod size of queue = front queue is full. Here the queue is to be used circularly. 

(1) q insert front 

if (front==rear==-1) 

then front=rear=0 

q (front)=item 

else if(rear+1)mod sizeof q=front 

q is full, insertion not possible else front = (front + sizeof q-1) mod sizeof q

(2) q insert rear 

if (front==rear==-1) 

front=rear=0 

q(rear)=item 

else if (rear+1) mod sizeof queue + front 

queue is full, insertion not possible 

else rear = (rear+1) mode sizeof queue 

q(rear) = item

(3) q delete front 

if (front==rear==-1)

queue is empty

else if (front==rear)

k = q(front), front = rear= -1

return(k)

else k=q(front)

front = (front+1) mod sizeof queue

return (k)

(4) q delete rear

if (front==rear==-1)

queue is empty

else if (front==rear)

k = q(rear), front=rear=-1

return(k)

else

k=q(rear)

rear = (rear +size of queue -1) mod sizeof q 

return (k)

The new operator in C++ allocates memory dynamically. 

Syntax: 

pointervariable = new datatype; 

Example: ptr = new int;

The characteristics of motherboard identifies different kinds of motherboards, including Physical characteristics, which in combination are called the form factor like XT, AT Baby AT and ATX motherboard; The chipset used, which defines the capabilities of the motherboard such as an AMD, Intel, NVidia, SiS, or VIA chipset; The processors the motherboard supports; Different processors use different sockets or slots. Based on the type, there are two main types of slots.

a. Socket 7:
Is a 321-pin socket for Pentium class CPUs – Pentium MMX, K5, K6, etc.,

b. Slot 1:
Pentium ll/IH CPUs use slot 1.

The BIOS it uses – System BIOS is a chip located on all motherboards that contain instructions and set up for how your system should boot and how it operates. The phoenix and AMI are the two BIOS manufacturers and the internal and expansion buses that it supports.

• Let Q be a linear array of size N.
• The pointer FRONT contains location of front element of the queue (element to be deleted)
• The pointer REAR contains location of rear element of the queue (recently added element)
• The queue is empty when FRONT = 0
• The queue is full when REAR = N To add element, REAR = REAR + 1 
• To delete element, FRONT = FRONT +1

Let Q be a linear array of size N.
The pointer FRONT contains location of front element of the queue (element to be deleted)
The pointer REAR contains location of rear element of the queue (recently added element)
The queue is empty when FRONT = 0
The queue is full when FRONT = N
To add element, REAR = REAR + 1
To delete element, FRONT = FRONT + 1

Let A be two-dimensional array
Let M is rows and N is columns

The array may be stored in the memory in one of the following methods:

1. Row-major representation:
In this type of method, the first row occupies the first set of memory locations reserved for the array and second-row occupies the next set and so on.

2. Column-major representation:
In this type of method, the first column occupies the first set of memory locations reserved for the array and the second column occupies the next set and so on.

1. A pointer is a variable that holds the memory address, usually the location of another variable.

2. The fixed size of memory allocation and cannot be altered during runtime is called static memory allocation.

3. Allocation of memory at the time of execution (run time) is known as dynamic memory allocation.

The correct answer is Etikoppaka.

• Etikoppaka
  • Located on the banks of the river Varaha in Vishakhapatnam district of AP, is a small village called Etikoppaka.
  • Made in the Etikoppaka region of Andhra Pradesh, these toys are made with lacquer colour and are traditionally known as Etikoppaka toys or Etikoppaka Bommalu.
  • The village is very famous for its toys made of wood.
  • The toys are also called as lacquer toys because of the application of lacquer coating.​

• The village has a glorious history where the local zamindars started recognizing the possibility of making splendid and attractive toys much before independence.
• These are well known for canon toys, lord Ganesha form and bullock etc.
• The toys are made out of wood and are coloured with natural dyes derived from seeds, lacquer, bark, roots and leaves.
• The wood used to make the toys is soft in nature and the art of toy making is also known as Turned wood Lacquer craft. While making the Etikoppaka toys, lac, a colourless resinous secretion of numerous insects, is used.
• The already prepared vegetable dyes are further mixed to the lac, during the process of oxidation.
• After this process, the end product obtained is rich and coloured lacquer.
• The lac dye is used for decorating the Etikoppaka toys, which are exported all over the world.

The correct answer is Shilparamam.

• Shilparamam
  • Shilparamam which literally translates into 'Crafts Village' in English, seeks to keep arts & crafts relevant- to people in general, become a part of daily life, and to artisans for whom crafts are more than a mere livelihood- they are a way of life.
  • Shilparamam literally translates into ‘Crafts Village’ in English.
  • Shilparamam seeks to keep craft relevant- to people in general so that crafts and thereby culture can become a part of daily life, and to artisans for whom crafts are more than a mere livelihood- they are a way of life.
  • Shilparamam Society under the Department of Tourism and Culture, Government of Andhra Pradesh is a registered body under the AP Societies Registration Act, 2001 is mandated to keep alive State’s arts, crafts, cuisine and other cultural aspects through promotion, preservation and popularization.

• An enterprise of the Andhra Pradesh Government, Lepakshi Corporation was set up in the year 1982 for the promotion, development and marketing of handicrafts besides implementing schemes for the welfare of artisans.
• Lepakshi’s vision - "An Empowered Artisan Community Thriving in an 'Enabling' Environment" guides the organization in its successful journey with a total of 12+2 Showrooms (12 in AP , 1 in Kolkata and 1 in New Delhi) across Andhra Pradesh and India.

• The State of Uttar Pradesh is bounded by Uttarakhand in the North, Madhya Pradesh and Chhattisgarh in the South. 
• The states of Rajasthan, Haryana and Delhi are located on the west of UP whereas Bihar and Jharkhand lie on the east. 
• It does not share the border with the Indian state of Gujarat. 

The members of various houses of Legislative Assembly and Parliament from Uttar Pradesh are as follows: