Q: How do you implement a GraphQL API for a cloud-native application using Node.js and Express? Include an example schema and resolver.

To implement a GraphQL API for a cloud-native application using Node.js and Express, we can use the `graphql` and `express-graphql` libraries. This approach allows us to define a flexible schema for querying data and implementing resolvers to handle the requests. 1. **Setup**: Install the required libraries. ```bash npm install express express-graphql graphql ``` 2. **Define Schema**: Create a GraphQL schema with types and queries. 3. **Create Resolvers**: Implement resolver functions to retrieve data according to the schema. Here’s a simple example: ```javascript const express = require('express'); const { graphqlHTTP } = require('express-graphql'); const { buildSchema } = require('graphql'); // Define GraphQL schema const schema = buildSchema(` type Query { user(id: ID!): User } type User { id: ID name: String email: String } `); // Sample data const users = [ { id: '1', name: 'John Doe', email: 'john@example.com' }, { id: '2', name: 'Jane Doe', email: 'jane@example.com' } ]; // Define resolvers const root = { user: ({ id }) => users.find(user => user.id === id), }; const app = express(); app.use('/graphql', graphqlHTTP({ schema: schema, rootValue: root, graphiql: true, })); app.listen(4000, () => console.log('GraphQL API running on port 4000')); ``` This code sets up a simple GraphQL API with a `user` query, which returns user details based on the ID provided. The server listens on port 4000, and the GraphiQL interface allows for interactive queries. In a cloud-native environment, you would typically deploy this API as a containerized application using Docker and orchestrate it using Kubernetes.

Question 1

What is a Stack, and how can it be used to check for balanced parentheses in an expression? Provide a code example.

Accepted Answer

A Stack is a linear data structure that follows the Last In First Out (LIFO) principle. To check for balanced parentheses, we can use a stack to keep track of opening parentheses. Whenever we encounter a closing parenthesis, we check if it matches the top of the stack. Here’s a Python implementation:

```python
def is_balanced(expression):
    stack = []
    parentheses = {'(': ')', '{': '}', '[': ']'}
    for char in expression:
        if char in parentheses:
            stack.append(char)
        elif char in parentheses.values():
            if not stack or parentheses[stack.pop()] != char:
                return False
    return not stack

# Example usage:
exp = '{[()]}'
print(is_balanced(exp))  # Output: True
```

Question 2

Explain the difference between BFS and DFS in graph traversal, and how can you find the shortest path using BFS?

Accepted Answer

Breadth-First Search (BFS) explores all neighbors at the present depth prior to moving on to nodes at the next depth level, while Depth-First Search (DFS) explores as far as possible along a branch before backtracking. Here’s a BFS implementation:

```python
from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            visited.add(vertex)
            queue.extend(set(graph[vertex]) - visited)
    return visited
```
To find the shortest path in an unweighted graph using BFS, you can modify the BFS to also track the path:

```python
def shortest_path(graph, start, goal):
    queue = deque([(start, [start])]
    while queue:
        vertex, path = queue.popleft()
        for neighbor in graph[vertex]:
            if neighbor == goal:
                return path + [goal]
            else:
                queue.append((neighbor, path + [neighbor]))
```

Question 3

Explain how to use a Hash Map to count the frequency of characters in a string. Can you also demonstrate with code?

Accepted Answer

A Hash Map (or dictionary in Python) is an efficient way to count the frequency of characters in a string because it allows for average-case O(1) time complexity for insertions and lookups. Here’s how you could implement this in Python:

```python
def character_frequency(s):
    freq_map = {}
    for char in s:
        if char in freq_map:
            freq_map[char] += 1
        else:
            freq_map[char] = 1
    return freq_map

# Example usage:
s = 'anagram'
frequency = character_frequency(s)
print(frequency)  # Output: {'a': 3, 'n': 1, 'g': 1, 'r': 1, 'm': 1}
```

Question 4

How can you solve the 'Two Sum' problem using an array, and what is the sliding window technique in this context?

Accepted Answer

The 'Two Sum' problem requires finding two indices in an array such that their values add up to a specific target. The sliding window technique can be applied to optimize the search in a sorted array. Here is a sample implementation in Python:

```python
def two_sum(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        current_sum = nums[left] + nums[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return []
```
This solution runs in O(n) time complexity, where n is the number of elements in the array, since we only pass through the array once.

Question 5

How do you implement a GraphQL API for a cloud-native application using Node.js and Express? Include an example schema and resolver.

Accepted Answer

To implement a GraphQL API for a cloud-native application using Node.js and Express, we can use the `graphql` and `express-graphql` libraries. This approach allows us to define a flexible schema for querying data and implementing resolvers to handle the requests.

1. **Setup**: Install the required libraries.
   ```bash
   npm install express express-graphql graphql
   ```
2. **Define Schema**: Create a GraphQL schema with types and queries.
3. **Create Resolvers**: Implement resolver functions to retrieve data according to the schema.

Here’s a simple example:

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

// Define GraphQL schema
const schema = buildSchema(`
    type Query {
        user(id: ID!): User
    }
    type User {
        id: ID
        name: String
        email: String
    }
`);

// Sample data
const users = [
    { id: '1', name: 'John Doe', email: 'john@example.com' },
    { id: '2', name: 'Jane Doe', email: 'jane@example.com' }
];

// Define resolvers
const root = {
    user: ({ id }) => users.find(user => user.id === id),
};

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

app.listen(4000, () => console.log('GraphQL API running on port 4000'));
```
This code sets up a simple GraphQL API with a `user` query, which returns user details based on the ID provided. The server listens on port 4000, and the GraphiQL interface allows for interactive queries. In a cloud-native environment, you would typically deploy this API as a containerized application using Docker and orchestrate it using Kubernetes.

SarthiQ

Interview Preparation Guide

Data Structures & Algorithms
Questions & Answers

Document Details

Need Help?

Top Data Structures & Algorithms Interview Questions

Data Structures & Algorithms Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

Data Structures & AlgorithmsQuestions & Answers

Document Details

Need Help?

Top Data Structures & Algorithms Interview Questions

Data Structures & Algorithms Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Data Structures & Algorithms
Questions & Answers