Goldman Sachs Interview Preparation and Recruitment Process

In SQL (Structured Query Language), a JOIN clause is used to combine rows from two or more tables based on a related column between them.

Here's a breakdown:

1. Purpose: Relational databases often store data in multiple tables to reduce redundancy and improve organization (a concept called normalization). For example, you might have one table for Customers and another for Orders. A JOIN allows you to retrieve data that spans these tables, such as getting a list of customers along with their corresponding order details, in a single result set.
2. Mechanism: Joins work by comparing values in specified columns (the "join condition"), usually involving a primary key in one table and a foreign key in another. When the values match according to the join condition, the corresponding rows from the tables are combined.
3. Types of Joins: There are several types of joins, each behaving differently regarding which rows are included in the result:
   • INNER JOIN: Returns only the rows where there is a match in both tables based on the join condition. This is the most common type of join.
   • LEFT JOIN (or LEFT OUTER JOIN): Returns all rows from the "left" table (the first table mentioned) and the matched rows from the "right" table (the second table mentioned). If there's no match in the right table for a row in the left table, the result will contain NULL values for the columns from the right table.  
      
   • RIGHT JOIN (or RIGHT OUTER JOIN): Returns all rows from the "right" table and the matched rows from the "left" table. If there's no match in the left table for a row in the right table, the result will contain NULL values for the columns from the left table.  
      

      
   • FULL JOIN (or FULL OUTER JOIN): Returns all rows when there is a match in either the left or the right table. It essentially combines the results of a LEFT JOIN and a RIGHT JOIN. If there's no match for a row from one table in the other, the result will contain NULL values for the columns from the table without the match.  
      
   • CROSS JOIN: Returns the Cartesian product of the two tables, meaning it combines every row from the first table with every row from the second table. It doesn't typically use an ON condition.  
      
   • SELF JOIN: This isn't a different type of join keyword, but rather a technique where a table is joined with itself using table aliases. This is useful for comparing rows within the same table (e.g., finding employees who report to the same manager).

In essence, SQL JOINs are fundamental tools for querying relational databases effectively by linking related information stored across different tables.

Okay, let's break down processes and threads in the context of an Operating System (OS). Both are fundamental concepts for understanding how software executes and how operating systems manage multitasking and concurrency.

Process

1. Definition: A process is essentially an instance of a program that is currently running. When you launch an application (like a web browser, a word processor, or even a command-line tool), the OS creates a process for it.
2. What it Contains: A process is a heavyweight structure that includes:
   • Code/Text Segment: The actual program instructions.
   • Data Segment: Global and static variables.
   • Heap: Dynamically allocated memory used by the program during runtime (e.g., when using new or malloc).
   • Stack: Used for local variables, function parameters, and return addresses for function calls.
   • Process Control Block (PCB): A data structure maintained by the OS containing information about the process, such as:
     • Process ID (PID)
     • Process state (running, waiting, ready, terminated)
     • Program Counter (indicates the next instruction to execute)
     • CPU registers
     • Memory management information (pointers to code, data, stack, heap)
     • Accounting information (CPU time used, etc.)
     • I/O status information (files opened, devices allocated)
3. Key Characteristics:
   • Isolation: Processes are typically isolated from each other. Each process has its own private virtual address space. One process cannot directly access the memory of another process (unless explicitly set up using Inter-Process Communication mechanisms). This isolation provides protection – a crash in one process usually doesn't affect others.
   • Resource Ownership: Processes are the primary unit of resource allocation. The OS allocates memory, file handles, network sockets, etc., to processes.
   • Creation Overhead: Creating a new process is relatively expensive (time-consuming and resource-intensive) because the OS needs to set up the entire isolated environment (address space, PCB, etc.).
   • Communication: Communication between different processes (Inter-Process Communication or IPC) requires specific mechanisms provided by the OS, such as pipes, sockets, shared memory, or message queues.

Thread

1. Definition: A thread is the smallest unit of execution within a process. It's often called a "lightweight process." A single process can contain multiple threads, all executing concurrently (or pseudo-concurrently on a single-core CPU).
2. What it Contains (Own vs. Shared):
   • Shared within the Process: All threads within the same process share:
     • Code Segment
     • Data Segment
     • Heap
     • OS resources like open files and network connections.
   • Individual per Thread: Each thread has its own:
     • Thread ID (TID)
     • Program Counter
     • Register set
     • Stack (each thread needs its own stack for its function calls and local variables).
3. Key Characteristics:
   • Shared Resources: Because threads within a process share memory (code, data, heap), they can communicate and share data directly by reading and writing to the same memory locations. This makes communication much faster than IPC between processes.
   • Concurrency within a Process: Threads allow different parts of the same program to run concurrently. For example, in a word processor, one thread might handle user input, another might perform spell-checking in the background, and a third might handle auto-saving.
   • Creation Overhead: Creating a thread is much cheaper ("lighter weight") than creating a process because fewer new resources need to be allocated – much of the environment (address space, open files) is simply shared.
   • Synchronization: Because threads share resources (especially memory), developers must use synchronization mechanisms (like mutexes, semaphores, condition variables) to prevent race conditions and ensure data consistency when multiple threads access shared data concurrently.
   • Impact of Errors: An error or crash in one thread can potentially affect all other threads within the same process because they share the same memory space.

Analogy:

Think of a Process as a restaurant kitchen:

• It has its own space, address, equipment (resources), and recipes (code).
• It's isolated from other kitchens (other processes).

Think of Threads as chefs working within that kitchen:

• All chefs (threads) share the same kitchen space, equipment, and ingredients (shared resources like code, data, heap).
• Each chef can work on a different dish or part of a dish concurrently (multiple execution paths).
• Each chef has their own personal notes/current step in the recipe (program counter), their specific tools they are holding (registers), and their personal workspace/cutting board (stack).
• Chefs can easily coordinate by talking or looking at shared order slips (shared memory), but they need rules (synchronization) to avoid bumping into each other or messing up each other's work.

Summary Table:

#include<bits/stdc++.h>
using namespace std;
//function to calculate the maximum profit attainable
int maximiseProfit(int prices[], int size)
{
    int maximumProfit = 0; // stores the maximum profit
    for(int i = 1; i < size; i ++)
    {
        if(prices[i] - prices[i - 1] > 0)
            maximumProfit += prices[i] - prices[i - 1];
    }
    return maximiseProfit;
}
int main()
{
    int prices[] = { 100, 180, 260, 310, 40, 535, 695 };
    int size = sizeof(prices) / sizeof(prices[0]);
    cout << maximiseProfit(prices, size) << endl;
    return 0;
}​

Let's break down BFS (Breadth-First Search) and DFS (Depth-First Search) — two fundamental graph traversal algorithms — with key comparisons, how they work, and when to use each.

1. Overview

2. How They Work

BFS (Breadth-First Search)

• Start at the root (or any node)

• Explore all neighbors first, then their neighbors' neighbors

• Ideal for shortest path in unweighted graphs

Steps:

1. Enqueue start node

2. While queue isn’t empty:

   • Dequeue node

   • Visit and enqueue all unvisited neighbors

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])

    while queue:
        node = queue.popleft()
        if node not in visited:
            print(node)
            visited.add(node)
            queue.extend(graph[node] - visited)

DFS (Depth-First Search)

• Start at the root and go as deep as possible before backtracking

• Ideal for pathfinding, detecting cycles, topological sorting, etc.

Steps:

1. Start at node

2. Visit an unvisited neighbor, repeat

3. Backtrack when no unvisited neighbors

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start)
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

Example Graph

Imagine this undirected graph:

   A
  / \
 B   C
 |   |
 D   E

• BFS from A → A B C D E (level by level)

• DFS from A → A B D C E (deep before wide — order may vary depending on implementation)

 int x = 6;
// some code
int *ptr = &x;​

int x = 6;
int &ref = x;​

int x = 6;
int *ptr;
ptr = &x;
int y = 7;
ptr = &y;​

The JVM is the cornerstone of Java's platform independence ("write once, run anywhere") and acts as an abstract machine that executes Java bytecode.

Here's a look at its key internal components:

1. Class Loader Subsystem

This component is responsible for dynamically loading Java classes (.class files) into the JVM memory as they are needed by the application during runtime. It performs three main functions:

• Loading: Finds and imports the binary data (bytecode) for classes and interfaces. This involves locating the .class file (e.g., from the classpath) and creating a corresponding Class object representation inside the JVM. This is typically done by a hierarchy of class loaders:
  • Bootstrap Class Loader: Loads core Java libraries (like java.lang.*) from the <JAVA_HOME>/jre/lib directory. It's implemented in native code.
  • Extension Class Loader: Loads classes from the extensions directory (<JAVA_HOME>/jre/lib/ext).
  • Application/System Class Loader: Loads classes from the application's classpath (specified by -cp or the CLASSPATH environment variable).
  • These loaders follow a delegation hierarchy – requests are passed up the chain, and a loader only tries to load a class if its parent cannot find it.
• Linking: This involves integrating the loaded class/interface into the runtime state of the JVM. It consists of three steps:
  • Verification: The bytecode verifier checks if the loaded .class file is structurally correct, safe, and adheres to JVM specifications. This prevents malicious code from corrupting the JVM.
  • Preparation: Allocates memory for class static variables and initializes them with default values (e.g., 0 for integers, null for objects).
  • Resolution: Replaces symbolic references (like class names or method names) in the bytecode with direct references (actual memory addresses or offsets). This can happen eagerly or lazily (when a reference is first used).
• Initialization: This is the final phase where the class's static initializers (code within static {} blocks) are executed, and static variables are assigned their actual initial values as specified in the code. This phase is triggered only when a class is actively used for the first time (e.g., an instance is created, a static method is called, or a static field is accessed).

2. Runtime Data Areas (Memory Areas)

These are the memory regions allocated and managed by the JVM during program execution. They are crucial for storing data needed while the application runs.

• Method Area (Shared across all threads):
  • Stores per-class information, such as:
    • Runtime constant pool (metadata, symbolic references used by the code)
    • Field and method data (names, types, modifiers)
    • Code for methods and constructors (bytecode)
  • In older JVMs (before Java 8), this was often part of the "Permanent Generation" (PermGen). In newer JVMs, it's often implemented as "Metaspace" in native memory.
• Heap Area (Shared across all threads):
  • This is the main memory area where all class instances (objects) and arrays are allocated at runtime.
  • Memory management for the heap is handled automatically by the Garbage Collector (GC).
• JVM Stack (Per thread):
  • Each thread executing in the JVM has its own private JVM Stack.
  • It stores frames. A new frame is created for each method invocation and destroyed when the method completes.
  • Each frame contains:
    • Local Variables: Stores local variables and parameters of the method.
    • Operand Stack: A workspace for the method to perform intermediate calculations (like a calculator's temporary registers). Bytecode instructions push and pop values from here.
    • Frame Data: Includes a reference to the runtime constant pool for the current method's class, supporting dynamic linking.
• PC Registers (Program Counter Registers) (Per thread):
  • Each thread has its own PC register.
  • It holds the address of the JVM instruction currently being executed by that thread. If the thread is executing a native method, the PC register's value is undefined.
• Native Method Stack (Per thread):
  • Used to support methods written in languages other than Java (e.g., C/C++), known as native methods.
  • If a thread invokes a native method, it uses a native method stack (often a typical C stack) instead of the JVM stack frame for that call.

3. Execution Engine

This is the core component responsible for executing the bytecode loaded by the Class Loader and stored in the Runtime Data Areas.

• Interpreter: Reads bytecode instructions one by one, interprets their meaning, and executes them sequentially. This is straightforward but relatively slow.
• Just-In-Time (JIT) Compiler: To improve performance, the JVM identifies frequently executed sections of bytecode ("hotspots"). The JIT compiler compiles these hotspots into native machine code specific to the underlying hardware and OS at runtime. This compiled native code executes much faster than interpreted bytecode. Modern JVMs use sophisticated JIT compilers with multiple tiers of optimization (e.g., C1 and C2 compilers in HotSpot).
• Garbage Collector (GC): Part of the execution engine (or closely collaborating with it), the GC automatically manages memory in the Heap Area. It identifies objects that are no longer referenced by the running application and reclaims their memory, making it available for new object allocations. There are various GC algorithms (e.g., Serial, Parallel, G1, ZGC, Shenandoah), each with different performance characteristics.

4. Native Method Interface (JNI)

• This is an interface (a set of functions and conventions) that allows Java code running inside the JVM to interact with applications and libraries written in other languages, such as C, C++, or assembly (native code).
• It enables calling native methods from Java and allows native code to call Java methods or access JVM features.

5. Native Method Libraries

• These are libraries of native code (typically written in C/C++) that are accessible to the Java application via the JNI. They are often used to perform platform-specific operations, interact directly with hardware, or leverage existing non-Java codebases.

In Java, both StringBuffer and StringBuilder are used to create mutable (modifiable) sequences of characters — unlike String, which is immutable.

Here’s a breakdown of the differences between StringBuffer and StringBuilder:

StringBuffer vs StringBuilder

Code Example

// StringBuffer example
StringBuffer sbf = new StringBuffer("Hello");
sbf.append(" World");
System.out.println(sbf);  // Output: Hello World

// StringBuilder example
StringBuilder sbl = new StringBuilder("Hello");
sbl.append(" Java");
System.out.println(sbl);  // Output: Hello Java

Note:

• Use **StringBuffer** when multiple threads might access and modify the string concurrently.

• Use **StringBuilder** for better performance in single-threaded scenarios.

Multithreading is one of Java's core strengths — let’s break it down clearly:

What is Multithreading in Java?

Multithreading is a Java feature that allows concurrent execution of two or more parts (threads) of a program to improve performance, especially on multi-core processors.

Think of a thread as a lightweight subprocess — it's the smallest unit of execution in Java.

Goal: Improve application responsiveness and resource utilization by doing multiple tasks simultaneously.

How Are Threads Formed in Java?

There are two main ways to create threads in Java:

1. Extending the Thread class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running via Thread class");
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();  // Start the thread
    }
}

• You override the run() method.

• Call start() to begin execution (internally calls run() on a new thread).

2. Implementing the Runnable interface

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread running via Runnable");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();  // Start the thread
    }
}

• Preferred way — allows you to extend another class (Java supports single inheritance).

Thread Lifecycle in Java

1. New: Thread is created but not started.

2. Runnable: After calling start(), it's ready to run.

3. Running: The thread scheduler picks it up.

4. Blocked/Waiting: Waiting for resources or signal.

5. Terminated: Thread has finished execution.

Why Use Multithreading?

• Faster execution on multi-core systems

• Better CPU utilization

• Useful for:

  • Parallel processing

  • Background tasks (e.g., file downloads, UI updates)

  • Game engines, real-time applications.