Question 1

How would you implement a function to count the frequency of elements in an array and identify duplicates? Provide code examples.

Accepted Answer

To count the frequency of elements in an array and identify duplicates, we can use a hashmap (or dictionary) to keep track of the count of each element. Here’s a simple approach to achieve this: Python Example: ```python def count_frequencies(arr): frequency_dict = {} duplicates = [] for item in arr: if item in frequency_dict: frequency_dict[item] += 1 if frequency_dict[item] == 2: # Only add on first duplicate duplicates.append(item) else: frequency_dict[item] = 1 return frequency_dict, duplicates # Example usage array = [1, 2, 2, 3, 4, 4, 4, 5] frequency, duplicates = count_frequencies(array) print("Frequencies:", frequency) # Output: {1: 1, 2: 2, 3: 1, 4: 3, 5: 1} print("Duplicates:", duplicates) # Output: [2, 4] ``` Java Example: ```java import java.util.HashMap; import java.util.ArrayList; import java.util.List; public class Main { public static void main(String[] args) { int[] array = {1, 2, 2, 3, 4, 4, 4, 5}; HashMap frequencyMap = countFrequencies(array); System.out.println("Frequencies: " + frequencyMap); } public static HashMap countFrequencies(int[] arr) { HashMap frequencyMap = new HashMap<>(); List duplicates = new ArrayList<>(); for (int item : arr) { frequencyMap.put(item, frequencyMap.getOrDefault(item, 0) + 1); if (frequencyMap.get(item) == 2) { duplicates.add(item); } } System.out.println("Duplicates: " + duplicates); return frequencyMap; } } ``` In both code examples, we iterate through the array, updating our frequency count in a map. We also track duplicates by checking when the count reaches 2. This solution effectively handles edge cases like empty arrays and works for any integer input.

Question 2

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 related columns. The main types of SQL joins are INNER JOIN, LEFT JOIN, RIGHT JOIN, and FULL OUTER JOIN.

1. INNER JOIN: Returns records with matching values in both tables.
   
   ```sql
   SELECT a.id, a.name, b.order_id
   FROM customers a
   INNER JOIN orders b ON a.id = b.customer_id;
   ```

2. LEFT JOIN: Returns all records from the left table and matched records from the right table. If there is no match, NULL values are returned for columns from the right table.
   
   ```sql
   SELECT a.id, a.name, b.order_id
   FROM customers a
   LEFT JOIN orders b ON a.id = b.customer_id;
   ```

3. RIGHT JOIN: Returns all records from the right table and matched records from the left table. If there is no match, NULL values are returned for columns from the left table.
   
   ```sql
   SELECT a.id, a.name, b.order_id
   FROM customers a
   RIGHT JOIN orders b ON a.id = b.customer_id;
   ```

4. FULL OUTER JOIN: Returns all records when there is a match in either left or right table records. 
   
   ```sql
   SELECT a.id, a.name, b.order_id
   FROM customers a
   FULL OUTER JOIN orders b ON a.id = b.customer_id;
   ```

These joins are crucial for retrieving data from multiple tables in relational databases effectively.

Question 3

How do you manipulate arrays and strings in Python? Provide examples of common operations.

Accepted Answer

In Python, arrays are usually represented by lists, and strings are sequences of characters. Here are some common operations:

1. Creating an Array (List):
   
   ```python
   fruits = ['apple', 'banana', 'cherry']
   ```

2. Accessing Elements:
   
   ```python
   print(fruits[1])  # Output: banana
   ```

3. Adding Elements:
   
   ```python
   fruits.append('orange')
   print(fruits)  # Output: ['apple', 'banana', 'cherry', 'orange']
   ```

4. Removing Elements:
   
   ```python
   fruits.remove('banana')
   print(fruits)  # Output: ['apple', 'cherry', 'orange']
   ```

5. String Manipulation:
   - Concatenation:
   
   ```python
   greeting = 'Hello'
   name = 'World'
   message = greeting + ' ' + name
   print(message)  # Output: Hello World
   ```
   - Slicing:
   
   ```python
   text = 'Hello World'
   print(text[0:5])  # Output: Hello
   ```
   - String Length:
   
   ```python
   print(len(text))  # Output: 11
   ```

These operations form the basis for data manipulation in Python, allowing developers to work efficiently with collections of data.

Question 4

How can you use CSS Flexbox to create a responsive grid layout for a trading dashboard in Zerodha?

Accepted Answer

To create a responsive grid layout using CSS Flexbox, you can define a container that uses display: flex and then apply appropriate flex properties to its children. For example, the following code demonstrates a simple trading dashboard layout with three columns that adjust based on the viewport size:

```css
.dashboard {
  display: flex;
  flex-wrap: wrap;
  justify-content: space-between;
}

.card {
  flex: 1 1 30%; /* Grow, shrink, base width */
  margin: 10px;
  background-color: #f8f9fa;
  border: 1px solid #dee2e6;
  border-radius: 5px;
  padding: 20px;
  box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
}

@media (max-width: 768px) {
  .card {
    flex: 1 1 100%; /* Full width on smaller screens */
  }
}
```

This code snippet defines a `.dashboard` class with children having the `.card` class. The cards will adjust their size to fit the container. On smaller screens, the cards stack vertically, ensuring a good user experience on mobile devices.

Question 5

Can you explain the differences between various sorting algorithms and implement a quicksort algorithm in Python? How does the choice of sorting algorithm impact performance in a trading application like Zerodha?

Accepted Answer

Sorting algorithms can vary significantly in their time complexity and efficiency based on the data set. In a trading application such as Zerodha, where performance is critical, choosing an optimal sorting algorithm can impact the speed of order execution and data retrieval. Here is an implementation of the Quicksort algorithm in Python:

```python
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# Example usage:
data = [3, 6, 8, 10, 1, 2, 1]
sorted_data = quicksort(data)
print(sorted_data)  # Output: [1, 1, 2, 3, 6, 8, 10]
```
In terms of performance:
- Quicksort has an average-case time complexity of O(n log n) but can degrade to O(n²) in the worst case if not implemented with optimizations like choosing a good pivot.
- Mergesort is stable and works well for large datasets but requires O(n) additional space.
- Heapsort offers O(n log n) time complexity with O(1) space but is not stable. 
In trading applications, where data sets can be large and performance is paramount, the choice of sorting algorithm can lead to significant differences in execution time and responsiveness of the system, particularly during peak trading hours.

SarthiQ

Interview Preparation Guide

Zerodha
Questions & Answers

Document Details

Need Help?

Top Zerodha Interview Questions

Zerodha Interview Questions

A Software Engineer was asked

A Backend Developer was asked

Full Stack Developer

Frontend Developer