Question 1

How do SQL aggregate functions like MAX, MIN, and AVG work? Provide SQL queries demonstrating their usage.

Accepted Answer

SQL aggregate functions perform calculations on a set of values and return a single value. The most commonly used aggregate functions include:
- MAX: Returns the maximum value.
- MIN: Returns the minimum value.
- AVG: Returns the average value.

Here’s how you can use these functions in SQL:

```sql
-- Create a table
CREATE TABLE Sales (
    ID INT PRIMARY KEY,
    Product VARCHAR(100),
    Amount DECIMAL(10, 2)
);

-- Insert sample data
INSERT INTO Sales (ID, Product, Amount) VALUES (1, 'Laptop', 1200.00);
INSERT INTO Sales (ID, Product, Amount) VALUES (2, 'Smartphone', 800.00);
INSERT INTO Sales (ID, Product, Amount) VALUES (3, 'Tablet', 600.00);

-- Using aggregate functions
SELECT MAX(Amount) AS MaxSale FROM Sales; -- Output: 1200.00
SELECT MIN(Amount) AS MinSale FROM Sales; -- Output: 600.00
SELECT AVG(Amount) AS AvgSale FROM Sales; -- Output: 866.67
```

These queries demonstrate how to use SQL aggregate functions to summarize data in the 'Sales' table. Each function processes the 'Amount' column and returns the corresponding maximum, minimum, and average values.

Question 2

Can you explain the basic operations on arrays and strings in programming? Provide a code example for both.

Accepted Answer

Arrays and strings are fundamental data structures in programming.

Arrays are collections of elements identified by index or key. Operations typically include insertion, deletion, and traversal. Strings are arrays of characters that represent text.

### Example Code for Array Operations:
```python
def insert_element(arr, index, element):
    if index < 0 or index > len(arr):
        return 'Index out of bounds'
    return arr[:index] + [element] + arr[index:]

arr = [1, 2, 3, 4]
new_arr = insert_element(arr, 2, 99)
print(new_arr)  # Output: [1, 2, 99, 3, 4]
```

### Example Code for String Operations:
```python
def reverse_string(s):
    return s[::-1]

string = 'Hello'
reversed_string = reverse_string(string)
print(reversed_string)  # Output: 'olleH'
```
Both examples illustrate basic manipulation of arrays and strings. Edge cases like empty arrays and strings should be handled appropriately in a full implementation.

Question 3

How can you manage complex state in a React application using the Context API and useReducer hook? Provide an example.

Accepted Answer

In React, managing state across multiple components can become complex. The Context API combined with the useReducer hook allows for centralized state management without prop drilling. Here's an example of how to implement this: 1. Create a context and a provider component: ```javascript import React, { createContext, useReducer } from 'react'; const initialState = { count: 0 }; const CountContext = createContext(initialState); const countReducer = (state, action) => { switch (action.type) { case 'increment': return { ...state, count: state.count + 1 }; case 'decrement': return { ...state, count: state.count - 1 }; default: return state; } }; export const CountProvider = ({ children }) => { const [state, dispatch] = useReducer(countReducer, initialState); return ( {children} ); }; ``` 2. Use the context in your components: ```javascript import React, { useContext } from 'react'; import { CountContext } from './CountProvider'; const Counter = () => { const { state, dispatch } = useContext(CountContext); return (

{state.count}

); }; ``` 3. Wrap your application with the provider: ```javascript import React from 'react'; import ReactDOM from 'react-dom'; import { CountProvider } from './CountProvider'; import App from './App'; ReactDOM.render( , document.getElementById('root') ); ``` In this example, the `CountProvider` allows any child component to access and modify the count state efficiently. This pattern is especially useful in larger applications where state needs to be shared across multiple components.

Question 4

What are the differences between trees and graphs in data structures? Provide examples of scenarios where each would be used.

Accepted Answer

Trees and graphs are fundamental data structures used to represent hierarchical and interconnected data, respectively.

### Differences:
- Structure: A tree is a hierarchical structure with a single root node and each node having zero or more child nodes. A graph is a collection of nodes (vertices) connected by edges.
- Cycles: Trees do not contain cycles, whereas graphs can have cycles.
- Connectivity: In trees, there is exactly one path between any two nodes, while in graphs, there can be multiple paths.

### Use Cases:
- Trees: Used in scenarios such as representing hierarchies (e.g., file systems, organization structures) or in search algorithms (e.g., binary search trees).
- Graphs: Used for representing networks (e.g., social networks, transportation networks).

### Example of a Binary Tree:
```python
class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

class BinaryTree:
    def __init__(self):
        self.root = None
```  
### Example of a Graph:
```python
class Graph:
    def __init__(self):
        self.graph = {}

def add_edge(self, u, v):
        if u not in self.graph:
            self.graph[u] = []
        self.graph[u].append(v)
```

Question 5

What are the core principles of Object Oriented Programming (OOP)? Provide examples for each principle in JavaScript.

Accepted Answer

Object Oriented Programming (OOP) is a programming paradigm based on the concept of 'objects', which can contain data and code. The core principles of OOP are:

1. Encapsulation: This principle restricts direct access to some of an object's components, which is a means of preventing unintended interference and misuse.
   - Example:
   ```javascript
   class User {
     constructor(name, age) {
       this.name = name;
       this.age = age;
     }
     getName() {
       return this.name;
     }
   }
   const user = new User('Alice', 30);
   console.log(user.getName()); // Outputs: Alice
   ```

2. Abstraction: This principle focuses on hiding the complex reality while exposing only the necessary parts. It helps to reduce programming complexity and increase efficiency.
   - Example:
   ```javascript
   class Car {
     start() {
       this._engineStart();
     }
     _engineStart() {
       console.log('Engine started.');
     }
   }
   const car = new Car();
   car.start(); // Outputs: Engine started.
   ```

3. Inheritance: This allows a class to inherit properties and methods from another class. It promotes code reusability.
   - Example:
   ```javascript
   class Animal {
     speak() {
       console.log('Animal speaks');
     }
   }
   class Dog extends Animal {
     speak() {
       console.log('Woof!');
     }
   }
   const dog = new Dog();
   dog.speak(); // Outputs: Woof!
   ```

4. Polymorphism: This principle allows methods to do different things based on the object it is acting upon. It can be achieved via method overriding and method overloading.
   - Example:
   ```javascript
   class Shape {
     area() {
       return 0;
     }
   }
   class Circle extends Shape {
     constructor(radius) {
       super();
       this.radius = radius;
     }
     area() {
       return Math.PI * this.radius * this.radius;
     }
   }
   class Square extends Shape {
     constructor(side) {
       super();
       this.side = side;
     }
     area() {
       return this.side * this.side;
     }
   }
   const shapes = [new Circle(5), new Square(4)];
   shapes.forEach(shape => {
     console.log(shape.area());
   }); // Outputs: Area of circle and area of square
   ```

Understanding and applying these core principles of OOP can lead to more organized, modular, and reusable code in software development.

SarthiQ

Interview Preparation Guide

CRED
Questions & Answers

Document Details

Need Help?

Top CRED Interview Questions

CRED Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Frontend Developer

Software Engineer

Interview Preparation Guide

CREDQuestions & Answers

Document Details

Need Help?

Top CRED Interview Questions

CRED Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Frontend Developer

Software Engineer

CRED
Questions & Answers