Q: Compare and contrast REST and GraphQL for API design. In what scenarios would you prefer one over the other?

REST (Representational State Transfer) and GraphQL are two approaches to API design that serve different needs. REST is resource-oriented, using HTTP methods like GET, POST, PUT, and DELETE to interact with resources identified by URLs. GraphQL, on the other hand, offers a more flexible query language that allows clients to request exactly the data they need, thus reducing over-fetching and under-fetching issues. ### REST API Example ```javascript const express = require('express'); const app = express(); app.get('/users', (req, res) => { res.json([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]); }); app.listen(3000, () => { console.log('REST API running on port 3000'); }); ``` ### GraphQL API Example ```javascript const express = require('express'); const { graphqlHTTP } = require('express-graphql'); const { buildSchema } = require('graphql'); const schema = buildSchema(` type User { id: Int name: String } type Query { users: [User] } `); const root = { users: () => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }] }; const app = express(); app.use('/graphql', graphqlHTTP({ schema: schema, rootValue: root, graphiql: true, })); app.listen(3000, () => { console.log('GraphQL API running on port 3000'); }); ``` ### When to Use Each - Use REST when your application is simple, and the resources can be easily mapped to URLs. REST is often easier for caching and is widely understood. - Use GraphQL when you need more flexibility in querying data, especially for complex relationships, or when you want to minimize data transfer between client and server. In summary, the choice between REST and GraphQL depends on the specific needs of your application and the complexity of the data interactions required.

Question 1

Explain dynamic programming and illustrate it with an example of solving the Fibonacci sequence problem using memoization.

Accepted Answer

Dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems. It stores the results of subproblems to avoid redundant calculations, which is useful in optimization problems.

### Example: Fibonacci Sequence using Memoization

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

Using memoization to optimize:
```javascript
const fibonacci = (n, memo = {}) => {
  if (n in memo) return memo[n];
  if (n <= 1) return n;
  memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
  return memo[n];
};

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

In this implementation:
- We check if the value is already computed and stored in `memo`.
- If not, we compute it recursively and store the result, thus reducing the time complexity from exponential to linear (O(n)).

This highlights the power of dynamic programming in optimizing recursive algorithms.

Question 2

What are the main principles of Object-Oriented Programming (OOP) and how do they apply to software design?

Accepted Answer

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

1. Encapsulation: Bundling the data (attributes) and methods (functions) that operate on the data into a single unit, or class. This restricts direct access to some components and can prevent accidental interference.

```javascript
   class BankAccount {
       constructor(balance) {
           this._balance = balance;
       }
       deposit(amount) {
           this._balance += amount;
       }
       getBalance() {
           return this._balance;
       }
   }
   ```

2. Abstraction: Hiding complex implementation details and showing only the essential features of the object. This can be achieved using abstract classes or interfaces.

```javascript
   class Shape {
       area() {
           throw new Error('Method not implemented');
       }
   }
   class Circle extends Shape {
       constructor(radius) {
           super();
           this.radius = radius;
       }
       area() {
           return Math.PI * this.radius  2;
       }
   }
   ```

3. Inheritance: Allowing a class (child) to inherit properties and methods from another class (parent). This promotes code reusability.

```javascript
   class Animal {
       speak() {
           console.log('Animal speaks');
       }
   }
   class Dog extends Animal {
       speak() {
           console.log('Woof!');
       }
   }
   ```

4. Polymorphism: Allowing methods to do different things based on the object it is acting upon, typically implemented through method overriding or interfaces.

```javascript
   const animals = [new Dog(), new Cat()];
   animals.forEach(animal => animal.speak()); // Outputs 'Woof!' and 'Meow!'
   ```

### Application in Software Design:
OOP principles help in designing software that is modular, flexible, and maintainable. By encapsulating data, developers can create components that are easier to manage and understand. Abstraction reduces complexity, inheritance allows for code reuse, and polymorphism enables dynamic method resolution. Together, these principles lead to cleaner and more organized code, ultimately resulting in robust software solutions.

Complexity: Medium
Role: Full Stack Developer
Year: 2024

Question 3

What are the most important coding questions for TCS Ninja related to Data Structures, specifically Arrays and Strings? Provide solutions to two example problems.

Accepted Answer

### Problem 1: Find the maximum product of two integers in an array. Problem Statement: Given an array of integers, find two numbers such that their product is maximum and return that product. Solution: To solve this problem, we can iterate through the array and keep track of the two largest numbers. The product of these two numbers will be the maximum product. ```python def max_product(arr): if len(arr) < 2: return None # Not enough elements max1 = max(arr[0], arr[1]) max2 = min(arr[0], arr[1]) for i in range(2, len(arr)): if arr[i] > max1: max2 = max1 max1 = arr[i] elif arr[i] > max2: max2 = arr[i] return max1 * max2 # Example Usage array = [1, 20, 3, 4, 5] print(max_product(array)) # Output: 100 ``` ### Problem 2: Check if a string is a palindrome. Problem Statement: Write a function that checks if a given string is a palindrome, considering only alphanumeric characters and ignoring case. Solution: We can use two pointers: one starting at the beginning of the string and the other at the end, moving towards the center. ```python def is_palindrome(s): s = ''.join(c for c in s if c.isalnum()).lower() left, right = 0, len(s) - 1 while left < right: if s[left] != s[right]: return False left += 1 right -= 1 return True # Example Usage string = "A man, a plan, a canal: Panama" print(is_palindrome(string)) # Output: True ```

Question 4

Compare and contrast REST and GraphQL for API design. In what scenarios would you prefer one over the other?

Accepted Answer

REST (Representational State Transfer) and GraphQL are two approaches to API design that serve different needs. REST is resource-oriented, using HTTP methods like GET, POST, PUT, and DELETE to interact with resources identified by URLs. GraphQL, on the other hand, offers a more flexible query language that allows clients to request exactly the data they need, thus reducing over-fetching and under-fetching issues.

### REST API Example
```javascript
const express = require('express');
const app = express();

app.get('/users', (req, res) => {
    res.json([{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]);
});

app.listen(3000, () => {
    console.log('REST API running on port 3000');
});
```

### GraphQL API Example
```javascript
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const schema = buildSchema(`
    type User {
        id: Int
        name: String
    }
    type Query {
        users: [User]
    }
`);

const root = { users: () => [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }] };

const app = express();
app.use('/graphql', graphqlHTTP({
    schema: schema,
    rootValue: root,
    graphiql: true,
}));

app.listen(3000, () => {
    console.log('GraphQL API running on port 3000');
});
```

### When to Use Each
- Use REST when your application is simple, and the resources can be easily mapped to URLs. REST is often easier for caching and is widely understood.
- Use GraphQL when you need more flexibility in querying data, especially for complex relationships, or when you want to minimize data transfer between client and server.

In summary, the choice between REST and GraphQL depends on the specific needs of your application and the complexity of the data interactions required.

Question 5

What are the fundamental differences between HTTP and TCP/IP, and how do they work together in web communication?

Accepted Answer

HTTP (Hypertext Transfer Protocol) and TCP/IP (Transmission Control Protocol/Internet Protocol) are critical components of web communication, but they operate at different layers of the internet protocol suite.

HTTP:
- HTTP is an application-layer protocol used for transmitting hypertext via the World Wide Web. 
- It is stateless, meaning each request from a client to a server is treated as independent. 
- HTTP operates over TCP, relying on the reliability and ordering provided by TCP.

Example of an HTTP Request:
```http
GET /index.html HTTP/1.1
Host: www.example.com
Connection: keep-alive
```

TCP/IP:
- TCP is a transport-layer protocol responsible for ensuring reliable transmission of data packets. 
- IP is a network-layer protocol that handles the addressing and routing of packets across network boundaries. 
- TCP establishes a connection (using a three-way handshake) and ensures that packets are delivered in the correct order and without errors.

How They Work Together:
- When a user requests a web page, the browser sends an HTTP request to the server, which uses TCP to establish a connection. 
- The TCP layer handles packetization of the HTTP request, ensuring it reaches the server reliably. 
- Once the server processes the request, it sends back an HTTP response through the same TCP connection.

Example of TCP Handshake (in pseudocode):
```plaintext
1. Client -> Server: SYN (synchronize)
2. Server -> Client: SYN-ACK (synchronize-acknowledge)
3. Client -> Server: ACK (acknowledge)
```

In summary, while HTTP is focused on the content being transferred, TCP/IP is concerned with ensuring that the data reaches its destination reliably. They work together to facilitate web communication effectively.

SarthiQ

Interview Preparation Guide

Software Engineering Intern
Questions & Answers

Document Details

Need Help?

Top Software Engineering Intern Interview Questions

Software Engineering Intern Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

Software Engineering InternQuestions & Answers

Document Details

Need Help?

Top Software Engineering Intern Interview Questions

Software Engineering Intern Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Software Engineering Intern
Questions & Answers