Question 1

Explain the concept of normalization in DBMS and describe the different normal forms with examples.

Accepted Answer

Normalization is a database design technique that organizes tables to reduce redundancy and dependency. The different normal forms are: 1. First Normal Form (1NF): A table is in 1NF if it contains only atomic values and each column has unique names. For example, a table of student records should not have multiple values in a single column.

```sql
   CREATE TABLE Students (
       StudentID INT PRIMARY KEY,
       Name VARCHAR(100),
       Courses VARCHAR(255)
   );
   ```
   To convert to 1NF, we would split 'Courses' into a separate table:
   ```sql
   CREATE TABLE Courses (
       CourseID INT,
       StudentID INT,
       CourseName VARCHAR(100),
       PRIMARY KEY (CourseID, StudentID)
   );
   ```

2. Second Normal Form (2NF): A table is in 2NF if it is in 1NF and all non-key attributes are fully functional dependent on the primary key. For example:
   ```sql
   CREATE TABLE Orders (
       OrderID INT PRIMARY KEY,
       ProductID INT,
       Quantity INT,
       ProductName VARCHAR(100),
       FOREIGN KEY (ProductID) REFERENCES Products(ProductID)
   );
   ```
   To convert to 2NF, we can move 'ProductName' to a separate table:
   ```sql
   CREATE TABLE ProductDetails (
       ProductID INT PRIMARY KEY,
       ProductName VARCHAR(100)
   );
   ```

3. Third Normal Form (3NF): A table is in 3NF if it is in 2NF and all the attributes are functionally dependent only on the primary key. For example:
   ```sql
   CREATE TABLE Employees (
       EmployeeID INT PRIMARY KEY,
       Name VARCHAR(100),
       DepartmentID INT,
       DepartmentName VARCHAR(100)
   );
   ```
   To convert to 3NF, we separate the department details:
   ```sql
   CREATE TABLE Departments (
       DepartmentID INT PRIMARY KEY,
       DepartmentName VARCHAR(100)
   );
   ```
Normalization helps maintain data integrity and efficiency.

Question 2

What is the system design round like at Tech Mahindra?

Accepted Answer

The system design round at Tech Mahindra typically assesses your ability to design scalable and efficient systems. You may be asked to design a URL shortening service like Bitly. The interviewer will look for your understanding of system components, data storage solutions, and API design.

A simple design might involve creating a service with the following components:
- A web server to handle HTTP requests.
- A database to store URL mappings.
- Hashing algorithms to generate unique short URLs.

You could sketch your design as follows:
1. Input URL is received by the web server.
2. A unique ID is generated using a hashing function.
3. The mapping of the unique ID to the original URL is stored in the database.
4. The short URL is returned to the user.
5. When accessing the short URL, the service retrieves the original URL from the database.

Make sure to discuss trade-offs, such as database choice (SQL vs. NoSQL) and scaling strategies.

Question 3

Implement a function in Python that returns the maximum sum of a contiguous subarray using Kadane's algorithm. Include edge case handling for empty input and negative numbers.

Accepted Answer

Kadane's algorithm is an efficient way to find the maximum sum of a contiguous subarray in an array of integers. Here’s how to implement it:

```python
def max_subarray_sum(arr):
    if not arr:
        return 0  # Handle empty input

max_current = max_global = arr[0]

for i in range(1, len(arr)):
        max_current = max(arr[i], max_current + arr[i])  # Current max sum including arr[i]
        if max_current > max_global:
            max_global = max_current  # Update global max if current is greater

return max_global
```

Explanation:
- The function first checks if the input array `arr` is empty and returns 0 in that case.
- `max_current` keeps track of the maximum subarray sum ending at the current position, while `max_global` tracks the overall maximum found.
- The loop iterates through the array, updating `max_current` to be either the current element or the sum of `max_current` plus the current element, ensuring we only keep contiguous elements.
- If `max_current` exceeds `max_global`, we update `max_global`.
- Finally, we return `max_global` which contains the maximum sum of the contiguous subarray.

Edge Cases: This solution correctly handles cases where all numbers are negative by returning the maximum single element when no positive sum is possible.

Question 4

What techniques can be employed for SQL query optimization? Provide examples.

Accepted Answer

SQL query optimization is essential for improving the performance of database operations. Here are several techniques that can be employed:

### 1. Use Indexes
Indexes can significantly speed up data retrieval. Here's how you can create an index:

```sql
CREATE INDEX idx_user_email ON users(email);
```

### 2. Avoid SELECT *
Instead of selecting all columns, specify only the necessary columns:

```sql
SELECT id, name FROM users WHERE email = 'example@example.com';
```

### 3. Use WHERE Clauses Wisely
Narrow down your results with WHERE clauses to limit the data processed:

```sql
SELECT * FROM orders WHERE status = 'shipped';
```

### 4. Query Execution Plans
Analyze the query execution plan to understand how the database processes your query. You can use:

```sql
EXPLAIN SELECT * FROM users WHERE email = 'example@example.com';
```

### 5. Limit Result Sets
Use `LIMIT` to restrict the number of results returned:

```sql
SELECT * FROM products LIMIT 10;
```

### 6. Optimize Joins
Ensure that joins are optimized with appropriate indexes:

```sql
SELECT u.name, o.amount FROM users u JOIN orders o ON u.id = o.user_id WHERE u.id = 1;
```

### Conclusion
By applying these optimization techniques, you can greatly enhance the performance of SQL queries, leading to faster response times and improved user experience.

Question 5

Explain the Node.js event loop and its significance in handling asynchronous operations.

Accepted Answer

The Node.js event loop is a crucial component that enables Node.js to perform non-blocking I/O operations despite being single-threaded. This allows Node.js to handle multiple operations concurrently, making it highly efficient for I/O-heavy applications.

### How the Event Loop Works
1. Event Loop Phases: The event loop has different phases, including timers, I/O callbacks, idle, poll, check, and close callbacks. Each phase has a specific purpose and handles different types of tasks.

2. Task Queue: When an asynchronous operation completes, its callback is added to the task queue. The event loop processes this queue by executing callbacks from the queue in the order they were added.

### Example of Event Loop in Action
Here’s a practical example:

```javascript
const fs = require('fs');

console.log('Start');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

console.log('End');
```

#### Explanation:
- When you run this code, you’ll see 'Start' printed first, followed by 'End'. This is because `fs.readFile` is an asynchronous operation.
- The callback function is added to the task queue once the file reading is complete, and the event loop processes it after the main script has finished executing.

### Significance
- Non-blocking: Node.js can handle many connections simultaneously without blocking the execution thread.
- Scalability: This allows Node.js applications to scale efficiently, making it suitable for real-time applications like chat apps and online gaming.

Understanding the event loop is critical for building efficient and performant applications in Node.js.

SarthiQ

Interview Preparation Guide

Tech Mahindra
Questions & Answers

Document Details

Need Help?

Top Tech Mahindra Interview Questions

Tech Mahindra Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

Tech MahindraQuestions & Answers

Document Details

Need Help?

Top Tech Mahindra Interview Questions

Tech Mahindra Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Tech Mahindra
Questions & Answers