Question 1

Explain the differences between stacks and queues. Provide a code example of each data structure in JavaScript.

Accepted Answer

Stacks and queues are fundamental data structures that manage collections of items, but they operate differently. A stack follows the Last In, First Out (LIFO) principle, meaning the last item added is the first one to be removed. A queue follows the First In, First Out (FIFO) principle, where the first item added is the first one to be removed.

Here’s a code example of a stack implemented in JavaScript:

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

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

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

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

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

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

And here’s an example of a queue:

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

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

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

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

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

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

The stack provides methods to add (`push`), remove (`pop`), and view the top element (`peek`), while the queue provides methods to add (`enqueue`), remove (`dequeue`), and view the front element (`front`). Understanding these data structures is crucial for efficient algorithm design and performance optimization.

Question 2

Explain the use of SQL subqueries and nested queries. Provide an example that retrieves employees who earn more than the average salary in their department.

Accepted Answer

Subqueries and nested queries in SQL allow you to execute a query within another query. A subquery is often used in the WHERE clause to filter results based on the output of another query.

Here’s an example showing how to retrieve employees who earn more than the average salary in their department:

```sql
SELECT employee_id, employee_name, salary
FROM employees e
WHERE salary > (
    SELECT AVG(salary)
    FROM employees
    WHERE department_id = e.department_id
);
```

In this example, the inner query calculates the average salary of employees in the same department as the outer query’s current employee (`e`). The outer query then filters employees whose salary exceeds that average.

This structure allows for powerful data retrieval while maintaining clarity and organization in complex queries. It is important to ensure that the subquery returns a single value when used in a condition like this to avoid errors.

Edge cases to consider include departments with no employees, which would result in a `NULL` average. You may want to handle this with additional conditions to ensure your query returns valid results.

Question 3

Can you explain how to traverse a linked list? Provide an example in code to demonstrate this process.

Accepted Answer

Traversing a linked list involves accessing each node in the list sequentially. A linked list consists of nodes, where each node contains data and a pointer to the next node.

Here's a simple implementation of a singly linked list in Python and a function to traverse it:

```python
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node

def traverse(self):
        current = self.head
        while current:
            print(current.data, end=' -> ')
            current = current.next
        print('None')

# Example usage
linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)
linked_list.traverse()  # Output: 1 -> 2 -> 3 -> None
```

In this example, we create a linked list, append three nodes to it, and then traverse the list, printing the data of each node. The traversal continues until there are no more nodes (i.e., when `current` becomes `None`).

Traversing a linked list is essential for operations like searching, displaying, and modifying the list's content.

Question 4

Explain the ACID properties of a transaction in a Database Management System (DBMS). Why are they important in the context of Database design?

Accepted Answer

ACID stands for Atomicity, Consistency, Isolation, and Durability. These properties ensure reliable processing of database transactions.

1. Atomicity: This property ensures that a transaction is an all-or-nothing operation. If any part of the transaction fails, the entire transaction fails, and the database state is unchanged.

Example:
   ```sql
   BEGIN TRANSACTION;
   INSERT INTO accounts (id, balance) VALUES (1, 100);
   INSERT INTO accounts (id, balance) VALUES (2, 200);
   COMMIT;
   ```
   If the second insert fails, the first will also not be committed.

2. Consistency: This ensures that a transaction brings the database from one valid state to another, maintaining database invariants. For example, if a database has a constraint that the balance cannot be negative, this must hold true after a transaction.

3. Isolation: This property ensures that transactions occur independently without interference. For example, if two transactions are executed concurrently, the outcome should be the same as if they were executed sequentially.

4. Durability: Once a transaction has been committed, it will remain so, even in the event of a system failure. This is typically achieved through database logs.

Understanding ACID properties is crucial in database design to ensure data integrity and reliability, especially in multi-user environments. If not properly managed, it can lead to data corruption and inconsistency, which can have serious implications for business operations.

Question 5

What are the basic operations that can be performed on arrays and strings in programming? Provide code examples to demonstrate these operations.

Accepted Answer

Arrays and strings are fundamental data structures in programming.

Basic Operations on Arrays:
1. Insertion: Adding an element to an array.
   ```python
   def insert(arr, element, index):
       arr.insert(index, element)
       return arr
   
   my_array = [1, 2, 3, 4]
   print(insert(my_array, 5, 2))  # Output: [1, 2, 5, 3, 4]
   ```

2. Deletion: Removing an element from an array.
   ```python
   def delete(arr, index):
       if index < len(arr):
           arr.pop(index)
       return arr
   
   my_array = [1, 2, 3, 4]
   print(delete(my_array, 2))  # Output: [1, 2, 4]
   ```

3. Traversal: Accessing each element in an array.
   ```python
   def traverse(arr):
       return [x for x in arr]
   
   my_array = [1, 2, 3, 4]
   print(traverse(my_array))  # Output: [1, 2, 3, 4]
   ```

Basic Operations on Strings:
1. Concatenation: Joining two strings together.
   ```python
   def concatenate(str1, str2):
       return str1 + str2
   
   print(concatenate('Hello, ', 'World!'))  # Output: 'Hello, World!'
   ```

2. Substring: Extracting a part of a string.
   ```python
   def substring(s, start, end):
       return s[start:end]
   
   print(substring('Hello, World!', 7, 12))  # Output: 'World'
   ```

3. Length: Finding the length of a string.
   ```python
   def length(s):
       return len(s)
   
   print(length('Hello'))  # Output: 5
   ```

These operations are fundamental for manipulating data in programming and are widely used in various applications.

SarthiQ

Interview Preparation Guide

Atlassian
Questions & Answers

Document Details

Need Help?

Top Atlassian Interview Questions

Atlassian Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

AtlassianQuestions & Answers

Document Details

Need Help?

Top Atlassian Interview Questions

Atlassian Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Atlassian
Questions & Answers