Question 1

What are arrays and strings in data structures? Provide examples of basic operations.

Accepted Answer

Arrays and strings are fundamental data structures used to store collections of data.

1. Arrays: An array is a collection of elements identified by index or key. Each element in an array is of the same data type.
   - Example Operations:
   ```python
   # Creating an array
   numbers = [1, 2, 3, 4, 5]
   # Accessing elements
   print(numbers[0])  # Output: 1
   # Modifying elements
   numbers[1] = 10
   print(numbers)  # Output: [1, 10, 3, 4, 5]
   # Finding the length
   print(len(numbers))  # Output: 5
   ```
   - Edge Case: Handling an empty array.
   ```python
   empty_array = []
   print(len(empty_array))  # Output: 0
   ```

2. Strings: A string is a sequence of characters. Strings are immutable in many programming languages (like Python).
   - Example Operations:
   ```python
   text = "Hello World"
   # Accessing characters
   print(text[0])  # Output: H
   # Slicing
   print(text[0:5])  # Output: Hello
   # Concatenation
   new_text = text + "!"
   print(new_text)  # Output: Hello World!
   # Finding length
   print(len(text))  # Output: 11
   ```
   - Edge Case: Handling an empty string.
   ```python
   empty_string = ""
   print(len(empty_string))  # Output: 0
   ```

Arrays and strings are essential for managing and manipulating collections of data in programming.

Question 2

What are subqueries and nested queries in SQL? Provide an example of each and explain their differences.

Accepted Answer

Subqueries and nested queries are SQL features that allow you to perform operations based on the results of other queries.

- Subquery: A query nested inside another SQL query. Subqueries can return individual values or a set of records.
- Nested Query: Often used interchangeably with subqueries, but usually refers to a more complex query structure where a query is within another as part of the `FROM` or `WHERE` clause.

### Example of a Subquery:
```sql
SELECT UserName
FROM Users
WHERE UserID IN (SELECT UserID FROM Orders WHERE OrderDate > '2023-01-01');
```
This query retrieves usernames from the `Users` table for users who have made orders after January 1, 2023.

### Example of a Nested Query:
```sql
SELECT UserName, (SELECT COUNT(*) FROM Orders WHERE Orders.UserID = Users.UserID) AS OrderCount
FROM Users;
```
Here, the nested query counts the number of orders for each user, returning the username and their respective order count.

### Differences:
- Subqueries can return values used in the main query, while nested queries are typically part of the main SQL logic in the `SELECT`, `FROM`, or `WHERE` clauses.

Question 3

What are SQL Joins? Explain the different types of joins with examples using SQL queries.

Accepted Answer

SQL Joins are used to combine records from two or more tables in a database based on a related column between them. There are several types of joins:

1. INNER JOIN: Returns records that have matching values in both tables.
   
   ```sql
   SELECT students.name, courses.title
   FROM students
   INNER JOIN enrollments ON students.id = enrollments.student_id
   INNER JOIN courses ON enrollments.course_id = courses.id;
   ```

2. LEFT JOIN (or LEFT OUTER JOIN): Returns all records from the left table and the matched records from the right table. If there is no match, NULL values are returned for columns from the right table.
   
   ```sql
   SELECT students.name, courses.title
   FROM students
   LEFT JOIN enrollments ON students.id = enrollments.student_id
   LEFT JOIN courses ON enrollments.course_id = courses.id;
   ```

3. RIGHT JOIN (or RIGHT OUTER JOIN): Returns all records from the right table and the matched records from the left table. If there is no match, NULL values are returned for columns from the left table.
   
   ```sql
   SELECT students.name, courses.title
   FROM students
   RIGHT JOIN enrollments ON students.id = enrollments.student_id
   RIGHT JOIN courses ON enrollments.course_id = courses.id;
   ```

4. FULL JOIN (or FULL OUTER JOIN): Returns all records when there is a match in either left or right table records. If there is no match, NULL values are returned for non-matching rows.
   
   ```sql
   SELECT students.name, courses.title
   FROM students
   FULL JOIN enrollments ON students.id = enrollments.student_id
   FULL JOIN courses ON enrollments.course_id = courses.id;
   ```

5. CROSS JOIN: Returns the Cartesian product of both tables, meaning it combines all rows from the first table with all rows from the second table.
   
   ```sql
   SELECT students.name, courses.title
   FROM students
   CROSS JOIN courses;
   ```

Understanding these joins helps in effectively querying data from relational databases.

Question 4

Can you explain the difference between stacks and queues? Provide code examples for both data structures in JavaScript.

Accepted Answer

Stacks and queues are both linear data structures but differ in their operations and use cases.

### Stack
A stack follows the Last In First Out (LIFO) principle. The last element added is the first to be removed. Here’s a simple implementation:

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

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

pop() {
        if (this.isEmpty()) return 'Underflow';
        return this.items.pop();
    }

peek() {
        return this.items[this.items.length - 1];
    }

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

// Example usage:
const stack = new Stack();
stack.push(10);
stack.push(20);
console.log(stack.peek()); // Output: 20
console.log(stack.pop());   // Output: 20
console.log(stack.pop());   // Output: 10
```

### Queue
A queue follows the First In First Out (FIFO) principle. The first element added is the first to be removed. Here’s how you can implement a queue:

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

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

dequeue() {
        if (this.isEmpty()) return 'Underflow';
        return this.items.shift();
    }

front() {
        return this.items[0];
    }

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

// Example usage:
const queue = new Queue();
queue.enqueue(10);
queue.enqueue(20);
console.log(queue.front()); // Output: 10
console.log(queue.dequeue()); // Output: 10
console.log(queue.dequeue()); // Output: 20
```

### Edge Cases:
- For both structures, ensure to handle cases where you try to pop from an empty stack or dequeue from an empty queue by returning appropriate messages or values.

Question 5

Explain the concept of execution context in JavaScript. Demonstrate how closures work with an example.

Accepted Answer

In JavaScript, an execution context is the environment in which JavaScript code is evaluated and executed. It consists of the variable environment, the scope chain, and the `this` value. When a function is invoked, a new execution context is created.

### Closures:
A closure is a function that retains access to its lexical scope, even when the function is executed outside that scope. Closures are often used to maintain state in asynchronous programming.

### Example of a Closure:
```javascript
function makeCounter() {
    let count = 0;  // `count` is a private variable
    return function() {
        count += 1;  // Accessing the `count` variable
        return count;
    };
}

const counter = makeCounter();
console.log(counter()); // Output: 1
console.log(counter()); // Output: 2
console.log(counter()); // Output: 3
```
In this example, `makeCounter` creates a private variable `count` and returns an inner function that updates and returns `count`. Each time `counter` is called, it remembers the value of `count` from previous calls, demonstrating the closure's ability to maintain state.

SarthiQ

Interview Preparation Guide

Naukri
Questions & Answers

Document Details

Need Help?

Top Naukri Interview Questions

Naukri Interview Questions

A Full Stack Developer was asked

A Software Engineer was asked

Backend Developer

Software Engineer