# **Questions**

1. C Programming: What is the value of **`v`** in the following code snippet?

    unsigned long v1 = 0x00001111;
    unsigned long v2 = 0x00001202;
    unsigned long v;
    v = v1 & (~v2);
    v = v | v2;
    

2. C Programming: What is the value of **`fun(456) + fun(123) + fun(789)`** in the following function?

    int fun(int x){
        int count = 0;
        while(x){
            count++;
            x = x & (x-1);
        }
        return count;
    }

3. C Programming: What is the output of the following code snippet?

    int a = 25;
    int b = 30;
    int ques1 = a++ + b++;
    int ques2 = ++a + ++b;
    printf("%d, %d", ques1, ques2);

4. Operating Systems: What is a Process and what is a Thread?
5. Operating Systems: What is Deadlock? What are its necessary conditions and how can it be prevented?
6. Object-Oriented Programming: Design a simple classification system for the animal kingdom. Include at least three classes: Animal, Mammal, and Bird. Demonstrate the concepts of inheritance and polymorphism.
7. C Programming: Implement the Swap function and finish the following code.

    void Swap(){
    
    }
    
    int main()
    {
        // Code here
        return 0;
    }

8. C Programming: Define the variable **`a`** according to the following requirements:
- declare a as int
- declare a as pointer to int
- declare a as pointer to pointer to int
- declare a as array 10 of int
- declare a as array 10 of pointer to int
- declare a as pointer to array 10 of int
- declare a as pointer to function (int) returning int
- declare a as array 10 of pointer to function (int) returning int
9. Version Control: Explain the differences and use cases between "git rebase" and "git merge".
10. Software Architecture: What is the MVC architecture? Describe the functions of its components and how they interact.

---

# Answer

1. The value of **`v`** is **`0x00001313`**.

**Note**: **`~v2 = 0xffffedfd`**, thus **`v1&(~v2)`** = **`0x00001111 & 0xffffedfd = 0x111`**. This operation results in 1s for the lower four 16-bit values that are odd. **`0x111 | v2 = 0x111 | 0x1202 = 0x1313`**.

2. **`fun(456) + fun(123) + fun(789) = 15`**

**Note**: The function **`fun`** calculates the number of 1's in the binary representation of the input numbers.

3. The output is **`55, 59`**.

**Note**: The right side operations are processed later, and the left side operations are processed first. Therefore, the first line will perform **`a + b`** first, which is the value obtained by **`ques1`**, and then **`a`** and **`b`** are incremented by 1 each. The second line will increment **`a`** and **`b`** by 1 each first, and then perform **`a + b`**, which is the value obtained by **`ques2`**.

4. **Process**:
A process is a basic unit of execution in an operating system. It usually contains an instance of a program's execution, as well as the resources required for the program to execute, such as memory, file descriptors, etc. Each process is independent, and they do not directly share memory space, thus avoiding interference between multiple processes. Processes can run concurrently, managed by the operating system's scheduling, ensuring their execution does not interfere with each other.
Each process has its own address space and system resources, so switching between processes requires more system overhead. This means that the cost of switching processes is higher in a multi-process environment.

**Thread**:
A thread is a unit of execution within a process, and it is smaller than a process. Multiple threads within the same process can share the same address space and resources, making communication and data sharing between threads easier. The creation and switching costs of threads are lower than processes because they share many resources, and only a few internal states need to be changed when switching.
However, because threads share resources, extra attention is needed to ensure the safety of multiple threads, avoiding race conditions, and deadlocks.

5. **Deadlock**:
Deadlock is a situation in a multi-process or multi-threaded environment where two or more execution units (processes or threads) are waiting for each other to release some resources, resulting in none of them being able to proceed. In a deadlock, each execution unit is waiting for another execution unit to release resources while being unwilling to release the resources it occupies, leading all execution units to be unable to continue, resulting in a stalemate.

**Necessary conditions**:
a. Mutual Exclusion: At least one resource can only be occupied by one execution unit at a time, and other execution units must wait.
b. Hold and Wait: At least one execution unit holds a resource and is waiting for another resource occupied by another execution unit.
c. No Preemption: Allocated resources cannot be forcibly retrieved from the execution unit holding them.
d. Circular Wait: A series of execution units form a cycle, each waiting for the next execution unit's resources.

**Prevention**:
a. Breaking Necessary Conditions: This means eliminating one or more of the necessary conditions for a deadlock. For example, grading resources, prioritizing resource allocation, or implementing resource preemption.
b. Deadlock Prevention: Design the system reasonably to avoid deadlock. For example, avoid satisfying the four necessary conditions simultaneously.
c. Detection and Recovery: Regularly check whether the system is in a deadlock state. If so, take recovery measures, such as terminating some execution units to break the deadlock.
d. Deadlock Avoidance: Allocate resources based on predicted execution unit demands to avoid deadlock.

**Note**: Deadlock is a common problem in multi-tasking environments. Solving deadlock requires careful system design and strategies to ensure reasonable resource allocation and use.

6. **Object-Oriented Programming**:
Here is a simple classification system for the animal kingdom using C++:

    cppCopy code
    #include <iostream>// Base class
    class Animal {
    public:
        virtual void speak() {
            std::cout << "I am an animal." << std::endl;
        }
    };
    
    // Derived class
    class Mammal : public Animal {
    public:
        void speak() override {
            std::cout << "I am a mammal." << std::endl;
        }
    };
    
    // Derived class
    class Bird : public Animal {
    public:
        void speak() override {
            std::cout << "I am a bird." << std::endl;
        }
    };
    
    int main() {
        Animal* animal = new Animal();
        Animal* mammal = new Mammal();
        Animal* bird = new Bird();
    
        animal->speak();
        mammal->speak();
        bird->speak();
    
        delete animal;
        delete mammal;
        delete bird;
    
        return 0;
    }
    

In this example, **`Animal`** is the base class, and **`Mammal`** and **`Bird`** are derived classes. The **`speak`** method is a virtual function in the **`Animal`** class, which is overridden in the **`Mammal`** and **`Bird`** classes. This demonstrates the concept of polymorphism, as the **`speak`** method behaves differently depending on the class of the object that calls it.

7. C Programming:

    cCopy code
    #include <stdio.h>void Swap(int *x, int *y){
        int temp = *x;
        *x = *y;
        *y = temp;
    }
    
    int main()
    {
        int a = 10, b = 20;
        printf("Before Swap: a = %d, b = %d\n", a, b);
        Swap(&a, &b);
        printf("After Swap: a = %d, b = %d\n", a, b);
        return 0;
    }
    

**Note**: In this example, the **`Swap`** function takes two pointers to integers and swaps the values they point to. The **`main`** function demonstrates the **`Swap`** function by declaring two integers **`a`** and **`b`**, printing their values before and after the **`Swap`** function is called.

8. C Programming:
- declare **`a`** as int: **`int a;`**
- declare **`a`** as pointer to int: **`int *a;`**
- declare **`a`** as pointer to pointer to int: **`int **a;`**
- declare **`a`** as array 10 of int: **`int a[10];`**
- declare **`a`** as array 10 of pointer to int: **`int *a[10];`**
- declare **`a`** as pointer to array 10 of int: **`int (*a)[10];`**
- declare **`a`** as pointer to function (int) returning int: **`int (*a)(int);`**
- declare **`a`** as array 10 of pointer to function (int) returning int: **`int (*a[10])(int);`**
9. **Version Control**:
**`git rebase`**:
**`git rebase`** moves or combines a sequence of commits to a new base commit. It essentially moves the entire branch to the tip of the master (or another branch), which can result in a cleaner, more linear history. You should always rebase local changes that you want to keep private before pushing them to a public repository.
**Use Case**: If you have a feature branch that is far behind the master, and you want to catch up without merging all the master branch commits, you can use **`git rebase`**. It can also be used to squash multiple commits into a single one before merging into the master branch.

**`git merge`**:
**`git merge`** takes the contents of a source branch and integrates it with the target branch. A new commit is created in the target branch, which has a history that contains both branches.
**Use Case**: When you want to integrate changes from one branch into another and maintain the entire history of the branch being merged, you should use **`git merge`**.

10. **MVC Architecture**:
**Model**: Represents the application data and business logic. It is responsible for retrieving and storing the application data, either in a database or in-memory. The model notifies the view of changes to the data.
**View**: Represents the user interface and the visualization of the data. It is responsible for displaying the data to the user and sending the user's commands to the controller.
**Controller**: Acts as an intermediary between the Model and the View. It processes user input from the view, requests data from the model, and sends the data to the view for presentation.
The MVC architecture aims to separate the application logic into three interconnected components, making it easier to manage the complexity of the application. For example, changes to the user interface do not affect the data processing, and vice versa. This separation into three components also makes it easier to test and maintain the application.