• To print pyramid triangle in C++, we have use two for loop, the outer for loop and the inner for loop.
• The outer for loop is responsible for rows and the inner for loop is responsible for column.
• C++ programs to print different types of patterns using stars(*), numbers, and characters or alphabets.
• This C++ program prints the full pyramid using stars(*).

Sample Code in C++

#include <iostream>
using namespace std;
   int main()
{
    int j, rows;
       cout <<"Enter number of rows: ";
    cin >> rows;
       for(int i = 1, k = 0; i <= rows; ++i, k = 0)
    {
        for(j = 1; j <= rows-i; ++j)
        {
            cout <<"  ";
        }
        while(k != 2*i-1)
        {
            cout << "* ";
            ++k;
        }
        cout << endl;
    }    
    return 0;
}

Output

Enter number of rows : 7   
            * 
          * * * 
        * * * * * 
      * * * * * * * 
    * * * * * * * * * 
  * * * * * * * * * * * 
* * * * * * * * * * * * * 

• A dangling pointer is pointing to a memory location that has been deleted (or freed). The dangling pointer act as a different ways there are,
  • De-allocation of memory
  • Function Call
  • Variable goes out of scope

To find easy to way of Divisibility by 11,

• The multiples of 11: 22, 33, 44, 55, etc. But we did’t easy to find the number 2728, 54695 is divisible by 11.
• Here an easy way to test for divisibility by 11. Take the alternating sum of the digits in the number, read from left to right. If that is divisible by 11, so is the original number.
• So, for example, 2728 has alternating sum of digits 2-7+2-8 = -11. Since -11 is divisible by 11, so is 2728.
• Similarly, for 54695, the alternating sum of digits is 5-4+6-9+5 = 3. This is not divisible by 11, so neither is 54695.

n = 122164154695
Queries: l = 0 r = 3, l = 1 r = 2, l = 5 r = 9, l = 0 r = 11

True
True
False
True

#include <iostream> 
using namespace std; 
  
const int MAX = 1000005; 
  
// To store sums of even and odd digits 
struct OddEvenSums 
{ 
    int e_sum; // Sum of even placed digits 
  
    int o_sum; // Sum of odd placed digits 
}; 
  
OddEvenSums sum[MAX]; // Auxiliary array 
  
// Utility function to evaluate a character's 
// integer value 
int toInt(char x) 
{ 
    return int(x) - 48; 
} 
  
// This function receives the string representation 
// of the number and precomputes the sum array 
void preCompute(string x) 
{  
    sum[0].e_sum = sum[0].o_sum = 0; // Initialize everb 
  
    // Add the respective digits depending on whether 
    // they're even indexed or odd indexed 
    for (int i=0; i<x.length(); i++) 
    { 
        if (i%2==0) 
        { 
            sum[i+1].e_sum = sum[i].e_sum+toInt(x[i]); 
            sum[i+1].o_sum = sum[i].o_sum; 
        } 
        else
        { 
            sum[i+1].o_sum = sum[i].o_sum+toInt(x[i]); 
            sum[i+1].e_sum = sum[i].e_sum; 
        } 
    } 
} 
  
// This function receives l and r representing 
// the indices and prints the required output 
bool query(int l,int r) 
{ 
    int diff = (sum[r+1].e_sum - sum[r+1].o_sum) - (sum[l].e_sum - sum[l].o_sum); 
  
    return (diff%11==0); 
} 
  
//driver function to check the program 
int main() 
{ 
    string s = "122164154695"; 
  
    preCompute(s); 
  
    cout << query(0, 3) << endl; 
    cout << query(1, 2) << endl; 
    cout << query(5, 9) << endl; 
    cout << query(0, 11) << endl; 
  
    return 0; 
} 

1 
1
0
1

• Sort an array elements means arrange elements of array in ascending order and descending order.

• Find number of digits in the largest number. Let us assume number of digits be n.
• Create extended version of all numbers. In extended version, we have n+1 digit formed by concatenating the number of with itself and truncating extra digits.
• Sorting the value from original numbers according to their extended values.
• Concatenating to the sorted numbers produce the required result.

• Polymorphism means having many forms that in a single entity can takes more than one form.

• • Subtype polymorphism is also known as runtime polymorphism
  • Parametric polymorphism is also known as compile-time polymorphism
  • Ad-hoc polymorphism is also known as overloading
  • Coercion is also known as (implicit or explicit) casting

• In C++, A pure virtual function or abstract function is a virtual function for which we don’t have implementation, we only declare it. A pure virtual function is declared by assigning 0 in declaration.

• Abstract Class is a class which contains atleast one Pure Virtual function.
• An abstract class is a class that is designed to be specifically used as a base class.
• It is used to provide an Interface for its sub classes.
• Classes inheriting an Abstract Class must provide definition to the pure virtual function, otherwise they will also become abstract class.
• You declare a pure virtual function by using a pure specifier (= 0) in the declaration of a virtual member function in the class declaration.

• Dynamic binding (dynamic dispatch) means that a block of code executed with reference to a procedure call is determined at run time.

• When two or more objects are derived from a common base class, we can prevent multiple copies of the base class being present in an object derived from those objects by declaring the base class as virtual when it is being inherited such a base class is known as virtual base class.
• Virtual base classes, used in virtual inheritance, is a way of preventing multiple “instances” of a given class appearing in an inheritance hierarchy when using multiple inheritance.

• Accessing a data member depends only on the access control of that data member. If its public, then the data member can be easily accessed using the direct member access (.) operator with the object of that class.
• If, the data member is defined as private or protected, then we cannot access the data variables directly. Then we will have to create special public member functions to access, use or initialize the private and protected data members.
• These member functions are also called Accessors and Mutator methods or getter and setter functions.

• • 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.

• Derived classes can access protected and public members of it’s base class, and the derived class can not access the private members of it’s base class.
• The private members are inherited for the following reason :
  • The base class can define a protected or public function that modifies the base class’s private member.

• Encapsulation is a mechanism that puts the data and function together.
• It is the result of hiding implementation details of an object from its user.
• The object hides its data to de accessed by only those functions which are packed in the class of that object.

• Data hiding is hiding the details of internal data members of an object. Data hiding is also known as Information hiding.

• It can be defined as the separation of unnecessary details or explanation from system requirements so as to reduce the complexities of understanding requirements.

• It is a mechanism that puts the data and function together. It is the result of hiding implementation details of an object from its user.The object hides its data to de accessed by only those functions which are packed in the class of that object.

• Dynamic binding is the process of resolving the function to be associated with the respective functions calls during their runtime rather than compile time.