#include <iostream>
using namespace std;
int main() {
    int i, num, n, count;
    cout << "Enter the range: "; 
    cin >> n;
    cout << "The prime numbers in between the range 1 to " << n << " are: ";

    for (num = 1; num <= n; num++) {
        count = 0;
        for (i = 2; i <= num / 2; i++) {
            if (num % i == 0) {
                count++;
                break;
            }
        }
        if (count == 0 && num != 1)
            cout << num << " ";
    }

    return 0;
}

Sample I/O:
Enter the range: 50
The prime numbers in between the range 1 to 50 are: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 

=== Code Execution Successful ===

🔗 Run Online: Prime number between range

#include <iostream>
using namespace std;
int main() {
    int i, j, n, p, q;
    cout << "Input number of rows: "; 
    cin >> n;
    for (i = 1; i <= n; i++) {
        if (i % 2 == 0) {
            p = 1;
            q = 0;
        } else {
            p = 0;
            q = 1;
        }
        for (j = 1; j <= i; j++) {
            if (j % 2 == 0)
                cout << p;
            else
                cout << q;
        }
        cout << endl;
    }
    return 0;
}

Sample I/O:
Input number of rows: 6
1
01
101
0101
10101
010101
=== Code Execution Successful ===

#include <iostream>
using namespace std;
int main() {
    int n, i, sum = 0, term = 1, nextTerm;
    cout << "Enter the value of n: "; 
    cin >> n;
    cout << "The series is: ";
    for (i = 1; i <= n; i++) {
        cout << term << " ";
        sum += term;
        nextTerm = term + i;
        term = nextTerm;
    }

    cout << "\nThe sum of the series is: " << sum << endl;
    return 0;
}

Sample I/O:
Enter the value of n: 10
The series is: 1 2 4 7 11 16 22 29 37 46 
The sum of the series is: 175

=== Code Execution Successful ===

Step-by-Step Execution

1. Initial call: fun(5)

   • x = 5
   • Print 5
   • x-- (post-decrement) → Pass x = 4 to fun(--x)

2. Recursive call: fun(3)

   • x = 3
   • Print 3
   • x-- (post-decrement) → Pass x = 2 to fun(--x)

3. Recursive call: fun(1)

   • x = 1
   • Print 1
   • x-- (post-decrement) → Pass x = 0 to fun(--x)

4. Recursive call: fun(-1)

   • x = -1
   • The if(x<0) return; triggers, stopping recursion.
   • Nothing is printed here.

5. Returning from fun(1):

   • x = -1 at this point (because x was decremented before recursion)
   • Print -1

6. Returning from fun(3):

   • x = 1
   • Print 1

7. Returning from fun(5):

   • x = 3
   • Print 3

Polymorphism means “having many forms.” It allows the same method or function to perform different tasks based on the context. In simpler terms, it enables a single interface to represent different functionalities.

Polymorphism can be broadly categorized into two types:

1. Compile-time Polymorphism (Static Polymorphism)
2. Runtime Polymorphism (Dynamic Polymorphism)

1. Compile-time Polymorphism (Static Polymorphism)

Compile-time polymorphism is achieved through method overloading and operator overloading. The method to be executed is determined at compile time based on the method signature.

2. Runtime Polymorphism (Dynamic Polymorphism)

Runtime polymorphism is achieved through method overriding. The method to be executed is determined at runtime based on the object being referred to.

🎥 Video Solution: Polymorphism & its types.

Multithreading Programming

Multithreading programming is a technique where a single program is divided into multiple threads that can run at the same time. Each thread represents a small unit of execution, allowing the program to perform multiple tasks concurrently within the same process.

Why Multithreading is Used

Multithreading is used to improve the performance and responsiveness of applications. It allows better utilization of CPU resources, enables tasks to run in parallel on multi-core processors, and helps keep programs responsive while performing time-consuming operations such as file processing or network communication.

In Database Management Systems (DBMS), relationships define how data in different tables are connected. There are three main types of relationships in a relational database:

1. One-to-One (1:1) Relationship:
Each record in Table A is linked to only one record in Table B, and vice versa.

Example:

• A person and their passport (One person has only one passport, and one passport belongs to one person).

2. One-to-Many (1:M) Relationship:
A record in Table A can be linked to multiple records in Table B, but each record in Table B is linked to only one record in Table A.

Example:

• A customer can place multiple orders, but each order belongs to only one customer.

3. Many-to-Many (M:N) Relationship:
Each record in Table A can be linked to multiple records in Table B, and vice versa.

Example:

• A doctor can treat multiple patients, and a patient can have multiple doctors.

Order: Stack follows LIFO (Last In First Out); Queue follows FIFO (First In First Out).

Insertion: In Stack, insertion is called push; in Queue, it is called enqueue.

Deletion: In Stack, deletion is called pop; in Queue, it is called dequeue.

Access: Stack allows access to the top element only; Queue allows access from front and rear.

Structure: Stack works like a vertical pile; Queue works like a line (queue).

Example: Stack → plates stack; Queue → people standing in a line.

Problems Solved by Stack:

1. Balancing Parentheses (Expression Validation)
2. Backtracking (Undo Operation)

Problems Solved by Queue:

1. Task Scheduling (CPU Scheduling)
2. BFS (Breadth-First Search) in Graphs