Q: How do you create a basic REST API using Node.js?

To create a basic REST API using Node.js, you can use the Express framework, which simplifies the process of building server-side applications. Below is an example of a simple REST API that manages a list of users. First, set up a new Node.js project: ```bash mkdir user-api cd user-api npm init -y npm install express ``` Then, create an `index.js` file: ```javascript const express = require('express'); const app = express(); const PORT = 3000; app.use(express.json()); // Middleware to parse JSON requests let users = []; // Create a new 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}`); }); ``` This code sets up a basic REST API with endpoints to create, retrieve all users, and retrieve a specific user by ID. Be sure to handle edge cases like missing data or invalid IDs appropriately. Test the API using tools like Postman or curl to send requests and check responses.

Question 1

Can you explain the basics of arrays and strings as data structures? Provide examples of common operations such as insertion, deletion, and searching.

Accepted Answer

Arrays and strings are fundamental data structures in programming. An array is a collection of elements identified by index or key, while a string is a sequence of characters. Here are some basic operations:

1. Insertion: Adding an element to an array. In Python, we can do this using the `insert` method.
   ```python
   arr = [1, 2, 3, 5]
   arr.insert(3, 4)  # Inserts 4 at index 3
   print(arr)  # Outputs: [1, 2, 3, 4, 5]
   ```

2. Deletion: Removing an element from an array. In Python, we can use the `remove` method.
   ```python
   arr = [1, 2, 3, 4, 5]
   arr.remove(3)  # Removes the first occurrence of 3
   print(arr)  # Outputs: [1, 2, 4, 5]
   ```

3. Searching: Finding an element in an array. We can use a simple linear search algorithm:
   ```python
   def linear_search(arr, target):
       for index, value in enumerate(arr):
           if value == target:
               return index
       return -1
   
   arr = [1, 2, 3, 4, 5]
   index = linear_search(arr, 3)
   print(index)  # Outputs: 2
   ```

For strings, similar operations can be performed:
1. Concatenation: Joining two strings.
   ```python
   str1 = 'Hello'
   str2 = 'World'
   result = str1 + ' ' + str2  # Outputs: 'Hello World'
   ```
2. Substring Search: Checking if a string contains a substring.
   ```python
   str1 = 'Hello World'
   print('World' in str1)  # Outputs: True
   ```
3. Length: Getting the length of a string.
   ```python
   str1 = 'Hello'
   print(len(str1))  # Outputs: 5
   ```
In summary, arrays and strings are versatile structures that allow efficient data manipulation, and understanding their operations is crucial for software development.

Question 2

What is normalization in DBMS? Explain the different normal forms and the ACID properties of transactions.

Accepted Answer

Normalization is the process of organizing data in a database to reduce redundancy and improve data integrity. The main normal forms are:

1. First Normal Form (1NF): Requires that all columns contain atomic values, and each row is unique. For example, a table storing customer orders should have separate rows for each order.

2. Second Normal Form (2NF): Achieved when it is in 1NF and all non-key attributes are fully functionally dependent on the primary key. This means that all data must depend on the entire primary key.

3. Third Normal Form (3NF): Achieved when it is in 2NF and all the attributes are functionally dependent only on the primary key. This means no transitive dependency exists.

4. Boyce-Codd Normal Form (BCNF): A stronger version of 3NF where every determinant is a candidate key.

ACID Properties: ACID stands for Atomicity, Consistency, Isolation, and Durability, which are essential properties to ensure reliable processing of database transactions.
- Atomicity: Ensures that transactions are all or nothing. If one part of a transaction fails, the entire transaction fails and the database state is left unchanged.
- Consistency: Ensures that a transaction brings the database from one valid state to another, maintaining all defined rules, including constraints and cascades.
- Isolation: Ensures that concurrent transactions do not interfere with each other. Each transaction should appear as if it is the only operation being executed in the system.
- Durability: Ensures that once a transaction is committed, it will remain so, even in the event of a system failure.
These properties work together to ensure that database transactions are processed reliably.

Question 3

How do hashmaps and dictionaries differ in terms of data structure and usage? Provide code examples in Python.

Accepted Answer

Hashmaps (also known as hash tables) and dictionaries are both key-value pair data structures that offer average O(1) time complexity for lookups, inserts, and deletions. However, their implementations can differ based on the programming language. In Python, dictionaries are built-in and optimized for performance and memory usage.

Here’s how you can use dictionaries in Python, which function similarly to hashmaps:

```python
# Creating a dictionary
employee_dict = {
    'E001': 'Alice',
    'E002': 'Bob',
    'E003': 'Charlie'
}

# Accessing values
print(employee_dict['E001'])  # Output: Alice

# Adding a new key-value pair
employee_dict['E004'] = 'David'

# Updating a value
employee_dict['E002'] = 'Bobby'

# Deleting a key-value pair
del employee_dict['E003']

# Iterating through the dictionary
for emp_id, name in employee_dict.items():
    print(f'ID: {emp_id}, Name: {name}')
```
In this example, we create a dictionary to store employee IDs and names, demonstrating how to access, add, update, and delete entries.

This question was likely asked in 2024.

Question 4

Explain the concept of database transactions and how indexing can improve transaction performance in a database. Provide examples using SQL.

Accepted Answer

Database transactions are sequences of operations that are treated as a single unit of work. A transaction must be atomic (all or nothing), consistent (maintains database invariants), isolated (no interference from other transactions), and durable (once committed, it remains so).

Indexing is a data structure technique that improves the speed of data retrieval operations on a database table at the cost of additional space and slower writes.

Here’s an example of using transactions and indexing in SQL:

```sql
-- Create a sample table
CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    Name VARCHAR(100),
    Salary DECIMAL(10, 2)
);

-- Create an index on Salary to speed up queries
CREATE INDEX idx_salary ON Employees(Salary);

-- Start a transaction to update salaries
BEGIN TRANSACTION;
UPDATE Employees SET Salary = Salary * 1.1 WHERE Salary < 50000;
COMMIT;
```
In this example, the `BEGIN TRANSACTION` and `COMMIT` statements ensure that the salary updates are atomic. The index on `Salary` enhances the performance of the `UPDATE` operation, especially if the `Employees` table contains a large number of records.

This question was most likely asked in 2024.

Question 5

How do you create a basic REST API using Node.js?

Accepted Answer

To create a basic REST API using Node.js, you can use the Express framework, which simplifies the process of building server-side applications. Below is an example of a simple REST API that manages a list of users.

First, set up a new Node.js project:
```bash
mkdir user-api
cd user-api
npm init -y
npm install express
```
Then, create an `index.js` file:
```javascript
const express = require('express');
const app = express();
const PORT = 3000;

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

let users = [];

// Create a new 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}`);
});
```
This code sets up a basic REST API with endpoints to create, retrieve all users, and retrieve a specific user by ID. Be sure to handle edge cases like missing data or invalid IDs appropriately. Test the API using tools like Postman or curl to send requests and check responses.

SarthiQ

Interview Preparation Guide

Qualcomm
Questions & Answers

Document Details

Need Help?

Top Qualcomm Interview Questions

Qualcomm Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

QualcommQuestions & Answers

Document Details

Need Help?

Top Qualcomm Interview Questions

Qualcomm Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Qualcomm
Questions & Answers