Q: What are SQL aggregate functions? Provide examples using MAX, MIN, and AVG.

SQL aggregate functions perform a calculation on a set of values and return a single value. Common aggregate functions include MAX, MIN, and AVG. Below are examples using these functions: Assume we have a table named `sales`: ```sql CREATE TABLE sales ( id INT, amount DECIMAL(10, 2) ); INSERT INTO sales (id, amount) VALUES (1, 150.00), (2, 200.00), (3, 50.00); ``` 1. MAX: To find the highest sale amount: ```sql SELECT MAX(amount) AS MaxSale FROM sales; ``` 2. MIN: To find the lowest sale amount: ```sql SELECT MIN(amount) AS MinSale FROM sales; ``` 3. AVG: To calculate the average sale amount: ```sql SELECT AVG(amount) AS AverageSale FROM sales; ``` These aggregate functions enable users to summarize data efficiently. They handle edge cases like empty tables by returning NULL, ensuring that the queries remain robust.

Q: What is the significance of ACID properties in a database management system? Explain each property with an example.

ACID properties are critical for a reliable database system, ensuring that transactions are processed reliably. ACID stands for Atomicity, Consistency, Isolation, and Durability. 1. Atomicity: This property ensures that all operations within a transaction are completed successfully. If any operation fails, the entire transaction is rolled back. Example: ```sql BEGIN TRANSACTION; INSERT INTO accounts (account_id, balance) VALUES (1, 100); INSERT INTO accounts (account_id, balance) VALUES (2, 200); -- Suppose the second insert fails ROLLBACK; -- Both inserts will be undone ``` 2. Consistency: This property ensures that a transaction takes the database from one valid state to another, maintaining all predefined rules like constraints, cascades, and triggers. Example: If a bank has a rule that an account balance cannot go below zero, a transaction attempting to withdraw money that would violate this rule should not be allowed: ```sql BEGIN TRANSACTION; UPDATE accounts SET balance = balance - 500 WHERE account_id = 1; -- If balance < 0, this transaction fails, maintaining consistency ROLLBACK; ``` 3. Isolation: This property ensures that transactions are executed in isolation from one another. The intermediate state of a transaction is invisible to other transactions. Example: ```sql BEGIN TRANSACTION; UPDATE accounts SET balance = balance - 100 WHERE account_id = 1; -- Another transaction cannot see this update until it is committed COMMIT; ``` 4. Durability: Once a transaction has been committed, it will remain so, even in the event of a power loss or system crash. The changes are saved to a permanent storage. Example: ```sql COMMIT; -- Changes are written to the disk, ensuring durability ``` These ACID properties are essential in transactional systems such as banking, where data integrity and reliability are paramount.

Question 1

Explain the four pillars of Object Oriented Programming (OOP) with examples. How would you implement these concepts in a simple Python class?

Accepted Answer

The four pillars of Object Oriented Programming are Encapsulation, Abstraction, Inheritance, and Polymorphism.

1. Encapsulation: This is the concept of wrapping data (attributes) and methods (functions) together into a single unit or class. It restricts direct access to some of the object's components.

Example:
   ```python
   class BankAccount:
       def __init__(self, account_number, balance=0):
           self.__account_number = account_number  # private attribute
           self.__balance = balance  # private attribute

def deposit(self, amount):
           if amount > 0:
               self.__balance += amount
           else:
               raise ValueError('Deposit amount must be positive')

def get_balance(self):
           return self.__balance
   ```

2. Abstraction: Abstraction is the concept of hiding the complex reality while exposing only the necessary parts. It allows a programmer to focus on interactions at a high level.

Example:
   ```python
   from abc import ABC, abstractmethod

class Shape(ABC):
       @abstractmethod
       def area(self):
           pass

class Circle(Shape):
       def __init__(self, radius):
           self.radius = radius

def area(self):
           return 3.14 * (self.radius  2)
   ```

3. Inheritance: Inheritance is a mechanism where a new class can inherit properties and methods from an existing class. This promotes code reusability.

Example:
   ```python
   class Animal:
       def speak(self):
           return 'Animal sound'

class Dog(Animal):
       def speak(self):
           return 'Bark'
   ```

4. Polymorphism: Polymorphism allows methods to do different things based on the object it is acting upon. This can be achieved through method overriding and method overloading.

Example:
   ```python
   def animal_sound(animal):
       print(animal.speak())

dog = Dog()
   animal_sound(dog)  # Output: Bark
   ```

In this example, `animal_sound` can accept any type of animal and call its `speak` method, demonstrating polymorphism.

Question 2

What are stacks and queues in data structures? Provide examples of their implementation in JavaScript.

Accepted Answer

Stacks and queues are fundamental data structures used in programming.

A stack is a Last In First Out (LIFO) data structure, meaning the last element added is the first one to be removed. It can be implemented using an array in JavaScript as follows:

```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()); // Outputs: 2
console.log(stack.peek()); // Outputs: 1
```

A queue, on the other hand, is a First In First Out (FIFO) data structure, where the first element added is the first one to be removed. It can also be implemented using an array:

```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()); // Outputs: 1
console.log(queue.front()); // Outputs: 2
```

Both stacks and queues handle edge cases, such as operations on empty structures. For example, trying to pop from an empty stack or dequeue from an empty queue should return null or an appropriate message to indicate the operation cannot be performed.

Question 3

How does recursion work in algorithms? Demonstrate with a Fibonacci sequence example.

Accepted Answer

Recursion is a programming technique where a function calls itself to solve smaller subproblems until it reaches a base case. It's particularly useful for problems that can be divided into similar subproblems, such as calculating Fibonacci numbers.

The Fibonacci sequence is defined as follows:
- F(0) = 0
- F(1) = 1
- F(n) = F(n-1) + F(n-2) for n > 1

Here's a recursive implementation of the Fibonacci sequence in JavaScript:

```javascript
function fibonacci(n) {
    if (n < 0) throw new Error('Negative arguments are not allowed');
    if (n === 0) return 0;
    if (n === 1) return 1;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

console.log(fibonacci(5)); // Outputs: 5
console.log(fibonacci(10)); // Outputs: 55
```

In this implementation, the function checks for negative input and handles the base cases for `n = 0` and `n = 1`. For other values of `n`, it recursively calls itself to calculate the previous two Fibonacci numbers until it reaches the base cases.

However, this recursive approach has exponential time complexity, making it inefficient for large `n`. An iterative approach or using memoization is often recommended to optimize performance:

```javascript
function fibonacciMemo(n, memo = {}) {
    if (n < 0) throw new Error('Negative arguments are not allowed');
    if (n in memo) return memo[n];
    if (n === 0) return 0;
    if (n === 1) return 1;
    memo[n] = fibonacciMemo(n - 1, memo) + fibonacciMemo(n - 2, memo);
    return memo[n];
}

console.log(fibonacciMemo(50)); // Outputs: 12586269025
```
Using memoization significantly reduces the time complexity to linear, making it feasible to calculate larger Fibonacci numbers efficiently.

Question 4

What are SQL aggregate functions? Provide examples using MAX, MIN, and AVG.

Accepted Answer

SQL aggregate functions perform a calculation on a set of values and return a single value. Common aggregate functions include MAX, MIN, and AVG. Below are examples using these functions:

Assume we have a table named `sales`:

```sql
CREATE TABLE sales (
    id INT,
    amount DECIMAL(10, 2)
);
INSERT INTO sales (id, amount) VALUES (1, 150.00), (2, 200.00), (3, 50.00);
```

1. MAX: To find the highest sale amount:

```sql
SELECT MAX(amount) AS MaxSale FROM sales;
```

2. MIN: To find the lowest sale amount:

```sql
SELECT MIN(amount) AS MinSale FROM sales;
```

3. AVG: To calculate the average sale amount:

```sql
SELECT AVG(amount) AS AverageSale FROM sales;
```

These aggregate functions enable users to summarize data efficiently. They handle edge cases like empty tables by returning NULL, ensuring that the queries remain robust.

Question 5

What is the significance of ACID properties in a database management system? Explain each property with an example.

Accepted Answer

ACID properties are critical for a reliable database system, ensuring that transactions are processed reliably. ACID stands for Atomicity, Consistency, Isolation, and Durability.

1. Atomicity: This property ensures that all operations within a transaction are completed successfully. If any operation fails, the entire transaction is rolled back.
   Example:
   ```sql
   BEGIN TRANSACTION;
   INSERT INTO accounts (account_id, balance) VALUES (1, 100);
   INSERT INTO accounts (account_id, balance) VALUES (2, 200);
   -- Suppose the second insert fails
   ROLLBACK;  -- Both inserts will be undone
   ```

2. Consistency: This property ensures that a transaction takes the database from one valid state to another, maintaining all predefined rules like constraints, cascades, and triggers.
   Example:
   If a bank has a rule that an account balance cannot go below zero, a transaction attempting to withdraw money that would violate this rule should not be allowed:
   ```sql
   BEGIN TRANSACTION;
   UPDATE accounts SET balance = balance - 500 WHERE account_id = 1;
   -- If balance < 0, this transaction fails, maintaining consistency
   ROLLBACK;
   ```

3. Isolation: This property ensures that transactions are executed in isolation from one another. The intermediate state of a transaction is invisible to other transactions.
   Example:
   ```sql
   BEGIN TRANSACTION;
   UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
   -- Another transaction cannot see this update until it is committed
   COMMIT;
   ```

4. Durability: Once a transaction has been committed, it will remain so, even in the event of a power loss or system crash. The changes are saved to a permanent storage.
   Example:
   ```sql
   COMMIT;
   -- Changes are written to the disk, ensuring durability
   ```

These ACID properties are essential in transactional systems such as banking, where data integrity and reliability are paramount.

SarthiQ

Interview Preparation Guide

Intuit
Questions & Answers

Document Details

Need Help?

Top Intuit Interview Questions

Intuit Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

IntuitQuestions & Answers

Document Details

Need Help?

Top Intuit Interview Questions

Intuit Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Intuit
Questions & Answers