// Process vs Thread — Key Differences

// PROCESS:
// - Independent program in execution
// - Has its OWN memory space (code, data, heap, stack)
// - Processes do NOT share memory with each other
// - Communication between processes requires IPC
//   (Inter-Process Communication: pipes, sockets, shared memory)
// - Creating a process is expensive (memory allocation)
// - Example: Opening Chrome and Word — two separate processes

// THREAD:
// - A unit of execution WITHIN a process
// - Shares memory (code, data, heap) with other threads
//   in the same process
// - Each thread has its OWN stack and registers
// - Communication between threads is fast (shared memory)
// - Creating a thread is cheap (no new memory allocation)
// - Example: Chrome tabs — each tab is a thread within Chrome

// Why this matters:
// Multithreading is faster than multiprocessing because
// threads share memory — no need to copy data between them.
// But shared memory means threads can corrupt each other's data
// if not synchronized properly (race conditions).

// Real-world analogy:
// Process = separate offices in a building (own space, own resources)
// Thread = employees in the same office (share desk, printer, files)

// Deadlock: Two or more processes are waiting for each other
// to release resources, and none of them can proceed.

// Real-world example:
// Two cars meet on a narrow bridge from opposite sides.
// Neither can move forward. Neither will reverse.
// Both are stuck forever — that is deadlock.

// The 4 Necessary Conditions (ALL must hold simultaneously):

// 1. MUTUAL EXCLUSION
//    A resource can be held by only one process at a time.
//    Example: Only one process can use the printer at a time.

// 2. HOLD AND WAIT
//    A process holding a resource is waiting for another resource.
//    Example: Process A holds the printer, waits for the scanner.

// 3. NO PREEMPTION
//    A resource cannot be forcibly taken from a process.
//    The process must release it voluntarily.

// 4. CIRCULAR WAIT
//    Process A waits for B, B waits for C, C waits for A.
//    A circular chain of waiting processes.

// Prevention: Remove ANY ONE condition to prevent deadlock.
// Most practical approach: Prevent circular wait by ordering
// resources and requiring processes to request them in order.

// Interview tip: Draw the circular wait diagram on paper
// if the interviewer gives you a whiteboard. Visual explanation
// is much more convincing than verbal.

// Virtual Memory: A memory management technique that gives
// each process the illusion of having a large, contiguous
// block of memory — even if physical RAM is limited.

// The Problem:
// Your laptop has 8 GB RAM. You open Chrome (2 GB),
// VS Code (1 GB), Spotify (500 MB), and a game (4 GB).
// Total: 7.5 GB — almost full. Without virtual memory,
// opening one more app would crash the system.

// The Solution:
// The OS uses a portion of the hard disk as "extended memory."
// Pages (fixed-size blocks) of memory that are not actively
// used are moved from RAM to disk (this is called "swapping"
// or "paging out"). When needed again, they are loaded back.

// How it works:
// 1. Each process gets a virtual address space
// 2. The OS maps virtual addresses to physical RAM addresses
//    using a Page Table
// 3. If a page is not in RAM (page fault), the OS loads it
//    from disk into RAM
// 4. If RAM is full, the OS evicts a less-used page to disk
//    (using algorithms like LRU — Least Recently Used)

// Why it matters:
// - Programs can be larger than physical RAM
// - Multiple programs can run simultaneously
// - Each process is isolated (cannot access another's memory)
// - Memory allocation is simplified for programmers

// RAM (Random Access Memory):
// - Volatile: Data is lost when power is turned off
// - Read AND write: CPU can read from and write to RAM
// - Fast: Used for currently running programs and data
// - Temporary storage: Holds the OS, open applications, data
// - Sizes: 4 GB, 8 GB, 16 GB in modern computers
// - Types: DRAM (main memory), SRAM (cache — faster, expensive)

// ROM (Read Only Memory):
// - Non-volatile: Data persists even without power
// - Read only: Data is written once during manufacturing
//   (modern variants like EEPROM can be rewritten)
// - Slower than RAM but permanent
// - Stores firmware: BIOS/UEFI that boots the computer
// - Small size: Usually a few MB
// - Types: PROM, EPROM, EEPROM, Flash ROM

// Key Difference Summary:
// RAM  → Volatile, Read/Write, Fast, Temporary, Large
// ROM  → Non-volatile, Read-only, Slower, Permanent, Small

// Real-world analogy:
// RAM = your desk (workspace for current tasks, cleared daily)
// ROM = instruction manual (permanent, rarely changes)

// Interview tip: Keep this answer under 60 seconds.
// It is a warm-up question — answer clearly and move on.

// TCP (Transmission Control Protocol):
// - Connection-oriented: Establishes connection before sending data
//   (3-way handshake: SYN → SYN-ACK → ACK)
// - Reliable: Guarantees delivery, order, and error checking
// - Slower: Overhead from acknowledgments and retransmissions
// - Use cases: Web browsing (HTTP/HTTPS), email (SMTP),
//   file transfer (FTP), banking transactions

// UDP (User Datagram Protocol):
// - Connectionless: Sends data without establishing connection
// - Unreliable: No guarantee of delivery or order
// - Faster: No overhead from acknowledgments
// - Use cases: Video streaming (YouTube, Netflix),
//   online gaming (PUBG, Valorant), DNS lookups, VoIP calls

// Why the trade-off matters:
// When you watch a cricket match on Hotstar, a few dropped
// frames are acceptable — you do not want buffering.
// UDP is perfect here: fast, some loss is okay.
//
// When you transfer money on Google Pay, every byte must
// arrive correctly. TCP guarantees this with acknowledgments.

// Key Differences:
// TCP  → Reliable, Ordered, Slower, Connection-oriented
// UDP  → Unreliable, Unordered, Faster, Connectionless

// Interview tip: Always give real-world examples.
// "YouTube uses UDP, Google Pay uses TCP" is more
// convincing than reciting protocol specifications.

// Normalization: Process of organizing data to reduce
// redundancy and dependency.

// UNNORMALIZED TABLE (Student-Course):
// | StudentID | Name   | Courses          | Instructor     |
// |-----------|--------|------------------|----------------|
// | 101       | Rahul  | DBMS, OS         | Prof A, Prof B |
// | 102       | Priya  | DBMS, Networks   | Prof A, Prof C |
// Problem: Multiple values in one cell (Courses, Instructor)

// 1NF (First Normal Form):
// Rule: Each cell must contain a single atomic value.
// | StudentID | Name   | Course   | Instructor |
// |-----------|--------|----------|------------|
// | 101       | Rahul  | DBMS     | Prof A     |
// | 101       | Rahul  | OS       | Prof B     |
// | 102       | Priya  | DBMS     | Prof A     |
// | 102       | Priya  | Networks | Prof C     |
// Problem: Name repeats for each course (partial dependency)

// 2NF (Second Normal Form):
// Rule: Must be in 1NF + no partial dependency
// (non-key columns depend on the ENTIRE primary key)
// Split into two tables:
//
// Students: | StudentID | Name  |
//           | 101       | Rahul |
//           | 102       | Priya |
//
// Enrollments: | StudentID | Course   | Instructor |
//              | 101       | DBMS     | Prof A     |
//              | 101       | OS       | Prof B     |
//              | 102       | DBMS     | Prof A     |
//              | 102       | Networks | Prof C     |
// Problem: Instructor depends on Course, not on StudentID

// 3NF (Third Normal Form):
// Rule: Must be in 2NF + no transitive dependency
// (non-key columns depend ONLY on the primary key)
// Split Enrollments further:
//
// Enrollments: | StudentID | Course   |
//              | 101       | DBMS     |
//              | 101       | OS       |
//              | 102       | DBMS     |
//              | 102       | Networks |
//
// Courses: | Course   | Instructor |
//          | DBMS     | Prof A     |
//          | OS       | Prof B     |
//          | Networks | Prof C     |
// Now each non-key column depends only on the primary key.

// SQL (Relational Databases):
// - Structured: Data stored in tables with rows and columns
// - Schema: Fixed schema — must define structure before inserting
// - ACID compliant: Atomicity, Consistency, Isolation, Durability
// - Relationships: Tables linked via foreign keys (JOINs)
// - Examples: MySQL, PostgreSQL, Oracle, SQL Server
// - Use when: Data is structured, relationships matter,
//   transactions are critical (banking, e-commerce orders)

// NoSQL (Non-Relational Databases):
// - Flexible: Data stored as documents, key-value, graphs, columns
// - Schema-less: No fixed structure — fields can vary per record
// - BASE model: Basically Available, Soft state, Eventually consistent
// - No JOINs: Data is denormalized (duplicated for speed)
// - Examples: MongoDB (documents), Redis (key-value),
//   Cassandra (column), Neo4j (graph)
// - Use when: Data is unstructured, scale is massive,
//   speed matters more than consistency (social media feeds)

// Real-world examples:
// Flipkart order system → SQL (transactions must be ACID)
// Instagram feed → NoSQL (millions of posts, speed matters)
// Aadhaar database → SQL (structured citizen data)
// Chat messages on WhatsApp → NoSQL (flexible, high volume)

// Interview tip: Do not say one is "better" than the other.
// Say "it depends on the use case" and give examples.

-- Table: Employees (id, name, salary)

-- Approach 1: Subquery (most common answer)
SELECT MAX(salary) AS second_highest
FROM Employees
WHERE salary < (SELECT MAX(salary) FROM Employees);
-- Finds the max salary that is less than the overall max

-- Approach 2: LIMIT with OFFSET (MySQL)
SELECT DISTINCT salary
FROM Employees
ORDER BY salary DESC
LIMIT 1 OFFSET 1;
-- Sorts descending, skips 1st row, takes the next one
-- DISTINCT handles duplicate salaries

-- Approach 3: DENSE_RANK (best answer — works for Nth highest)
SELECT salary FROM (
  SELECT salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS rank
  FROM Employees
) ranked
WHERE rank = 2;
-- DENSE_RANK assigns ranks without gaps
-- Change rank = 2 to rank = N for Nth highest salary
-- This approach handles duplicates correctly

-- Why DENSE_RANK over RANK or ROW_NUMBER?
-- RANK: Skips ranks for ties (1, 1, 3 — no rank 2)
-- ROW_NUMBER: No ties (1, 2, 3 — arbitrary for same salary)
-- DENSE_RANK: No gaps (1, 1, 2 — correct for "second highest")

-- Interview tip: Start with the subquery approach (simple),
-- then mention DENSE_RANK to show you know window functions.
-- This impresses interviewers at both service and product companies.

// STACK — Last In, First Out (LIFO)
// The last element added is the first one removed.
//
// Real-world analogy: A stack of plates in a canteen.
// You add plates on top, and you take plates from the top.
// The plate you placed last is the first one you pick up.
//
// Operations:
//   push(element)  → Add to top       → O(1)
//   pop()          → Remove from top   → O(1)
//   peek()/top()   → View top element  → O(1)
//
// Use cases:
//   - Undo/Redo in text editors
//   - Browser back button (history stack)
//   - Function call stack in programming
//   - Expression evaluation (postfix, infix)

// QUEUE — First In, First Out (FIFO)
// The first element added is the first one removed.
//
// Real-world analogy: A queue at an IRCTC ticket counter.
// The person who arrives first gets served first.
//
// Operations:
//   enqueue(element) → Add to rear     → O(1)
//   dequeue()        → Remove from front → O(1)
//   front()/peek()   → View front element → O(1)
//
// Use cases:
//   - Print job scheduling (first document prints first)
//   - CPU task scheduling (round-robin)
//   - BFS (Breadth-First Search) in graphs
//   - Message queues in distributed systems

// JAVA — Palindrome Check
public class Palindrome {
    public static boolean isPalindrome(String str) {
        str = str.toLowerCase();
        int left = 0;
        int right = str.length() - 1;

        while (left < right) {
            if (str.charAt(left) != str.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println(isPalindrome("madam"));   // true
        System.out.println(isPalindrome("hello"));   // false
        System.out.println(isPalindrome("Racecar")); // true
    }
}

# PYTHON — Palindrome Check
def is_palindrome(s):
    s = s.lower()
    return s == s[::-1]

# Alternative: Two-pointer approach (same logic as Java)
def is_palindrome_two_pointer(s):
    s = s.lower()
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

print(is_palindrome("madam"))    # True
print(is_palindrome("hello"))    # False
print(is_palindrome("Racecar")) # True

// Interview tip: Use the two-pointer approach in Java.
// In Python, mention s == s[::-1] but also explain the
// two-pointer logic — it shows you understand the algorithm,
// not just Python shortcuts.

// ARRAY:
// - Contiguous memory allocation (elements stored side by side)
// - Fixed size (in most languages — must declare size upfront)
// - Fast access: O(1) — direct index access (arr[5])
// - Slow insertion/deletion: O(n) — must shift elements
// - Memory efficient: No extra pointers needed

// LINKED LIST:
// - Non-contiguous memory (elements scattered, connected by pointers)
// - Dynamic size (grows and shrinks as needed)
// - Slow access: O(n) — must traverse from head to find element
// - Fast insertion/deletion: O(1) — just update pointers
// - Extra memory: Each node stores data + pointer(s)

// Time Complexity Comparison:
// Operation        | Array  | Linked List
// Access by index  | O(1)   | O(n)
// Search           | O(n)   | O(n)
// Insert at start  | O(n)   | O(1)
// Insert at end    | O(1)*  | O(1)**
// Delete at start  | O(n)   | O(1)
// Delete at end    | O(1)*  | O(n)***
//
// *  If array has space; O(n) if resizing needed
// ** If tail pointer maintained
// *** O(1) if doubly linked list

// When to use what:
// Array → Frequent access by index, known size
//         Example: Storing marks of 60 students
// Linked List → Frequent insertions/deletions, unknown size
//         Example: Implementing a music playlist

// Recursion: A function that calls itself to solve
// a smaller version of the same problem.

// Two essential parts:
// 1. BASE CASE — when to stop (prevents infinite recursion)
// 2. RECURSIVE CASE — the function calls itself with a
//    smaller input, moving toward the base case

// JAVA — Factorial using recursion
public class Factorial {
    public static int factorial(int n) {
        // Base case: factorial of 0 or 1 is 1
        if (n <= 1) {
            return 1;
        }
        // Recursive case: n * factorial(n-1)
        return n * factorial(n - 1);
    }

    public static void main(String[] args) {
        System.out.println(factorial(5)); // 120
        // How it works:
        // factorial(5) = 5 * factorial(4)
        // factorial(4) = 4 * factorial(3)
        // factorial(3) = 3 * factorial(2)
        // factorial(2) = 2 * factorial(1)
        // factorial(1) = 1 (base case — stops here)
        // Unwinds: 2*1=2, 3*2=6, 4*6=24, 5*24=120
    }
}

# PYTHON — Factorial using recursion
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

// What happens without a base case?
// The function calls itself forever → stack overflow error.
// Each function call uses stack memory. Without a base case,
// the stack fills up and the program crashes.
// Java: StackOverflowError
// Python: RecursionError (default limit: 1000 calls)

// How to customize your answer for each company:

// FOR TCS:
// Research: TCS is the largest IT services company in India.
// Mention: Their training program (ILP — Initial Learning Program),
// global delivery model, work across industries.
// Sample: "TCS's Initial Learning Program is one of the most
// structured fresher training programs in the industry. I want
// to start my career where I can learn multiple technologies
// and work on projects across domains like banking and retail."

// FOR INFOSYS:
// Research: Known for InfyTQ platform, Mysore training campus.
// Mention: Their focus on digital transformation, Infosys BPM.
// Sample: "Infosys's Mysore training campus and the emphasis
// on continuous learning through platforms like Lex attracted me.
// I want to work on digital transformation projects where I can
// apply my CS fundamentals to real business problems."

// FOR WIPRO:
// Research: Strong in cybersecurity, cloud services.
// Mention: Their WILP program, sustainability initiatives.
// Sample: "Wipro's focus on cybersecurity and cloud services
// aligns with my interest in networking and security. The WILP
// program also gives me an opportunity to continue learning
// while working on live projects."

// COMMON MISTAKES:
// "I want to join because it is a big company" — too generic
// "I need a job" — honest but wrong answer
// "My friend works here" — irrelevant
// Always mention something SPECIFIC to that company.

// THE CORRECT ANSWER: Always say YES.

// For service companies (TCS, Infosys, Wipro, HCL, Cognizant):
// "Yes, I am completely open to relocation. I understand that
// project requirements may need me to work from different
// locations, and I see it as an opportunity to experience
// different cities and grow professionally."

// WHY this matters:
// Service companies assign freshers to projects based on
// client requirements. A project in Hyderabad needs 50 Java
// developers — they pull from the fresher pool. If you said
// "I only want Bangalore," you have eliminated yourself from
// most project allocations.

// WHAT ACTUALLY HAPPENS:
// - TCS: Posts freshers to any of 20+ offices across India
// - Infosys: Training in Mysore, then posted anywhere
// - Wipro: Training in various locations, posted based on project
// - Most freshers get posted to Hyderabad, Bangalore, Chennai,
//   or Pune — the major IT hubs

// CAN YOU NEGOTIATE LATER?
// Yes. Once you have 1-2 years of experience and are on a
// project, internal transfers are possible. But at the fresher
// stage, saying "no" to relocation means "no" to the job.

// The only exception: If you have a genuine medical reason
// for a specific location, mention it politely after getting
// the offer — not during the interview.

// FRESHER SALARY RANGES IN INDIAN IT:

// Service Companies (campus placement):
// TCS Digital    → ₹7-7.5 LPA (for top performers in NQT)
// TCS Ninja      → ₹3.36 LPA (standard package)
// Infosys SP     → ₹5-6.5 LPA (Systems Engineer Specialist)
// Infosys SE     → ₹3.6 LPA (Systems Engineer)
// Wipro          → ₹3.5-6.5 LPA (varies by role)
// HCL            → ₹3.5-4.25 LPA
// Cognizant GenC → ₹4-4.5 LPA
// Tech Mahindra  → ₹3.25-3.75 LPA

// Product Companies (off-campus/referral):
// Entry-level    → ₹6-12 LPA
// Good startups  → ₹8-15 LPA
// Top product    → ₹15-25+ LPA (rare for freshers)

// HOW TO ANSWER:
// For service companies (fixed package):
// "I am aware that the CTC for this role is [amount] as
// mentioned in the job description. I am comfortable with
// that and my focus is on learning and growing in the role."

// For product companies (negotiable):
// "Based on my research and the skills I bring, I am looking
// at a CTC in the range of ₹X-Y LPA. However, I am open to
// discussion based on the role and growth opportunities."

// MISTAKES TO AVOID:
// "I want ₹10 LPA" at a service company → unrealistic
// "Whatever you offer" → shows no research
// "I need at least ₹X because of EMI" → personal reasons
//   are irrelevant to the interviewer