10 Important Classical Programming

Interview Questions











Classical Programming Interview Questions


Powered by













Contents

Q. How can we sum the digits of a given number in single statement? ....................................... 3
Q. Solve the Rat In A Maze problem using backtracking. ................................................................ 3
Q. Write C code to solve the Tower of Hanoi problem. ..................................................................... 6
Q. Write C code to check if an integer is a power of 2 or not in a single line? .............................. 6
Q. How to compare two linked lists? Write a C program to compare two linked lists. .............. 6
Q. How would you detect a loop in a linked list? Write a C program to do the same ................. 7
Q. Write a C program to return the nth node from the end of a linked list. ................................... 8
Q. How do you find the middle of a linked list? Write a C program to find the same ................. 9
Q. Write a C program to find the depth or height of a tree. ............................................................ 10
Q. Write a C program to delete a node from a Binary Search Tree? ............................................ 11















Q. How can we sum the digits of a given number in single
statement?

Answer:

Q. Solve the Rat In A Maze problem using backtracking.

Answer:

This is one of the classical problems of computer science. There is a rat trapped in a
maze. There are multiple paths in the maze from the starting point to the ending
point. There is some cheese at the exit. The rat starts from the entrance of the maze
and wants to get to the cheese.

This problem can be attacked as follows:
Have a m*m matrix which represents the maze.
For the sake of simplifying the implementation, have a boundary around your
matrix and fill it up with all ones. This is so that you know when the rat is
trying to go out of the boundary of the maze. In the real world, the rat would
know not to go out of the maze, but hey! So, initially the matrix (I mean, the
maze) would be something like (the ones represent the "extra" boundary we
have added). The ones inside specify the obstacles.

111111111111111111111
100000000000000000001
100000010000000000001
100000010000000000001
100000000100001000001
100001000010000000001
100000000100000000001
100000000000000000001
111111111111111111111

#include<stdio.h>

void main() {
int num = 123456;
int sum = 0;
for (; num > 0; sum += num % 10, num /= 10);
// This is the "single line".
printf("\nsum = [%d]\n", sum);
}




The rat can move in four directions at any point in time (well, right, left, up,
down). Please note that the rat can't move diagonally. Imagine a real maze
and not a matrix. In matrix language
o Moving right means adding {0,1} to the current coordinates.
o Moving left means adding {0,-1} to the current coordinates.
o Moving up means adding {-1,0} to the current coordinates.
o Moving right means adding {1,0} to the current coordinates.
The rat can start off at the first row and the first column as the entrance point.
From there, it tries to move to a cell which is currently free. A cell is free if it
has a zero in it.
It tries all the 4 options one-by-one, till it finds an empty cell. If it finds one, it
moves to that cell and marks it with a 1 (saying it has visited it once). Then it
continues to move ahead from that cell to other cells.
If at a particular cell, it runs out of all the 4 options (that is it cant move either
right, left, up or down), then it needs to backtrack. It backtracks till a point
where it can move ahead and be closer to the exit.
If it reaches the exit point, it gets the cheese, of course.
The complexity is O(m*m).
Here is some pseudo code to chew upon
findpath()
{
Position offset[4];
Offset[0].row=0; offset[0].col=1; //right;
Offset[1].row=1; offset[1].col=0;//down;
Offset[2].row=0; offset[2].col=-1;//left;
Offset[3].row=-1; offset[3].col=0;//up;

// Initialize wall of obstacles around the maze
for(int i=0; i<m+1;i++)
maze[0][i] = maze[m+1][i]=1; maze[i][0] = maze[i][m+1]=1;

Position here;
Here.row=1;
Here.col=1;

maze[1][1]=1;
int option = 0;
int lastoption = 3;

while(here.row!=m || here.col!=m)
{
//Find a neighbor to move
int r,c;







while (option<=LastOption)
{
r=here.row + offset[position].row;
c=here.col + offset[option].col;
if(maze[r][c]==0)break;
option++;
}

//Was a neighbor found?
if(option<=LastOption)
{
path->Add(here);
here.row=r;here.col=c;
maze[r][c]=1;
option=0;
}
else
{
if(path->Empty())return(False);
Position next;
Path->Delete(next);
If(new.row==here.row)
Option=2+next.col - here.col;
Else {option = 3 + next.row - here.col;}
Here=next;
}
return(TRUE);
}
}


Q. Write C code to solve the Tower of Hanoi problem.

Answer:

main()
{
towers_of_hanio(n,'L','R','C');
}

towers_of_hanio(int n, char from, char to, char temp)
{
if(n>0)
{
tower_of_hanio(n-1, from, temp, to);
printf("\nMove disk %d from %c to %c\n", n, from, to);
tower_of_hanio(n-1, temp, to, from);
}
}
Q. Write C code to check if an integer is a power of 2 or not in a
single line?

Answer:

Method1

if(!(num & (num - 1)) && num)
{
// Power of 2!
}

Method2

if(((~i+1)&i)==i)
{
//Power of 2!
}
Q. How to compare two linked lists? Write a C program to
compare two linked lists.

Answer:

int compare_linked_lists(struct node *q, struct node *r) {
static int flag;






if ((q == NULL) && (r == NULL)) {

flag = 1;
} else {
if (q == NULL || r == NULL) {
flag = 0;
}
if (q->data != r->data) {
flag = 0;
} else {
compare_linked_lists(q->link, r->link);
}
}
return (flag);
}

Another way is to do it on similar lines as strcmp() compares two strings, character
by character (here each node is like a character).
Q. How would you detect a loop in a linked list? Write a C
program to detect a loop in a linked list.

Answer:

Brute force method

Have a double loop, where you check the node pointed to by the outer loop, with
every node of the inner loop.
typedef struct node {
void *data;
struct node *next;
} mynode;

mynode * find_loop(NODE * head) {
mynode *current = head;

while (current->next != NULL) {
mynode *temp = head;
while (temp->next != NULL && temp != current) {
if (current->next == temp) {
printf("\nFound a loop.");
return current;
}
temp = temp->next;
}
current = current->next;
}
return NULL;



}

Visited flag

Have a visited flag in each node of the linked list. Flag it as visited when you reach
the node. When you reach a node and the flag is already flagged as visited, then you
know there is a loop in the linked list.

Fastest method

Have 2 pointers to start of the linked list. Increment one pointer by 1 node and the
other by 2 nodes. If there's a loop, the 2nd pointer will meet the 1st pointer
somewhere. If it does, then you know there's one.

Here is some code
p=head;
q=head->next;

while(p!=NULL && q!=NULL)
{
if(p==q)
{
//Loop detected!
exit(0);
}
p=p->next;
q=(q->next)?(q->next->next):q->next;
}

// No loop.

Q. Write a C program to return the nth node from the end of a
linked list.

Answer:

Here is a solution which is often called as the solution that uses frames.

Suppose one needs to get to the 6th node from the end in this LL. First, just keep on
incrementing the first pointer (ptr1) till the number of increments cross n (which is 6
in this case)

STEP 1:
1(ptr1,ptr2) -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> 10

STEP 2:





1(ptr2) -> 2 -> 3 -> 4 -> 5 -> 6(ptr1) -> 7 -> 8 -> 9 -> 10

Now, start the second pointer (ptr2) and keep on incrementing it till the first pointer
(ptr1) reaches the end of the LL.

STEP 3:
1 -> 2 -> 3 -> 4(ptr2) -> 5 -> 6 -> 7 -> 8 -> 9 -> 10 (ptr1)

So here you have!, the 6th node from the end pointed to by ptr2!
Here is some C code..
struct node {
int data;
struct node *next;
} mynode;

mynode * nthNode(mynode *head, int n /*pass 0 for last node*/) {
mynode *ptr1, *ptr2;
int count;

if (!head) {
return (NULL);
}

ptr1 = head;
ptr2 = head;
count = 0;

while (count < n) {
count++;
if ((ptr1 = ptr1->next) == NULL) {
//Length of the linked list less than n. Error.
return (NULL);
}
}

while ((ptr1 = ptr1->next) != NULL) {
ptr2 = ptr2->next;
}

return (ptr2);
}











Q. How do you find the middle of a linked list? Write a C program
to return the middle of a linked list

Answer:

Method1
p=head;
q=head;


if(q->next->next!=NULL)
{
p=p->next;
q=q->next->next;
}

printf("The middle element is %d",p->data);

Here p moves one step, where as q moves two steps, when q reaches end, p will be
at the middle of the linked list.

Method 2

struct node *middle(struct node *head) {
struct node *middle = NULL;
int i;
for (i = 1; head; head = head->next, i++) {
if (i == 1)
middle = head;
else if ((i % 2) == 1)
middle = middle->next;
}
return middle;
}

In a similar way, we can find the 1/3 th node of linked list by changing (i%2==1) to
(i%3==1) and in the same way we can find nth node of list by changing (i%2==1) to
(i%n==1) but make sure ur (n<=i).
Q. Write a C program to find the depth or height of a tree.

Answer:

Here is some C code to get the height of the three

tree_height(mynode *p)
{





if(p==NULL)return(0);
if(p->left) {h1=tree_height(p->left);}
if(p=>right) {h2=tree_height(p->right);}
return(max(h1,h2)+1);
}

The degree of the leaf is zero. The degree of a tree is the max of its element
degrees. A binary tree of height n, h > 0, has at least h and at most (2^h -1) elements
in it. The height of a binary tree that contains n, n>0, elements is at most n and
atleast log(n+1) to the base 2.

Log(n+1) to the base 2 = h

n = (2^h - 1)
Q. Write a C program to delete a node from a Binary Search
Tree?

Answer:

The node to be deleted might be in the following states
The node does not exist in the tree - In this case you have nothing to delete.
The node to be deleted has no children - The memory occupied by this node
must be freed and either the left link or the right link of the parent of this node
must be set to NULL.
The node to be deleted has exactly one child - We have to adjust the pointer of
the parent of the node to be deleted such that after deletion it points to the
child of the node being deleted.
The node to be deleted has two children - We need to find the inorder
successor of the node to be deleted. The data of the inorder successor must
be copied into the node to be deleted and a pointer should be setup to the in
order successor. This inorder successor would have one or zero children. This
node should be deleted using the same procedure as for deleting a one child or
a zero child node. Thus the whole logic of deleting a node with two children is
to locate the inorder successor, copy its data and reduce the problem to a
simple deletion of a node with one or zero children.
Here is some C code for these two situations

Situation 1

100 (parent)

50 (cur == psuc)

20 80 (suc)

90



85 95

Situation 2

100 (parent)

50 (cur)

20 90

80


70 (suc)

75

72 76

mynode *delete(int item, mynode *head)
{
mynode *cur, *parent, *suc, *psuc, q;
if(head->left==NULL) {printf("\nEmpty tree!\n");return(head);}
parent = head;
cur = head->left;

while(cur!=NULL && item != cur->value)
{
parent = cur;
cur = (item < cur->next)? cur->left:cur->right;
}

if(cur == NULL)
{
printf("\nItem to be deleted not found!\n");
return(head);
}

// Item found, now delete it

if(cur->left == NULL)
q = cur->right;
elseif(cur->right == NULL)
q = cur->left;
else
{
// Obtain the inorder successor and its parent

psuc = cur;
cur = cur->left;



while(suc->left!=NULL)
{
psuc = suc;
suc = suc->left;
}

if(cur==psuc)
{
// Situation 1

suc->left = cur->right;
}

else
{
// Situation 2

suc->left = cur->left;
psuc->left = suc->right;
suc->right = cur->right;
}

q = suc;

}

// Attach q to the parent node

if(parent->left == cur)
parent->left=q;
else
parent->rlink=q;
freeNode(cur);
return(head);
}
















Study on the go; get high quality complete preparation
courses now on your mobile!