Question 1

What are primary keys and foreign keys in a relational database? Provide SQL examples to illustrate these concepts.

Accepted Answer

In a relational database, a primary key is a unique identifier for a record in a table, while a foreign key is a field in one table that uniquely identifies a row in another table. Here’s a simple illustration:

```sql
CREATE TABLE Users (
    user_id INT PRIMARY KEY,
    username VARCHAR(50) NOT NULL
);

CREATE TABLE Orders (
    order_id INT PRIMARY KEY,
    user_id INT,
    order_date DATE,
    FOREIGN KEY (user_id) REFERENCES Users(user_id)
);
```

In this example, the `user_id` in the `Users` table is defined as the primary key. In the `Orders` table, `user_id` serves as a foreign key referencing `Users`. This ensures that every order is linked to a valid user. If you attempt to insert an order with a `user_id` that doesn't exist in the `Users` table, the database will throw an error, maintaining referential integrity.

Question 2

How to build an accessible star rating component in React JS?

Accepted Answer

Creating an accessible star rating component in React involves using semantic HTML elements and ARIA attributes for better screen reader support. Here’s a simple implementation: ```javascript import React, { useState } from 'react'; const StarRating = ({ totalStars = 5 }) => { const [rating, setRating] = useState(0); const handleRating = (rate) => { setRating(rate); }; return (

Rate this product:

{[...Array(totalStars)].map((_, index) => { const starValue = index + 1; return ( = starValue} tabIndex={0} onClick={() => handleRating(starValue)} onKeyDown={(e) => e.key === 'Enter' && handleRating(starValue)} style={{ cursor: 'pointer', fontSize: '24px', color: rating >= starValue ? 'gold' : 'gray' }} > ★ ); })}

Your rating is: {rating}

); }; export default StarRating; ``` This component allows users to click on stars to set their rating and provides keyboard accessibility. The stars change color based on the current rating. It’s important to ensure that your components are usable by all users, including those with disabilities.

Question 3

Can you explain the Software Development Life Cycle (SDLC) and its phases? Provide a brief description and importance of each phase.

Accepted Answer

The Software Development Life Cycle (SDLC) is a structured process used for developing software applications. It consists of several distinct phases:

1. Requirement Analysis: This phase involves gathering requirements from stakeholders to understand what the software needs to achieve. Importance: It lays the foundation for the entire project.

2. Design: In this phase, the architecture of the software is designed, specifying how the application will function and the technologies to be used. Importance: A good design ensures that the software can be developed efficiently and meets the requirements.

3. Implementation (Coding): This is where developers write the code based on the design specifications. Importance: This phase translates designs into a working software application.

4. Testing: After coding, the software undergoes various tests to identify and fix bugs. Importance: Testing ensures the software is reliable and meets quality standards.

5. Deployment: Once testing is complete, the software is deployed to a production environment, making it available to users. Importance: Proper deployment ensures that users can access the software.

6. Maintenance: After deployment, the software will require updates and fixes. Importance: Ongoing maintenance ensures the software continues to function well and remains useful to users.

Each phase in the SDLC is crucial for delivering a high-quality software product, reducing risks, and ensuring that the final product meets user needs.

Question 4

Explain the four pillars of Object-Oriented Programming: encapsulation, abstraction, inheritance, and polymorphism.

Accepted Answer

Object-Oriented Programming (OOP) is based on four main principles: encapsulation, abstraction, inheritance, and polymorphism. Here’s a breakdown with examples:

1. Encapsulation: This involves bundling the data and methods that operate on the data within a single unit, or class. It restricts direct access to some of the object’s components.
   ```python
   class BankAccount:
       def __init__(self, balance):
           self.__balance = balance  # private variable

def deposit(self, amount):
           if amount > 0:
               self.__balance += amount

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

2. Abstraction: This principle focuses on hiding complex implementation details and showing only the essential features of the object. You can achieve abstraction using abstract classes or interfaces.
   ```python
   from abc import ABC, abstractmethod

class Animal(ABC):
       @abstractmethod
       def sound(self):
           pass

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

3. Inheritance: This allows a class (child) to inherit properties and methods from another class (parent), promoting code reuse.
   ```python
   class Vehicle:
       def start(self):
           return 'Vehicle started'

class Car(Vehicle):
       def honk(self):
           return 'Car honked'
   ```

4. Polymorphism: This allows methods to do different things based on the object it is acting upon, often implemented through method overriding.
   ```python
   class Cat(Animal):
       def sound(self):
           return 'Meow'

def make_sound(animal):
       print(animal.sound())

make_sound(Dog())  # Output: Bark
   make_sound(Cat())  # Output: Meow
   ```
Understanding these principles is crucial for effective software development, allowing for better design, maintenance, and scalability of code.

Question 5

Find the length of the longest increasing subarray.

Accepted Answer

To solve the problem of finding the length of the longest increasing subarray, you can iterate through the array while keeping track of the current length of the increasing subarray. Whenever you find that the current element is greater than the previous one, you increase the length. If not, you reset the length to 1. Here’s how you can implement this in Python:

```python
def longest_increasing_subarray(arr):
    if not arr:
        return 0
    max_length = 1
    current_length = 1

for i in range(1, len(arr)):
        if arr[i] > arr[i - 1]:
            current_length += 1
        else:
            max_length = max(max_length, current_length)
            current_length = 1
    max_length = max(max_length, current_length)  # final check
    return max_length

# Example usage:
print(longest_increasing_subarray([1, 2, 3, 2, 5]))  # Output: 3
print(longest_increasing_subarray([1, 1, 1, 1]))  # Output: 1
print(longest_increasing_subarray([]))  # Output: 0
```
This code handles edge cases such as empty arrays and arrays with all equal elements. The time complexity is O(n), making it efficient for large datasets.

SarthiQ

Interview Preparation Guide

Ola
Questions & Answers

Document Details

Need Help?

Top Ola Interview Questions

Ola Interview Questions

A Software Engineer was asked

A Frontend Developer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

OlaQuestions & Answers

Document Details

Need Help?

Top Ola Interview Questions

Ola Interview Questions

A Software Engineer was asked

A Frontend Developer was asked

Software Engineer

Software Engineer

Ola
Questions & Answers