Skip to content

Interview Prep Buddy

Algorithm Visualizers

Visualizers Hub Two Pointers Visualizer Sliding Window Visualizer Backtracking Visualizer Sorting Visualizer Searching Visualizer Arrays Visualizer Linked List Visualizer Stack & Queue Hash Tables Trees Visualizer Trie (Prefix Tree)Graphs Visualizer Heaps Visualizer Dynamic Programming

Practice Labs

HTML Labs CSS Labs JS Interview Lab React Practice Lab DSA Problem Lab DSA Patterns Guide SQL Query Lab Python Labs MongoDB Lab Git & GitHub Labs Tailwind CSS Playground

System Architecture

System Design Hub (HLD)Low-Level Design Hub (LLD)Object-Oriented Design (OOD)Design URL Shortener (TinyURL)Design Ride-Sharing (Uber)Design Chat App (WhatsApp)

Interview Questions

Interview Preparation

3,100+ Tech Interview Questions AI, LLM & RAG Interview Prep Tricky JavaScript Outputs Behavioural Questions

Study & Prep Roadmaps

Roadmaps Overview Blind 75 Guided Plan 30-Day DSA Bootcamp Frontend Interview (21 Days)Striver's Blind 75 JavaScript Mastery Plan SQL in 7 Days Last-Minute Revision Amazon Interview Plan Google Interview Plan

Company Interview Prep

Companies Overview Google Amazon Meta Microsoft Apple Netflix Uber Flipkart Swiggy

Share Feedback

Help us improve this platform

Your Message *

How's your experience?

⭐⭐⭐⭐⭐

Email (optional — for reply)

Interview Prep Buddy

1,400+ interview questions & docs

All Topics Home Overview Playground JS Interview Lab MCQ Hub MCQ Dashboard Interview Questions AI Engineering Object-Oriented Programming (OOP) Computer Networks Git & GitHub HTML & CSS Tailwind CSS Namaste JavaScript JavaScript React Academy Next.js Angular SQL / MySQL MongoDB Redis Data Structures Striver Blind 75 Solutions Node.js GraphQL Python TypeScript Cloud & AWS Docker Design Patterns & SOLID System Design High-Level Design (HLD) Low-Level Design (LLD) Interview Prep Behavioral Interview Prep

Home
Overview
Playground
JS Interview Lab
MCQ Hub
MCQ Dashboard
Interview Questions
AI Engineering
Object-Oriented Programming (OOP)
- Overview
- 01. Introduction
  - What is OOP?
  - Procedural vs OOP
- 02. Classes & Objects
- 03. Four Pillars
  - Overview
  - Encapsulation
  - Abstraction
  - Inheritance
    
    Overview
    Types
    Single
    Multilevel
    Hierarchical
    Multiple
    Hybrid
    super Keyword
    Method Overriding
  - Polymorphism
    
    Overview
    Method Overloading
- 04. Object Relationships
- 05. Advanced Concepts
- 06. Design Principles
  - SOLID Principles
  - DRY, KISS, YAGNI
- 07. Practice
Computer Networks
- Overview
- 01. Fundamentals
- 02. Transport
- 03. Web Protocols
- 04. Infrastructure
- 05. Interview
  - Network Interview Questions
Git & GitHub
- Overview
- 01. Basics
- 02. Branching
- 03. Remote & GitHub
- 04. Advanced
- 05. Interview
  - Git Interview Questions
HTML & CSS
- Overview
- 01. HTML Basics
- 02. CSS Basics
- 03. Layout
- 04. Advanced
- 05. Interview
  - HTML & CSS Interview Questions
Tailwind CSS
- Tailwind Overview
- 01. Basics
- 02. Core Utilities
- 03. Layout
- 04. Advanced
- 05. Interview
  - Interview Questions
Namaste JavaScript
JavaScript
- Phase 1 — Fundamentals
  - 01. Introduction
    
    Introduction to JavaScript
    What is JavaScript?
    The History of JavaScript
    JavaScript vs ECMAScript
    JavaScript Engines
    Compilation vs Interpretation
    JavaScript Runtime
  - 02. Environment
    
    Browser Environment
    JavaScript Environment
    Node.js Environment
    JavaScript Console
    Developer Tools
  - 03. Variables
    
    var
    let
    Variables
    const
    Temporal Dead Zone (TDZ)
    Variable Hoisting
  - 04. Data Types
    
    Primitive Types
    Reference Types
    Type Conversion
    Data Types
    Type Coercion
    Truthy & Falsy Values
    typeof Operator
    NaN — Not a Number
  - 05. Operators
    
    Arithmetic Operators
    Comparison Operators
    Logical Operators
    Assignment Operators
    Operators
    Ternary Operator
    Nullish Coalescing Operator
    Optional Chaining
  - 06. Control Flow
    
    if-else
    switch
    Loops
    break and continue
    Guard Clauses
    Control Flow
  - 07. Functions
    
    Function Declaration
    Function Expression
    Arrow Functions
    Anonymous Functions
    Named Functions
    Callback Functions
    Functions
    Higher-Order Functions
    Pure Functions
    Recursion
    IIFE
    Default Parameters
    Rest Parameters
    arguments Object
    Function Hoisting
  - 08. Scope
    
    Lexical Scope
    Block Scope
    Global Scope
    Scope Chain
    Closures
    Scope
  - 09. Arrays
    
    Creating Arrays
    Array Methods
    map()
    filter()
    reduce()
    forEach()
    find() and findIndex()
    some() and every()
    Arrays
    every()
    flat() and flatMap()
    sort()
    Array Performance
  - 10. Objects
    
    Object Literals
    Properties
    Methods
    Object Destructuring
    Spread Operator
    Object.freeze()
    Object.seal()
    Property Descriptors
    Object.defineProperty()
    Objects
- Phase 2 — Core Concepts
  - Execution Context
    
    Execution Context
    Types of Execution Context
    Creation Phase
    Execution Phase
    Lexical Environment
  - Call Stack
    
    Stack Frames
    Call Stack
    Stack Overflow
    Async Stack
  - Hoisting
    
    Function Hoisting
    var Hoisting
    Hoisting
    let/const Hoisting
    Temporal Dead Zone
  - this Keyword
    
    Default Binding
    Implicit Binding
    Explicit Binding
    The this Keyword
    new Binding
    Arrow Functions and this
    Common Pitfalls with this
  - Prototypes
    
    The Prototype Chain
    Setting Prototypes
    Built-in Prototypes
    Prototype vs Instance
    Prototypes
  - Inheritance
    
    Prototypal Inheritance
    Class Inheritance
    Composition vs Inheritance
    Inheritance
  - Classes
    
    Class Declaration
    Constructor
    extends & super
    Getters & Setters
    Static Members
    Private Fields
    Classes
  - Modules
    
    Named Exports
    Default Exports
    Dynamic Import
    ESM vs CommonJS
    Modules
  - Iterators
    
    Iteration Protocol
    Custom Iterables
    Iterators
  - Generators
    
    Generator Functions
    yield
    Async Generators
    Generators
  - Symbols
    
    Creating Symbols
    Well-Known Symbols
    Symbols
  - Map
    
    Map Methods
    Map vs Object
    Map Iteration
    WeakMap
    Map
  - Set
    
    Set Methods
    Set Operations
    WeakSet
    Set
  - WeakMap/WeakSet
    
    WeakMap
    WeakSet
    WeakMap & WeakSet
  - Memory Management
    
    Stack vs Heap
    Memory Lifecycle
    Memory Leaks
    Memory Management
  - Garbage Collection
    
    Mark-and-Sweep
    Generational GC
    Common Memory Leaks
    Garbage Collection
- Phase 3 — Async JS
- Phase 4 — Browser APIs
- Phase 5 — Modern JS
- Phase 6 — Performance
- Phase 7 — Design Patterns
- Phase 8 — Internals
- Phase 9 — Enterprise JS
- 🎯 Interview Questions (150+)
- Interview Questions
React Academy
- Phase 1: React Fundamentals
- Phase 2: Components & JSX
- Phase 3: State Management
- Phase 4: React Hooks
- Phase 5: Routing & Data Fetching
- Phase 6: Performance Optimization
- Phase 7: Advanced React
- Phase 8: Modern React
- Phase 9: Architecture & Enterprise
- Phase 10: Production React & Testing
- React Interview Questions
Next.js
Angular
- Overview
- Phase 1: Fundamentals
  - 01-angular-fundamentals
    
    Angular Fundamentals Overview
    1. Introduction to Angular
    2. Development Environment Setup
    Angular Architecture
    4. Angular Core Concepts
    Angular CLI
    Angular Workspace
    TypeScript Configuration (tsconfig.json)
    Angular JSON Configuration
  - 02-typescript
    
    TypeScript Fundamentals
    3. TypeScript Fundamentals for Angular
    Interfaces in TypeScript
    Access Modifiers in TypeScript
    Generics in TypeScript
    Decorators in TypeScript
    Enums in TypeScript
  - 03-components
    
    Creating Components
    Component Lifecycle
    Components
    Component Communication
    Standalone Components
    Component Best Practices
  - 04-data-binding
    
    Interpolation
    Property Binding
    Event Binding
    Data Binding
    Two-Way Binding
  - 05-directives
    
    Structural Directives
    Attribute Directives
    Custom Directives
    Directives
  - 06-pipes
    
    Built-in Pipes
    Custom Pipes
    Pipes
  - 07-services
    
    Creating Services
    Dependency Injection Introduction
    Services & Dependency Injection
- Phase 2: Components, Routing & Forms
  - 01-routing
    
    Routing
    Router Setup & Basics
    Child Routes
    Lazy Loading
    Route Guards
    Resolvers
    Route Data
  - 02-forms
    
    Introduction to Forms
    Angular Forms
    Template-Driven Forms
    Reactive Forms
    FormGroup
    FormControl
    FormArray
    Built-in Validators
    Custom Validators
    Async Validators
    Dynamic Forms
    Nested Forms
    Reusable Form Components
    Forms Best Practices
  - 03-dependency-injection
    
    Injectors
    Providers
    Dependency Injection
    inject() Function
    Hierarchical DI
- Phase 3: Advanced
  - 01-rxjs
    
    RxJS
    Observables
    RxJS Subjects
    RxJS Operators
    switchMap
    mergeMap
    concatMap
    exhaustMap
    combineLatest
    forkJoin
    takeUntil
    Error Handling
  - 02-state-management
    
    Component State
    State Management
    Service-based State
    Signals for State
    NgRx
    ComponentStore
  - 03-performance
    
    OnPush Change Detection
    trackBy
    Performance Optimization
    Lazy Loading & Preloading
    Preloading Strategies
    Change Detection Deep Dive
    Memoization
- Phase 4: Enterprise
  - 01-architecture
    
    Angular Architecture
    Smart vs Dumb Components
    Feature Modules
    Folder Structure
    Scalable Architecture
    Clean Architecture
    Micro-Frontends
  - 02-authentication
    
    Authentication
    Authentication & Authorization
    Authorization
    JWT Tokens
    Token Refresh
    Auth Route Guards
  - 03-http
    
    HttpClient
    HTTP Interceptors
    HTTP Client
    Retry Strategies
    HTTP Caching
    File Upload
    File Download
  - 04-testing
    
    Unit Testing
    Integration Testing
    Mocking
    Testing
    Jasmine
    Karma
    Cypress
- Phase 5: Modern Angular
  - 01-signals
    
    Angular Signals
    Writable Signals
    Computed Signals
    Effects
    Signal Inputs & Model
    Migration from RxJS/Observables to Signals
    resource() & rxResource()
    linkedSignal()
  - 02-control-flow
    
    @if
    New Control Flow
    @switch
    @for
    @defer
    @let Syntax
  - 03-standalone
    
    Standalone Components
    Standalone Routing
    Standalone Components
    Standalone Services
  - 04-ssr
    
    Server-Side Rendering
    Hydration
    Pre-rendering
    SSR & Hydration
    SEO with Angular SSR
  - 05-zoneless
    
    Zoneless Change Detection
    Zoneless Mode
- 🎯 Interview Questions (100+)
SQL / MySQL
- SQL / MySQL Overview
- Database Basics
- Querying Data
- Joins
- Performance & Transactions
- Programmability
  - Stored Procedures & Functions
  - Triggers
- Administration & Scaling
- Interview & Revision
MongoDB
- MongoDB Overview
- Getting Started
- Core MongoDB
- Aggregation Framework
- Operations
- Security
- Integration
  - Mongoose — Node.js
- Interview & Revision
Redis
- Redis Overview
- Core Concepts
- Data Types
- Features & Patterns
- Scaling & High Availability
- Integration & Commands
- Practice & Interview
Data Structures
Striver Blind 75 Solutions
Node.js
GraphQL
- GraphQL Overview
- 01. Basics
- 02. Operations
- 03. Server
- 04. Client & Practice
- 05. Interview
  - Interview Questions
Python
- Python Overview
- Introduction
- Setup & Environment
- Python Basics
- Strings
- Numbers & Math
  - Numbers in Python
  - Math Module
- Collections
- Control Flow
- Functions
- Exception Handling
  - Exception Handling (try/except)
  - Custom Exceptions
- Object-Oriented Programming
- Modules & Packages
- File Handling
- Regular Expressions
  - Regular Expression Syntax
  - The re Module
- Iterators, Generators & Decorators
- Advanced Concepts
- Standard Library
- Concurrency
- Database Programming
- Testing
  - unittest Framework
  - pytest Framework
- 🎯 Interview Questions (150+)
- Interview Preparation
  - Python Interview Questions
TypeScript
- Introduction
- Setup
- Basic Types
- Type Inference
- Type System
- Functions
- Objects & Interfaces
- Generics
- Advanced Types
- Architecture
- React + TypeScript
- Angular + TypeScript
- Node.js + TypeScript
- Interview Questions
- Cheatsheet
- Roadmap
Cloud & AWS
- Cloud & AWS Overview
- 01. Fundamentals
- 02. Compute
- 03. Storage & Database
- 04. Networking & Delivery
- 05. Deployment
- 06. Interview
  - Interview Questions
  - AWS CLI Cheat Sheet
- 🎯 Interview Questions (150+)
Docker
Design Patterns & SOLID
- Overview
- 01. Fundamentals
  - What Are Design Patterns?
  - OOP Refresher
- 02. SOLID Principles
- 03. Creational
- 04. Structural
- 05. Behavioral
- 06. Practical Guide
- 07. Interview
  - Interview Questions
System Design
High-Level Design (HLD)
Low-Level Design (LLD)
- LLD Overview
- 01. OOP & Design Principles
- 02. Code & Architecture
- LLD Projects
Interview Prep
Behavioral Interview Prep
- Question Bank & Story Builder ↗
- Guides

Select theme

On this page

Overview

On this page

Overview

Big-O Notation

Big-O Notation

Section titled “Big-O Notation”

Big-O describes worst-case runtime.

Example:

3n + 10  O(n)

Previous
Time Complexity Next
O(1) Constant Time