Question 1

How would you reverse a linked list in Python? Provide a sample implementation along with edge case handling.

Accepted Answer

To reverse a linked list, we need to change the direction of the `next` pointers for each node. Here's a sample implementation:

```python
class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

def append(self, value):
        new_node = Node(value)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

def reverse(self):
        prev = None
        current = self.head
        while current:
            next_node = current.next  # Store next node
            current.next = prev  # Reverse the link
            prev = current  # Move prev and current one step forward
            current = next_node
        self.head = prev  # Update head to new first element

def print_list(self):
        current = self.head
        while current:
            print(current.value, end=' -> ')
            current = current.next
        print('None')

# Example usage
ll = LinkedList()
ll.append(1)
ll.append(2)
ll.append(3)
ll.print_list()  # Outputs: 1 -> 2 -> 3 -> None
ll.reverse()
ll.print_list()  # Outputs: 3 -> 2 -> 1 -> None
```
In this implementation, we first append values to the linked list. The `reverse` function iteratively reverses the links until we reach the end of the list. Edge cases such as an empty list are handled since the method will simply do nothing if `self.head` is `None`.

Question 2

Explain SQL Joins with examples and how you would use a GROUP BY clause in a database query.

Accepted Answer

SQL Joins are used to combine rows from two or more tables based on a related column. Here are examples of different types of joins:

1. INNER JOIN: Returns records that have matching values in both tables.
```sql
SELECT 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 no match, NULL values are returned for right table columns.
```sql
SELECT 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 no match, NULL values are returned for left table columns.
```sql
SELECT 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.name, b.order_id
FROM customers a
FULL OUTER JOIN orders b ON a.id = b.customer_id;
```

The `GROUP BY` clause groups rows that have the same values in specified columns into summary rows. It is often used with aggregate functions like COUNT, SUM, AVG, etc. Here’s an example:
```sql
SELECT customer_id, COUNT(order_id) as total_orders
FROM orders
GROUP BY customer_id;
```
This query counts the total number of orders for each customer by grouping the results by `customer_id`.

Question 3

How can you manipulate strings in Java and Python? Provide examples of common operations such as reversing a string and checking for palindromes.

Accepted Answer

String manipulation is a common task in programming. In both Java and Python, there are built-in methods to facilitate this.

### Python Implementation:
```python
def reverse_string(s):
    return s[::-1]  # Using slicing to reverse the string

def is_palindrome(s):
    cleaned = ''.join(c.lower() for c in s if c.isalnum())  # Remove non-alphanumeric
    return cleaned == cleaned[::-1]

# Test cases
print(reverse_string('hello'))  # Output: 'olleh'
print(is_palindrome('A man a plan a canal Panama'))  # Output: True
```
### Java Implementation:
```java
public class StringManipulation {
    public static String reverseString(String s) {
        return new StringBuilder(s).reverse().toString();
    }

public static boolean isPalindrome(String s) {
        String cleaned = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
        return cleaned.equals(new StringBuilder(cleaned).reverse().toString());
    }

public static void main(String[] args) {
        System.out.println(reverseString("hello"));  // Output: 'olleh'
        System.out.println(is_palindrome("A man a plan a canal Panama"));  // Output: true
    }
}
```
These examples demonstrate basic string operations and highlight how to handle common tasks effectively in both languages.

Question 4

Describe the core concepts of React components and props. How would you implement a simple functional component that accepts props?

Accepted Answer

In React, components are the building blocks of the UI. They can be either class-based or functional. Props (short for properties) are a way to pass data from parent to child components. Here’s how to create a simple functional component that accepts props: ```javascript import React from 'react'; const Greeting = (props) => { return

Hello, {props.name}!

; }; const App = () => { return ; }; export default App; ``` In this example, the `Greeting` component takes a `name` prop and displays a greeting message. The `App` component renders `Greeting` and passes the name 'Alice' as a prop. This demonstrates how components are reusable and can accept dynamic data through props, enhancing modularity in applications.

Question 5

Explain the use of SQL subqueries and provide an example of a nested query to find employees who earn more than the average salary in their department.

Accepted Answer

Subqueries in SQL allow you to execute a query within another query. A nested query is a type of subquery that is embedded within the WHERE clause of the main query. Here’s an example:

```sql
SELECT employee_id, name, salary, department_id
FROM employees e
WHERE salary > (
    SELECT AVG(salary)
    FROM employees
    WHERE department_id = e.department_id
);
```
This query selects employees whose salary exceeds the average salary of their respective departments. The inner query calculates the average salary for each department, and the outer query retrieves the employee details. This approach allows for efficient data retrieval based on dynamic conditions.

To handle edge cases, ensure that the employees table is not empty, and that the department_id exists in the subquery. If departments have no employees, the subquery would return NULL and thus no employees would be selected from the outer query.

SarthiQ

Interview Preparation Guide

Goldman Sachs
Questions & Answers

Document Details

Need Help?

Top Goldman Sachs Interview Questions

Goldman Sachs Interview Questions

A Software Engineer was asked

A Backend Developer was asked

Software Engineer

Frontend Developer