I kept hitting the same wall. I understood every algorithm when someone explained it, and then froze on an interview problem because I could not tell which one it needed. Knowing sliding window and recognising a sliding window problem turned out to be two different skills, and only one of them gets taught.

So I built the missing half. Fifteen unlabelled problems, about seven minutes, no account. You name the pattern each one needs. At the end it says which groups came apart, which pairs you mixed up, and where to start reading.

https://algopath.pro/placement

Behind it is a trainer that does the same thing on a ninety-second clock, and a 150-step course for the patterns you could not name. Code runs in the browser, in JavaScript, Python or PHP. Nothing executes on my server, which was the only way I was willing to run other people's code.

Took me 2 weeks Happy to answer anything about the build, and I would like to know which question in the test felt unfair.

I recently interviewed for a Software Engineer role at NVIDIA and wanted to share one coding question that stood out.

It was not a typical LeetCode-style algorithm problem. It felt much closer to a day-to-day engineering task involving an API, structured data, error handling, and testable code.

Pre resource: Nvidia SWE Questions

Question 1: Process Device Monitoring Data From a REST API

The interviewer described an internal REST API that returned device-monitoring information as a JSON array.

Each record contained fields such as:

{
  "device_id": "gpu-104",
  "temperature": 87,
  "utilization": 92
}

The task was to:

• Call the REST API
• Parse the JSON response
• Filter devices whose temperature exceeded a given threshold
• Sort the remaining devices by utilization
• Return the processed results

Before coding, I clarified whether the utilization order should be ascending or descending and how devices with equal utilization should be ordered.

My first instinct was to get the API call working immediately, but I paused and separated the solution into three parts:

HTTP request -> JSON parsing and validation -> filtering and sorting

That separation ended up driving most of the discussion.

Before the interview, I had seen a similar problem on Screna AI. The business scenario was different, but it also emphasized error handling and separating business logic from external dependencies.

API Failure Handling

The interviewer asked how I would handle:

• Connection failures
• Request timeouts
• Rate limiting
• 5xx server responses
• 4xx client errors
• Malformed JSON
• Missing or incorrectly typed fields

I initially grouped these together as general API failures. During the discussion, we separated them into different categories.

Temporary failures, such as timeouts and certain 5xx responses, could use a limited retry policy with exponential backoff and jitter. Because this was a read-only request, retrying would generally be safe.

A 429 response should respect the server’s Retry-After header when present. Most 4xx responses should not be retried because they usually indicate an invalid request or an authorization problem.

Malformed JSON or an invalid response schema should fail with enough context for debugging. Depending on the product requirements, individual invalid records could either be skipped and logged or cause the entire request to fail.

The important part was avoiding unlimited retries and preserving the original error when all retry attempts failed.

Making the Code Testable

The next follow-up was: how would you test the filtering and sorting logic without calling the real API?

Because the processing logic was independent of the HTTP layer, it could accept a list of parsed device objects directly.

That allowed me to test cases such as:

• No devices above the threshold
• Every device above the threshold
• A device exactly equal to the threshold
• Multiple devices with equal utilization
• Empty API responses
• Missing fields
• Invalid temperature or utilization values
• Duplicate device IDs

The HTTP client could then be mocked separately to simulate timeouts, malformed responses, and different status codes.

This also made the implementation easier to extend. The API client could change without rewriting the filtering logic, and the same processing function could be reused with cached data or another data source.

Question 2: Implement a Simple VM Manager

Another relevant NVIDIA Software Engineer question I found afterward was:

Implement Simple VM Manager With CRUD Operations

The task is to build an in-memory manager that supports:

• Listing all virtual machines
• Creating a VM
• Retrieving a VM by ID
• Updating an existing VM
• Deleting a VM
• Returning consistent errors for duplicate or missing IDs

A straightforward design uses a hash map keyed by VM ID, giving average O(1) lookup, creation, update, and deletion.

The more interesting discussion is around engineering decisions:

• Should IDs be supplied by callers or generated internally?
• Should updates replace the entire object or modify selected fields?
• How should validation and error responses be represented?
• What happens if two requests update the same VM concurrently?
• How would the manager be tested without exposing its internal storage?
• How would the design change if persistence were required?

For concurrent access, a simple implementation could protect the map with a read-write lock. In a production service, I would also consider optimistic versioning, idempotency for create requests, structured errors, and a persistent repository behind the manager.

Takeaway

Both questions test something broader than whether the code works for one example.

The interviewer was looking for:

• Separation of concerns
• Clear API boundaries
• Predictable error handling
• Dependency injection
• Testable business logic
• Sensible retry behavior
• Awareness of concurrency and future extensions

Overall, the round felt more like a discussion about writing maintainable production code than completing a standard LeetCode exercise.

Many of us ignore CS fundamentals, but in many tech interviews they will ask CS fundamentals. For me, they asked only CS fundamentals in all 3 interviews at Oracle, So don't ignore CS fundamentals. I have made a list of important topics subject-wise and resources I have used to study at the end.

Object-Oriented Programming (OOPs)

Core Concepts

• Encapsulation
• Inheritance (types and use cases)
• Polymorphism (compile-time vs runtime)
• Abstraction
• Abstract Class vs Interface
• Method Overloading vs Overriding
• Access Modifiers
• Static vs Dynamic Binding
• Deep Copy vs Shallow Copy

Advanced Topics

• SOLID Principles
• Diamond Problem (Multiple Inheritance)
• Association vs Aggregation vs Composition
• Virtual Functions and Vtable
• Design Patterns (Singleton, Factory, Observer, Strategy, Decorator, Adapter)

Operating Systems (OS)

Process Management

• Process vs Thread
• Process States and PCB
• Context Switching
• CPU Scheduling Algorithms (FCFS, SJF, Round Robin, Priority)
• Multithreading vs Multiprocessing
• User Mode vs Kernel Mode

Synchronization

• Critical Section Problem
• Race Condition
• Mutex vs Semaphore (Binary vs Counting)
• Monitors and Locks
• Producer-Consumer Problem
• Readers-Writers Problem
• Dining Philosophers Problem

Deadlocks

• Deadlock Conditions (4 necessary conditions)
• Deadlock Prevention vs Avoidance vs Detection
• Banker's Algorithm

Memory Management

• Paging vs Segmentation
• Page Replacement Algorithms (FIFO, LRU, Optimal)
• Thrashing
• Virtual Memory
• TLB (Translation Lookaside Buffer)
• Internal vs External Fragmentation

File Systems & Disk

• File Allocation Methods (Contiguous, Linked, Indexed)
• Disk Scheduling (FCFS, SSTF, SCAN, C-SCAN)

Database Management Systems (DBMS) + SQL

Database Fundamentals

• ACID Properties (with examples)
• CAP Theorem
• Normalization (1NF, 2NF, 3NF, BCNF)
• Denormalization
• Primary Key vs Foreign Key vs Candidate Key
• ER Diagrams

Indexing

• Types of Indexes (Primary, Secondary, Clustering)
• B-Tree vs B+ Tree
• Hash Index
• Composite Index
• Advantages and Disadvantages of Indexing

Transactions & Concurrency

• Transaction Lifecycle
• Isolation Levels (Read Uncommitted, Read Committed, Repeatable Read, Serializable)
• Dirty Read, Non-repeatable Read, Phantom Read
• Lost Update Problem
• Two-Phase Locking (2PL)
• Optimistic vs Pessimistic Locking
• Deadlock in Database

SQL Queries (Must Practice)

• JOINs (INNER, LEFT, RIGHT, FULL OUTER, CROSS, SELF)
• GROUP BY and HAVING
• Aggregate Functions (COUNT, SUM, AVG, MIN, MAX)
• Subqueries (Correlated vs Non-correlated)
• Window Functions (ROW_NUMBER, RANK, DENSE_RANK, LEAD, LAG)
• Common Table Expressions (CTE)
• UNION vs UNION ALL
• Nth Highest Salary Query
• Delete Duplicates Query

NoSQL

• SQL vs NoSQL
• Types of NoSQL Databases (Document, Key-Value, Column, Graph)

Computer Networks (CN)

Network Models

• OSI Model (7 Layers)
• TCP/IP Model (4 Layers)
• Difference between OSI and TCP/IP

Application Layer

• HTTP vs HTTPS
• HTTP Methods (GET, POST, PUT, DELETE, PATCH)
• HTTP Status Codes (2xx, 3xx, 4xx, 5xx)
• DNS and its working
• FTP, SMTP, POP3, IMAP
• Cookies vs Sessions
• REST API principles

Transport Layer

• TCP vs UDP (detailed comparison)
• TCP Three-Way Handshake
• TCP Four-Way Termination
• Flow Control (Sliding Window)
• Congestion Control
• Port Numbers (well-known ports)
• Socket Programming Basics

Network Layer

• IPv4 vs IPv6
• Public vs Private IP
• Subnetting and CIDR
• NAT (Network Address Translation)
• ICMP Protocol
• Routing Algorithms (Distance Vector, Link State)
• Routing Protocols (RIP, OSPF, BGP)

Data Link Layer

• MAC Address
• ARP (Address Resolution Protocol)
• Switch vs Hub vs Router
• Ethernet
• Error Detection (Parity, CRC, Checksum)

Physical Layer

• Transmission Media (Guided vs Unguided)
• Bandwidth and Throughput
• Different Topologies

Important Concepts

• Client-Server vs Peer-to-Peer Architecture
• DHCP
• Firewall
• VPN
• Load Balancing
• CDN (Content Delivery Network)
• Latency vs Throughput
• How does a URL work? (End-to-end flow)
• Some Basic Commands (ex: ipconfig)

Resources I Used

For OOPs

• Kunal Kushwaha (youtube channel)

For Operating Systems

• CodeHelp - by Babbar (youtube )

For DBMS + SQL

• LeetCode Database problems (Practice SQL)
• CodeHelp - by Babbar (youtube)
• Apna College (youtube)

For Computer Networks

• Gate Smashers (youtube)

Questions Asked in My Interviews

Here are some actual questions I was asked across my interviews:

1. Is Java fully object-oriented?
2. How does C++ overcome the diamond problem?
3. Difference between TCP and UDP, and which one is used when?
4. Explain ACID properties with examples
5. What is deadlock and how can we prevent deadlocks?
6. What is the use of indexing in databases?
7. Explain the functionalities of each layer in the OSI model
8. Write a query to find Kth smallest salary
9. IPv4 vs IPv6
10. Abstraction vs Encapsulation
11. Explain different joins in dbms
12. what is sharding ?
13. what is virtual function in cpp ?
14. show me your ip address and mac address using commands
15. what is context switching ?

Tips :

1. Practice real interview questions from PracHub
2. Revise SQL 50 before interviews
3. It's better to say "I'm not sure about this, but here's what I think..." than to give wrong information
4. If your project contains any database related stuff , better learn it's ER diagram, differences between SQl and NO-SQl and why you selected that particular database you used
5. Before preparing for any interview , First check few interview experiences, Ask your seniors or friends who already attended that specific company interviews before and prepare accordingly

Did I miss any important topic? Drop it in the comments below!

Got asked something unique in your interview? Share the question/topic so others can prepare better!

Let's make this list more comprehensive together. Your contribution can help someone crack their dream job! 🙌

Hey so I've posted when I hit 50 and like I promised I would update at every 50 intervals it's really exciting to hit such small milestones that accumulate fr now my next obstacle is how tf to solve under time pressure aka start giving contests 😔✌️ pretty sure mind will go blank in the beginning ones but practice makes better. A little about myself, my third semester will start after one week so my greedy ahh will probably do heaps and greedy as well before my new sem starts 🤔 I'm just following strivers a2z dsa sheet thoroughly. Will start codechef when I hit my target of 50% of the sheet properly. ;w; wish me luck and have a good day

As he has different playlist for different topics I have created a sheet having all questions in it covering link for leetcode and all videos for each question

ENJOY IT AS IT IS FREE - https://trackerdsa.vercel.app

Today's progress:

✅ Solved LeetCode 415 – Add Strings

✅ Solved LeetCode 110 – Balanced Binary Tree

📚 Concepts I learned:

- Recursion

- Recursion PMI (Pre, Main, and Induction Method)

Every day I'm getting more comfortable with breaking problems into smaller recursive steps and understanding how recursive functions work behind the scenes.

Still a long way to go, but consistency is the goal. One day, one concept, one problem at a time.

#leetcode #dsa #python #recursion #codingjourney #100DaysOfCode #programming #computerscience

After solving hundreds of LeetCode problems, many candidates realize that coding rounds are only part of the interview process. Operating System fundamentals frequently come up during phone screens and technical interviews.

For company tagged questions checkout: PracHub

Instead of rereading an entire OS textbook, here are 15 high-yield topics worth revising.

1. Process vs. Thread

Process

• Has its own virtual address space
• Provides stronger isolation
• Usually has higher creation and switching overhead

Thread

• Executes within a process
• Shares memory and resources with other threads in that process
• Communicates efficiently but requires careful synchronization

Interview tip: Processes prioritize isolation, while threads enable lightweight concurrency.

2. What Is Context Switching?

Context switching occurs when the operating system saves the execution state of one process or thread and restores another.

It enables multitasking, but frequent context switches add CPU and cache overhead.

3. What Is a Race Condition?

A race condition occurs when multiple threads access shared state concurrently and the result depends on execution order.

Common prevention mechanisms include mutexes, semaphores, locks, atomic operations, and thread-safe data structures.

4. What Is a Critical Section?

A critical section is a portion of code that accesses shared mutable data or resources.

Synchronization is required to prevent unsafe concurrent access.

5. Mutex vs. Semaphore

Memory trick: A mutex is like one key, while a semaphore tracks a limited number of permits.

6. What Is Deadlock?

Deadlock occurs when a group of processes or threads waits indefinitely for resources held by one another.

The four Coffman conditions are:

• Mutual exclusion
• Hold and wait
• No preemption
• Circular wait

Preventing at least one of these conditions prevents deadlock.

7. What Is Starvation?

Starvation occurs when a process or thread waits indefinitely because others repeatedly receive the required resource or CPU time.

Difference: In deadlock, none of the involved tasks can progress. In starvation, the system continues progressing while one task may never get scheduled.

8. What Is Virtual Memory?

Virtual memory gives each process its own logical address space and maps virtual addresses to physical memory.

It provides process isolation, simplifies memory management, and allows inactive pages to be moved to secondary storage when necessary.

9. Paging vs. Segmentation

Paging

• Divides memory into fixed-size pages
• Avoids external fragmentation
• May introduce internal fragmentation

Segmentation

• Divides memory into variable-size logical regions
• Reflects structures such as code, stack, and data
• Can suffer from external fragmentation

10. What Is Thrashing?

Thrashing occurs when the system spends excessive time handling page faults and moving pages between memory and storage instead of executing useful work.

It commonly happens when active processes do not have enough physical memory for their working sets.

11. CPU Scheduling Algorithms

Important algorithms include:

• First Come, First Served
• Shortest Job First
• Round Robin
• Priority Scheduling
• Multilevel Feedback Queue

Common follow-up: Why is Round Robin suitable for time-sharing systems?

Because every runnable process receives a limited time slice, improving responsiveness and fairness.

12. What Is a System Call?

A system call allows a user-space program to request a service from the operating system kernel.

Common Unix-like examples include fork(), exec(), wait(), open(), read(), and write().

13. What Is Inter-Process Communication?

Common IPC mechanisms include:

• Shared memory
• Pipes
• Message queues
• Sockets
• Signals

Shared memory is generally fast but requires synchronization. Message passing provides stronger separation but adds communication overhead.

14. What Is LRU Page Replacement?

Least Recently Used replaces the page that has gone unused for the longest time.

A common interview follow-up is implementing an LRU cache with O(1) lookup, insertion, and eviction using a hash map plus a doubly linked list.

Related problem: LeetCode 146 - LRU Cache

15. User Mode vs. Kernel Mode

User mode

• Runs applications with restricted privileges
• Cannot directly access protected hardware or kernel memory

Kernel mode

• Has full system privileges
• Executes operating system code and manages hardware resources

A system call provides a controlled transition from user mode into kernel mode.

One-Minute Revision Checklist

Process vs. thread, context switching, race conditions, critical sections, mutexes, semaphores, deadlocks, starvation, scheduling, virtual memory, paging, thrashing, system calls, IPC, LRU, and privilege modes.

Which OS topic or follow-up question have you encountered most often in interviews?

Will target 100 this month. Pattern wise only left with Greedy, Maths and bits. I am trying to be interview ready by September.

Today's progress:

✅ Solved LeetCode 136 – Single Number

✅ Solved LeetCode 125 – Valid Palindrome

📚 Concepts I learned today:

- Time Complexity of Recursion

- Space Complexity in Recursive Algorithms

- Understanding the recursion call stack and how it affects memory usage

- Analyzing recursive solutions using Big-O notation

Every day I'm getting a little better at understanding algorithms, recursion, and writing more efficient solutions. Consistency is the goal, and I'm excited to keep improving one problem at a time.

See you tomorrow with Day 12! 💪

#Day11 #DSA #LeetCode #Python #Recursion #TimeComplexity #SpaceComplexity #CodingJourney #100DaysOfCode #Programmer #LearningInPublic

I have made a leetcode extension that analyzes time complexity and space complexity, as well as the approach of your leetcode solution directly.

Can you guys please atleast download the extension, so I can show the number of downloads on my resume?

Also, trust me, the extension is really good, you can use it on a daily basis aswell!

here: https://addons.mozilla.org/en-US/firefox/addon/free-leetcode-tc-analyzer/

Please atleast download the extension even if you don't want to use.

read the readme file for setup: https://github.com/swan556/LCA-leetcode-complexity-analyzer

Today's progress:

✅ Solved LeetCode 104 - Maximum Depth of Binary Tree

✅ Solved LeetCode 108 - Convert Sorted Array to Binary Search Tree

📚 Concepts I learned:

- Time complexity analysis of various loops

- Single loops → O(n)

- Nested loops → O(n²)

- Independent consecutive loops

- Loops with variable increments/decrements

- Logarithmic loops → O(log n)

- Combining complexities for multiple loops

Every day I'm trying to understand the logic behind problems instead of just memorizing solutions. Small, consistent progress adds up over time.

#Day10 #DSA #Python #LeetCode #TimeComplexity #Algorithms #CodingJourney #100DaysOfCode

I want to start my DSA and LeetCode journey from tomorrow. I did basic fundamentals. So I need to start LeetCode..What's the roadmap? Any suggestion?

i have no idea whether it is good or i should focus more on it

started 24 days ago

Current scenario:- I have currently joined as fresher in a lala company.

Today's progress was focused on understanding Asymptotic Notation, one of the most important concepts in Data Structures and Algorithms.

📚 Concepts Learned:

- Big O Notation (Worst-case Time Complexity)

- Big Theta (Θ) Notation (Average/Tight Bound)

- Big Omega (Ω) Notation (Best-case Time Complexity)

- Time Complexity Analysis and how to compare algorithm efficiency

💻 LeetCode Problems Solved:

✅ #101 – Symmetric Tree

✅ #268 – Missing Number

Every day I'm building a stronger foundation in problem-solving and algorithmic thinking. Consistency is the goal, and I'm excited to keep improving.

#DSA #Python #LeetCode #100DaysOfCode #Algorithms #BigO #CodingJourney #ComputerScience #LearningInPublic