Q: How do you create a simple REST API using Node.js? Provide a code example.

To create a simple REST API using Node.js, you can use the Express framework, which simplifies the process of handling HTTP requests. Below is an example of a basic REST API that manages a list of books. ```javascript const express = require('express'); const app = express(); const PORT = 3000; app.use(express.json()); // Middleware to parse JSON bodies let books = [ { id: 1, title: '1984', author: 'George Orwell' }, { id: 2, title: 'To Kill a Mockingbird', author: 'Harper Lee' } ]; // GET all books app.get('/api/books', (req, res) => { res.json(books); }); // POST a new book app.post('/api/books', (req, res) => { const newBook = { id: books.length + 1, ...req.body }; books.push(newBook); res.status(201).json(newBook); }); // GET a book by ID app.get('/api/books/:id', (req, res) => { const book = books.find(b => b.id === parseInt(req.params.id)); if (!book) return res.status(404).send('Book not found.'); res.json(book); }); app.listen(PORT, () => { console.log(`Server is running on http://localhost:${PORT}`); }); ``` In this example, we set up a REST API with three endpoints: one for retrieving all books, one for adding a new book, and one for retrieving a specific book by its ID. The API responds with JSON data and handles basic errors such as a missing book.

Question 1

What is recursion in algorithms, and how would you implement a function to calculate Fibonacci numbers using recursion?

Accepted Answer

Recursion is a programming technique where a function calls itself in order to solve a problem. It is often used for problems that can be broken down into smaller, similar sub-problems. The Fibonacci sequence is a classic example where each number is the sum of the two preceding ones.

Here’s how you can implement a recursive function to calculate Fibonacci numbers:

```javascript
function fibonacci(n) {
    if (n <= 0) return 0; // base case for n = 0
    if (n === 1) return 1; // base case for n = 1
    return fibonacci(n - 1) + fibonacci(n - 2); // recursive case
}

console.log(fibonacci(5)); // Output: 5
console.log(fibonacci(0)); // Output: 0
console.log(fibonacci(1)); // Output: 1
console.log(fibonacci(6)); // Output: 8
```

In this implementation, the base cases handle the scenarios for `n = 0` and `n = 1`. The recursive case calls the `fibonacci` function twice, leading to an exponential time complexity. It is important to note that this naive implementation can be inefficient for larger values of `n` due to repeated calculations. For improvement, memoization or an iterative approach can be utilized.

Question 2

How do you create a simple REST API using Node.js? Provide a code example.

Accepted Answer

To create a simple REST API using Node.js, you can use the Express framework, which simplifies the process of handling HTTP requests. Below is an example of a basic REST API that manages a list of books.

```javascript
const express = require('express');
const app = express();
const PORT = 3000;

app.use(express.json()); // Middleware to parse JSON bodies

let books = [
    { id: 1, title: '1984', author: 'George Orwell' },
    { id: 2, title: 'To Kill a Mockingbird', author: 'Harper Lee' }
];

// GET all books
app.get('/api/books', (req, res) => {
    res.json(books);
});

// POST a new book
app.post('/api/books', (req, res) => {
    const newBook = { id: books.length + 1, ...req.body };
    books.push(newBook);
    res.status(201).json(newBook);
});

// GET a book by ID
app.get('/api/books/:id', (req, res) => {
    const book = books.find(b => b.id === parseInt(req.params.id));
    if (!book) return res.status(404).send('Book not found.');
    res.json(book);
});

app.listen(PORT, () => {
    console.log(`Server is running on http://localhost:${PORT}`);
});
```

In this example, we set up a REST API with three endpoints: one for retrieving all books, one for adding a new book, and one for retrieving a specific book by its ID. The API responds with JSON data and handles basic errors such as a missing book.

Question 3

Can you explain the difference between method overloading and method overriding in Object-Oriented Programming (OOP) with examples?

Accepted Answer

In Object-Oriented Programming (OOP), method overloading and overriding are two important concepts that allow methods to behave differently based on context.

1. Method Overloading: This occurs when multiple methods in the same class have the same name but different parameters (type, number, or both).

Example:
```java
public class MathOperations {
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
}
```

2. Method Overriding: This occurs when a subclass provides a specific implementation of a method that is already defined in its superclass.

Example:
```java
class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}
```

In the example above, the `Dog` class overrides the `sound` method of the `Animal` class. Overloading is about the same method name with different signatures, while overriding is about redefining a method's behavior in a subclass.

Question 4

What are the four pillars of Object-Oriented Programming (OOP) and how do they apply to real-world applications?

Accepted Answer

The four pillars of Object-Oriented Programming are Encapsulation, Abstraction, Inheritance, and Polymorphism.

1. Encapsulation: This principle involves bundling the data (attributes) and methods (functions) that operate on the data into a single unit or class. It restricts direct access to some of the object's components, which can prevent the accidental modification of data. For example:
   ```python
   class BankAccount:
       def __init__(self, balance=0):
           self.__balance = balance  # private attribute
       
       def deposit(self, amount):
           if amount > 0:
               self.__balance += amount
           else:
               raise ValueError('Deposit amount must be positive')
       
       def get_balance(self):
           return self.__balance
   ```

2. Abstraction: This principle focuses on hiding the complex reality while exposing only the necessary parts. It helps to reduce programming complexity and increase efficiency. For example:
   ```python
   from abc import ABC, abstractmethod
   
   class Shape(ABC):
       @abstractmethod
       def area(self):
           pass
   
   class Circle(Shape):
       def __init__(self, radius):
           self.radius = radius
       
       def area(self):
           return 3.14 * self.radius  2
   ```

3. Inheritance: This allows a class to inherit properties and methods from another class, promoting code reusability. For example:
   ```python
   class Animal:
       def speak(self):
           return 'Animal sound'
   
   class Dog(Animal):
       def speak(self):
           return 'Bark'
   ```

4. Polymorphism: This principle allows methods to do different things based on the object it is acting upon. For instance:
   ```python
   def animal_sound(animal):
       print(animal.speak())
   
   dog = Dog()
   animal_sound(dog)  # Output: Bark
   ```

These pillars form the foundation of OOP and are crucial for designing scalable and maintainable software systems.

Question 5

Explain SQL Joins and provide examples of different types of joins with practical scenarios.

Accepted Answer

SQL Joins are used to combine rows from two or more tables based on a related column between them. The most common types of SQL Joins are INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL OUTER JOIN.

1. INNER JOIN: Returns records that have matching values in both tables.
   ```sql
   SELECT a.name, b.order_date 
   FROM customers a
   INNER JOIN orders b ON a.customer_id = b.customer_id;
   ```
   *Scenario*: Fetch customer names along with their order dates where there is a match in both tables.

2. LEFT JOIN: Returns all records from the left table and matched records from the right table. Non-matching records from the right table will return NULL.
   ```sql
   SELECT a.name, b.order_date 
   FROM customers a
   LEFT JOIN orders b ON a.customer_id = b.customer_id;
   ```
   *Scenario*: Fetch all customers and their orders, if any. Customers without orders will show NULL for order_date.

3. RIGHT JOIN: Returns all records from the right table and matched records from the left table. Non-matching records from the left table will return NULL.
   ```sql
   SELECT a.name, b.order_date 
   FROM customers a
   RIGHT JOIN orders b ON a.customer_id = b.customer_id;
   ```
   *Scenario*: Fetch all orders and the names of customers who made them, showing NULL for customers who don't exist in the customers table.

4. FULL OUTER JOIN: Returns all records when there is a match in either left or right table records.
   ```sql
   SELECT a.name, b.order_date 
   FROM customers a
   FULL OUTER JOIN orders b ON a.customer_id = b.customer_id;
   ```
   *Scenario*: Fetch all customers and all orders, showing NULLs for non-matching entries from either table.

Understanding these joins is essential for querying relational databases effectively and retrieving meaningful insights from data.

SarthiQ

Interview Preparation Guide

MakeMyTrip
Questions & Answers

Document Details

Need Help?

Top MakeMyTrip Interview Questions

MakeMyTrip Interview Questions

A Software Engineer was asked

A Backend Developer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

MakeMyTripQuestions & Answers

Document Details

Need Help?

Top MakeMyTrip Interview Questions

MakeMyTrip Interview Questions

A Software Engineer was asked

A Backend Developer was asked

Software Engineer

Software Engineer

MakeMyTrip
Questions & Answers