Question 1

Can you explain the GROUP BY clause in SQL with an example using aggregate functions?

Accepted Answer

The GROUP BY clause in SQL is used to arrange identical data into groups with the help of aggregate functions. It is commonly used with functions like COUNT, SUM, AVG, MAX, and MIN to produce summary reports.

Example:
Suppose we have a `Sales` table with the following columns: `ProductID`, `Quantity`, and `Price`.
```sql
CREATE TABLE Sales (
    ProductID int,
    Quantity int,
    Price decimal(10, 2)
);

INSERT INTO Sales (ProductID, Quantity, Price) VALUES
(1, 10, 15.50),
(2, 5, 20.00),
(1, 3, 15.50),
(3, 7, 25.00);
```
To calculate the total quantity sold for each product, you can use the following query:
```sql
SELECT ProductID, SUM(Quantity) as TotalQuantity
FROM Sales
GROUP BY ProductID;
```
Output:
| ProductID | TotalQuantity |
|-----------|---------------|
| 1         | 13            |
| 2         | 5             |
| 3         | 7             |

In this example, we group the results by `ProductID` and use the `SUM` function to calculate the total quantity sold for each product. The query effectively summarizes the data, making it easier to analyze sales performance across different products.

Question 2

Can you describe the data structures Stacks and Queues? Provide examples in JavaScript.

Accepted Answer

Stacks and queues are fundamental data structures in computer science.

A stack follows the Last In First Out (LIFO) principle, where the last element added is the first one removed. Here’s a simple implementation in JavaScript:

```javascript
class Stack {
    constructor() {
        this.items = [];
    }

push(element) {
        this.items.push(element);
    }

pop() {
        if (this.isEmpty()) return 'Stack is empty';
        return this.items.pop();
    }

isEmpty() {
        return this.items.length === 0;
    }
}

const stack = new Stack();
stack.push(1);
stack.push(2);
console.log(stack.pop()); // Output: 2
```

A queue follows the First In First Out (FIFO) principle, where the first element added is the first one removed. Here’s a queue implementation:

```javascript
class Queue {
    constructor() {
        this.items = [];
    }

enqueue(element) {
        this.items.push(element);
    }

dequeue() {
        if (this.isEmpty()) return 'Queue is empty';
        return this.items.shift();
    }

isEmpty() {
        return this.items.length === 0;
    }
}

const queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);
console.log(queue.dequeue()); // Output: 1
```

Both stacks and queues are used in various applications, such as function call management (stacks) and task scheduling (queues). Always test for edge cases like underflows on pop or dequeue operations.

Question 3

Can you write a recursive function in Python to calculate the nth Fibonacci number? Please ensure your solution handles edge cases such as negative inputs and non-integer values.

Accepted Answer

Here is a Python implementation of a recursive function to calculate the nth Fibonacci number with edge case handling:

```python
def fibonacci(n):
    if not isinstance(n, int) or n < 0:
        raise ValueError('Input must be a non-negative integer.')
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

# Test cases
try:
    print(fibonacci(10))  # Output: 55
    print(fibonacci(-5))  # Should raise ValueError
    print(fibonacci(0))   # Output: 0
    print(fibonacci(1.5)) # Should raise ValueError
except ValueError as e:
    print(e)
```

Question 4

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

Accepted Answer

Creating a REST API in Node.js typically involves using the Express framework to handle routing and requests. Below is a simple example of a REST API that manages a list of users:

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

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

let users = [];

// Create a user
app.post('/users', (req, res) => {
    const user = req.body;
    users.push(user);
    res.status(201).send(user);
});

// Get all users
app.get('/users', (req, res) => {
    res.status(200).send(users);
});

// Get a user by ID
app.get('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (!user) return res.status(404).send('User not found');
    res.status(200).send(user);
});

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

In this example, we define routes for creating users, retrieving all users, and fetching a user by ID. The API responds with appropriate status codes, making it a complete RESTful service. Always ensure to handle edge cases, such as invalid user IDs or empty requests.

Question 5

Describe the core concepts of React components and props. How do they facilitate component reusability?

Accepted Answer

In React, components are the building blocks of the UI, allowing developers to split the UI into independent, reusable pieces. Components can be class-based or functional. Props (short for properties) are a mechanism for passing data from one component to another, particularly from parent to child components. Here's a simple example: ```javascript // Parent Component function ParentComponent() { const message = 'Hello from Parent'; return ; } // Child Component function ChildComponent(props) { return

{props.message}

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

Creating a REST API in Node.js typically involves using the Express framework to handle routing and requests. Below is a simple example of a REST API that manages a list of users: ```javascript const express = require('express'); const app = express(); const PORT = 3000; app.use(express.json()); // Middleware to parse JSON requests let users = []; // Create a user app.post('/users', (req, res) => { const user = req.body; users.push(user); res.status(201).send(user); }); // Get all users app.get('/users', (req, res) => { res.status(200).send(users); }); // Get a user by ID app.get('/users/:id', (req, res) => { const user = users.find(u => u.id === parseInt(req.params.id)); if (!user) return res.status(404).send('User not found'); res.status(200).send(user); }); // Start the server app.listen(PORT, () => { console.log(`Server is running on http://localhost:${PORT}`); }); ``` In this example, we define routes for creating users, retrieving all users, and fetching a user by ID. The API responds with appropriate status codes, making it a complete RESTful service. Always ensure to handle edge cases, such as invalid user IDs or empty requests.

; } ``` In this example, `ParentComponent` passes a `message` prop to `ChildComponent`. This allows `ChildComponent` to be reused with different messages by simply changing the prop it receives. Using props enhances the reusability and maintainability of components, which is a core principle of React.

SarthiQ

Interview Preparation Guide

Morgan Stanley
Questions & Answers

Document Details

Need Help?

Top Morgan Stanley Interview Questions

Morgan Stanley Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Backend Developer

Interview Preparation Guide

Morgan StanleyQuestions & Answers

Document Details

Need Help?

Top Morgan Stanley Interview Questions

Morgan Stanley Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Backend Developer

Morgan Stanley
Questions & Answers