Q: Explain the concept of recursion and implement a function to calculate Fibonacci numbers using recursion in Python.

Recursion is a programming technique where a function calls itself to solve a problem. For calculating Fibonacci numbers, the Fibonacci sequence is defined as follows: F(0) = 0, F(1) = 1, and F(n) = F(n-1) + F(n-2) for n > 1. Below is a Python implementation: ```python def fibonacci(n): if n < 0: raise ValueError('Input cannot be negative') elif n == 0: return 0 elif n == 1: return 1 else: return fibonacci(n - 1) + fibonacci(n - 2) # Test the function print(fibonacci(10)) # Output: 55 print(fibonacci(0)) # Output: 0 print(fibonacci(1)) # Output: 1 # Edge case try: print(fibonacci(-5)) # This should raise an exception except ValueError as e: print(e) ``` This code handles both positive and zero cases effectively and raises an exception for negative inputs.

Q: What are stacks and queues in data structures? Explain their differences and provide code examples for both.

Stacks and queues are fundamental data structures used to store and manage collections of data. - Stack: A stack follows the Last In First Out (LIFO) principle, meaning the last element added is the first to be removed. You can visualize it as a stack of plates where you can only add or remove the top plate. Here’s an implementation of a stack 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; } } ``` - Queue: A queue follows the First In First Out (FIFO) principle, meaning the first element added is the first to be removed. You can think of it like a line of people waiting for a service where the first person in line is the first to be served. Here’s an implementation of a queue in JavaScript: ```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; } } ``` In summary, stacks and queues serve different purposes in data management, with stacks being ideal for scenarios where reverse order processing is needed (like undo operations) and queues being suitable for scenarios where order preservation is crucial (like task scheduling).

Question 1

What are the different types of keys in a database, and how do primary, foreign, and unique keys differ?

Accepted Answer

In a database, keys are used to uniquely identify records and establish relationships between tables. The three main types of keys are:

1. Primary Key: A unique identifier for a record in a table. No two rows can have the same primary key value, and it cannot be null.
   - Example: In a `users` table, `user_id` can be a primary key.

2. Foreign Key: A field (or collection of fields) in one table that uniquely identifies a row of another table. This establishes a relationship between the two tables.
   - Example: In an `orders` table, `user_id` can be a foreign key referencing the `user_id` in the `users` table.

3. Unique Key: Ensures that all values in a column are different. Unlike primary keys, unique keys can accept null values.
   - Example: In a `users` table, `email` can be a unique key.

Here’s a simple SQL example to illustrate these keys:
```sql
CREATE TABLE users (
    user_id INT PRIMARY KEY,
    email VARCHAR(255) UNIQUE NOT NULL,
    name VARCHAR(100)
);

CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    user_id INT,
    FOREIGN KEY (user_id) REFERENCES users(user_id)
);
```
In this SQL code, `user_id` is a primary key in the `users` table, while it serves as a foreign key in the `orders` table, linking orders to users. The `email` field is a unique key, ensuring no two users can have the same email address.

Question 2

Can you explain the basic operations of arrays and strings in programming, and give an example of how to reverse a string using an array?

Accepted Answer

Arrays and strings are fundamental data structures in programming. An array is a collection of items stored at contiguous memory locations, while a string is an array of characters terminated by a null character.

Key Operations:
- Accessing: You can access elements using an index.
- Inserting: Inserting new elements requires shifting elements if the array is full.
- Deleting: This also requires shifting elements to maintain order.
- Searching: You can search for elements using algorithms like linear or binary search.

Here’s a simple example of reversing a string using an array in Python:
```python
def reverse_string(s):
    # Convert string to list (array)
    arr = list(s)
    left, right = 0, len(arr) - 1
    while left < right:
        # Swap elements
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
    return ''.join(arr)

# Test the function
input_string = "Hello, World!"
reversed_string = reverse_string(input_string)
print(reversed_string)  # Output: !dlroW ,olleH
```
This code defines a function that reverses an input string by utilizing an array-like approach, demonstrating basic array operations such as indexing and swapping.

Question 3

What are the four pillars of Object-Oriented Programming (OOP) and how do they differ from each other? Provide code examples in JavaScript for each pillar.

Accepted Answer

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

1. Encapsulation: This is the bundling of data with the methods that operate on that data. It restricts direct access to some of an object's components. This can be achieved through private and public access modifiers.
   ```javascript
   class Person {
       constructor(name, age) {
           this.name = name;
           this.age = age;
       }
       getName() {
           return this.name;
       }
       getAge() {
           return this.age;
       }
   }
   const person = new Person('John', 30);
   console.log(person.getName()); // John
   ```

2. Abstraction: This is the concept of hiding the complex reality while exposing only the necessary parts. It can be achieved using abstract classes or interfaces.
   ```javascript
   class Animal {
       speak() {
           throw new Error('This method must be overridden');
       }
   }
   class Dog extends Animal {
       speak() {
           return 'Woof!';
       }
   }
   const dog = new Dog();
   console.log(dog.speak()); // Woof!
   ```

3. Inheritance: This allows a class to inherit properties and methods from another class. It promotes code reusability.
   ```javascript
   class Vehicle {
       start() {
           return 'Vehicle started';
       }
   }
   class Car extends Vehicle {
       start() {
           return 'Car started';
       }
   }
   const car = new Car();
   console.log(car.start()); // Car started
   ```

4. Polymorphism: This allows methods to do different things based on the object it is acting upon, typically through method overriding.
   ```javascript
   class Cat extends Animal {
       speak() {
           return 'Meow!';
       }
   }
   const cat = new Cat();
   console.log(cat.speak()); // Meow!
   console.log(dog.speak()); // Woof!
   ```
   In summary, encapsulation is about hiding data, abstraction is about hiding complexity, inheritance is about acquiring properties, and polymorphism is about method behavior based on the derived class.

Question 4

Explain the concept of recursion and implement a function to calculate Fibonacci numbers using recursion in Python.

Accepted Answer

Recursion is a programming technique where a function calls itself to solve a problem. For calculating Fibonacci numbers, the Fibonacci sequence is defined as follows: F(0) = 0, F(1) = 1, and F(n) = F(n-1) + F(n-2) for n > 1. Below is a Python implementation:

```python
def fibonacci(n):
    if n < 0:
        raise ValueError('Input cannot be negative')
    elif n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

# Test the function
print(fibonacci(10))  # Output: 55
print(fibonacci(0))   # Output: 0
print(fibonacci(1))   # Output: 1
# Edge case
try:
    print(fibonacci(-5))  # This should raise an exception
except ValueError as e:
    print(e)
```
This code handles both positive and zero cases effectively and raises an exception for negative inputs.

Question 5

What are stacks and queues in data structures? Explain their differences and provide code examples for both.

Accepted Answer

Stacks and queues are fundamental data structures used to store and manage collections of data.

- Stack: A stack follows the Last In First Out (LIFO) principle, meaning the last element added is the first to be removed. You can visualize it as a stack of plates where you can only add or remove the top plate.

Here’s an implementation of a stack 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;
    }
}
```

- Queue: A queue follows the First In First Out (FIFO) principle, meaning the first element added is the first to be removed. You can think of it like a line of people waiting for a service where the first person in line is the first to be served.

Here’s an implementation of a queue in JavaScript:

```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;
    }
}
```

In summary, stacks and queues serve different purposes in data management, with stacks being ideal for scenarios where reverse order processing is needed (like undo operations) and queues being suitable for scenarios where order preservation is crucial (like task scheduling).

SarthiQ

Interview Preparation Guide

LinkedIn
Questions & Answers

Document Details

Need Help?

Top LinkedIn Interview Questions

LinkedIn Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

LinkedInQuestions & Answers

Document Details

Need Help?

Top LinkedIn Interview Questions

LinkedIn Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

LinkedIn
Questions & Answers