telibrahma interview questions and answers - Wikitechy

What is Polymorphism in Java ?

Editor — Tue, 13 Jul 2021 23:07:15 +0000

What is Polymorphism in Java ?

Polymorphism in Java is a concept in different ways we can perform a single action.
Poly and morphs. The word “poly” means many and “morphs” means forms. Many forms are known as polymorphism.

There are two types of polymorphism in Java:
- Compile-Time Polymorphism and
- Runtime Polymorphism.

Polymorphism in java we can perform by method overloading and method overriding.

Dynamic Method Dispatch or Runtime Polymorphism in Java

Java supports Runtime Polymorphism is one of the ways is method overriding
A call to an overridden method is resolved at run time, rather than compile time it is called as dynamic method dispatch mechanism.
At run-time, it depends on the type of the object being referred that determines which version of an overridden method will be executed.
A subclass object refers by a superclass variable. This is also known as upcasting. Java uses this statistic to resolve calls to overridden methods at run time.

Example of Java Runtime Polymorphism

 
class Bike{  
  void run(){System.out.println("running");}  
}  
class Splendor extends Bike{  
  void run(){System.out.println("running safely with 60km");}  
  
  public static void main(String args[]){  
    Bike b = new Splendor();//upcasting  
    b.run();  
  }  
} 

Output

running safely with 60km.

Detect loop in a linked list ?

Editor — Tue, 13 Jul 2021 11:08:43 +0000

Detect loop in a linked list ?

There are two ways to detect loop in linked list or not.

Method 1:

Traverse through each node till end , tracking visited node using Hash map.
If you find node that is already visited, then there is a loop in LinkedList
If you reach till end while traversing then there is no loop in LinkedList

using namespace std; 

struct Node 
{ 
	int data; 
	struct Node* next; 
}; 

void push(struct Node** head_ref, int new_data) 
{ 

	struct Node* new_node = new Node; 

	
	new_node->data = new_data; 

	/* link the old list off the new node */
	new_node->next = (*head_ref); 

	/* move the head to point to the new node */
	(*head_ref) = new_node; 
} 

// Returns true if there is a loop in linked list 
// else returns false. 
bool detectLoop(struct Node *h) 
{ 
	unordered_set s; 
	while (h != NULL) 
	{ 
		// If this node is already present 
		// in hashmap it means there is a cycle 
		// (Because you we encountering the 
		// node for the second time). 
		if (s.find(h) != s.end()) 
			return true; 

		// If we are seeing the node for 
		// the first time, insert it in hash 
		s.insert(h); 

		h = h->next; 
	} 

	return false; 
} 

/* Drier program to test above function*/
int main() 
{ 
	/* Start with the empty list */
	struct Node* head = NULL; 

	push(&head, 21); 
	push(&head, 14); 
	push(&head, 5); 
	push(&head, 10); 

	/* Create a loop for testing */
	head->next->next->next->next = head; 

	if (detectLoop(head)) 
		cout << "Loop found"; 
	else
		cout << "No Loop"; 

	return 0; 
}

Output:

Loop found

Method 2:

Efficient approach for this problem would be Floyd’s cycle detection algorithm, so steps for this algorithm would be:

- Use two pointer fastPtr and slowPtr and initialize both to head of linkedlist
- Move fastPtr by two nodes and slowPtr by one node in each iteration.
- If fastPtr and slowPtr meet at some iteration , then there is a loop in linkedlist.
- If fastPtr reaches to the end of linkedlist without meeting slow pointer then there is no loop in linkedlist (i.e fastPtr->next or fastPtr->next->next become null).

// C program to detect loop in a linked list 
#include 
#include 
/* Link list node */
struct Node 
{ 
	int data; 
	struct Node* next; 
}; 

void push(struct Node** head_ref, int new_data) 
{ 
	/* allocate node */
	struct Node* new_node = 
		(struct Node*) malloc(sizeof(struct Node)); 

	/* put in the data */
	new_node->data = new_data; 

	/* link the old list off the new node */
	new_node->next = (*head_ref); 

	/* move the head to point to the new node */
	(*head_ref) = new_node; 
} 

int detectloop(struct Node *list) 
{ 
	struct Node *slow_p = list, *fast_p = list; 

	while (slow_p && fast_p && fast_p->next ) 
	{ 
		slow_p = slow_p->next; 
		fast_p = fast_p->next->next; 
		if (slow_p == fast_p) 
		{ 
		printf("Found Loop"); 
		return 1; 
		} 
	} 
	return 0; 
} 

/* Drier program to test above function*/
int main() 
{ 
	/* Start with the empty list */
	struct Node* head = NULL; 

	push(&head, 10); 
	push(&head, 4); 
	push(&head, 5); 
	push(&head, 10); 

	/* Create a loop for testing */
	head->next->next->next->next = head; 
	detectloop(head); 

	return 0; 
}

Output:

Found Loop

What is pure virtual function in C++ ?

Editor — Mon, 12 Jul 2021 22:24:30 +0000

What is pure virtual function in C++ ?

- A virtual function will become pure virtual function when you append “=0” at the end of declaration of virtual function.
- Pure virtual function doesn’t have body or implementation. We must implement all pure virtual functions in derived class.

Pure virtual function is also known as abstract function.
A class with at least one pure virtual function or abstract function is called abstract class. We can’t create an object of abstract class. Member functions of abstract class will be invoked by derived class object.

Sample Code

#include
       #include

       class BaseClass       //Abstract class
       {

              public:
               virtual void Display1()=0;     //Pure virtual function or abstract function
               virtual void Display2()=0;     //Pure virtual function or abstract function

               void Method3()
               {
                      cout<<"\n\tMethod3() is Base Class";
               }

       };

       class DerivedClass : public BaseClass
       {

              public:
               void Method1()
               {
                      cout<<"\n\tMethod1() is Derived Class";
               }

               void Method2()
               {
                      cout<<"\n\tMethod2() is Derived Class";
               }

       };

       void main()
       {

              DerivedClass D;

              D.Method1();            // This will invoke Method1() Derived Class
              D.Method2();            // This will invoke Method2() Derived Class
              D.Method3();            // This will invoke Method3() Base Class

       }

Output

Method1() is Derived Class
Method2() is Derived Class 
Method3() is Base Class

How to find LCM of two Numbers in C ?

Editor — Mon, 12 Jul 2021 21:04:03 +0000

To Find LCM of Two Numbers in C

The LCM of two numbers a and b is the smallest positive integer that is perfectly divisible by both a and b (without a remainder). For example: The LCM of 72 and 120 is 360.

Sample Code

#include  
// Recursive function to return gcd of a and b
int gcd(int a, int b)
{
// Everything divides 0
    if (a == 0 || b == 0)
        return 0;
// Base case
    if (a == b)
        return a;
// a is greater
    if (a > b)
        return gcd(a-b, b);
    return gcd(a, b-a);
}
// Function to return LCM of two numbers
int lcm(int a, int b)
{
    return (a*b)/gcd(a, b);
}
// Driver program to test above function
int main()
{
    int a = 10, b = 28;
    printf("LCM of %d and %d is %d ", a, b, lcm(a, b));
    return 0;
}

Output

LCM of 10 and 28 is 140

Pattern programs in C ?

Editor — Mon, 12 Jul 2021 20:26:13 +0000

Pattern programs in C ?

Pattern programs in C print various patterns of numbers and stars. These codes explain how to create various patterns using C programming. The C programs involve usage of nested for loops (a for loop inside a for loop).
A pattern of numbers, star or characters is a way of arranging these in some logical manner or they may form a sequence. Some of these patterns are triangles which have special importance in mathematics.

Example 1

Sample Code in C:

#include 
int main()
{
    int i, space, rows, k=0;

    printf("Enter number of rows: ");
    scanf("%d",&rows);

    for(i=1; i<=rows; ++i, k=0)
    {
        for(space=1; space<=rows-i; ++space)
        {
            printf("  ");
        }

        while(k != 2*i-1)
        {
            printf("* ");
            ++k;
        }

        printf("\n");
    }
    
    return 0;
}

Output

Enter number of rows : 5

        *
      * * *
    * * * * *
  * * * * * * *
* * * * * * * * *

Example 2

Sample Code in C:

#include 
int main()
{
    int i, space, rows, k=0, count = 0, count1 = 0;

    printf("Enter number of rows: \n");
    scanf("%d",&rows);

    for(i=1; i<=rows; ++i)
    {
        for(space=1; space <= rows-i; ++space)
        {
            printf("  ");
            ++count;
        }

        while(k != 2*i-1)
        {
            if (count <= rows-1)
            {
                printf("%d ", i+k);
                ++count;
            }
            else
            {
                ++count1;
                printf("%d ", (i+k-2*count1));
            }
            ++k;
        }
        count1 = count = k = 0;

        printf("\n");
    }
    return 0;
}

Output

Enter number of rows : 5

         1 
      2 3 2 
    3 4 5 4 3 
  4 5 6 7 6 5 4 
5 6 7 8 9 8 7 6 5