UnlockedCoding
Home
Categories
All Courses
← Back to dsa Courses
Loading Wistia player...
SIGMA-9-CPP
SIGMA-9 CPP DSA by Apna college video tutorials and hands-on projects.
Course Videos (592)
How to verify on Discord?
Orientation Session (Recording)
Extra Live Session 1 (Recording)
Extra Live Session 2 (Recording)
Extra Live Session 3 (Recording)
Linkedin Mentorship Session (with Aman Sir)
Coding Platforms Mentorship Session
Projects Mentorship Session
Resume Building Mentorship Session
Aman Sir's session for 1st year
Off-Campus Mentorship Session
Special Mentorship Session by Aman Sir
Message from the Teacher
Placements & Internships
About the Lectures
Pre-requisites
What to Install?
Using Replit
For Mac Users - Setting up C++
Using VS Code
What are Flowcharts?
Components of Flowchart
Sum of 2 Numbers
Calculate Simple Interest
Max of 2 Numbers
Print N Natural Numbers
Sum of N Natural Numbers
Boilerplate Code in C++
How does code run?
Preprocessor Directive
Main Function in C++
What is Namespace?
Output in C++
Print the Pattern
Variables in C++
Naming Conventions
Identify Valid Names
Data Types in C++
Comments
Input in C++
Print Average Marks
Constants
Implicit Type Conversion
Explicit Typecasting
Practice Qs
Arithmetic Operators
Unary Arithmetic Operators
Assignment Operators
Relational Operators
Logical Operators
If else Statements
Practice Qs
Else if Statements
Practice Qs
Practice Qs
Ternary Operator
Switch Statement
Build a Calculator
for Loop (in Detail)
Print "apna college"
Print N Natural Numbers
Sum of N Natural Numbers
while Loop
Practice Qs
Practice Qs
do while Loop
break Statement
Practice Qs (break)
continue Statement
Practice Qs (continue)
Check for Prime
Check for Prime (Optimized)
Nested Loops
Nested Loops (Dry Run)
Star Pattern
Inverted Star Pattern
Half Pyramid Pattern
Character Pyramid Pattern
Hollow Rectangle Pattern
Inverted & Rotated Half-Pyramid Pattern
Floyd's Triangle Pattern
Diamond Pattern
Butterfly Pattern
What are Functions?
Forward Declaration
Syntax with Parameters
Practice Qs
Practice Qs (Factorial)
Function call in Memory
Scope (Local & Global)
Practice Qs (Prime Number)
Practice Qs (Binomial Coefficient)
Function Overloading
Practice Qs (Primes in Range)
What is Binary Number System?
Convert Binary to Decimal
Convert Decimal to Binary
Question (Decimal to Binary)
Common Numbers in Binary
Data Type Modifiers
Binary to Decimal (Code)
Decimal to Binary (Code)
Basic Concepts of Memory
AddressOf (&) Operator
What are Pointers?
Dereference Operator
Null Pointers
Passing Arguments (Value vs Reference)
Reference Variables
Practice Qs
Practice Qs
Basics of Array
Creating an Array
Output & Input Array
Find Largest in Array
Arrays are passed by Reference
Linear Search
Reverse an Array
Binary Search
Binary Search Code
Binary Search (Time Complexity)
Array Pointer
Pointer Arithmetic 1
Pointer Arithmetic 2
Pointer Arithmetic 3
Pointer Arithmetic 4
Print Subarrays
Max Sum Subarray (Brute Force)
Max Sum Subarray (Slightly Optimized)
Kadane's Algorithm for Max Sum Subarray
Buy & Sell Stocks
Buy & Sell Stocks (Code)
Trapping Rainwater
Trapping Rainwater (Code)
Bubble Sort
Bubble Sort (Code)
Selection Sort
Selection Sort (Code)
Insertion Sort
Insertion Sort (Code)
Counting Sort
Counting Sort (Code)
In-built Sort in C++
Practice Qs
Introduction to 2D Arrays
Input & Output a 2D Array
2D Arrays in Memory
Spiral Matrix
Spiral Matrix (Code)
Diagonal Sum
Diagonal Sum (Code)
Search in Sorted Matrix
Search in Sorted Matrix (Code)
Matrix Pointers
Matrix Pointers in Functions
Revisit Char Data Type
Character Array
Input Char Array
Convert to UpperCase
Reverse a Char Array
Valid Palindrome
cstring Functions
OOPs Intro (for Strings)
C++ Strings
for each Loop
String Member Functions
Valid Anagram
Valid Anagram (Code)
Creating a Dynamic Array
Dynamic Memory Allocation
Static v/s Dynamic Allocation
Memory Leak
2D Dynamic Arrays
What is STL?
Vector Introduction
Vector Implementation in Memory
Pair Sum
2D Vectors
Practice Qs
Bitwise Operators
One's Complement
Bitwise Shift Operators
Practice Qs
Check if Odd or Even
Get ith Bit
Set ith Bit
Clear ith Bit
Check for Power of 2
Update ith Bit
Clear Last i Bits
Count Set Bits
Fast Exponentiation
Fast Exponentiation (Code)
Classes & Objects
Access Modifiers
Getters & Setters
Encapsulation
Constructor
Practice Qs
Copy Constructor
Shallow & Deep Copy
Destructor
Inheritance
Mode of Inheritance
Single Inheritance
Multi-level Inheritance
Multiple Inheritance
Hierarchical & Hybrid Inheritance
Polymorphism
Function Overloading
Operator Overloading
Function Overriding
Virtual Functions
Abstraction
Pure Virtual Function
Static Keyword
Static Objects
Friend Functions & Class
Practice Qs
Practice Qs
What is Recursion?
Dive Deep into Recursion
Recursion in Memory
Numbers in Decreasing Order
Dry Run with Call Stack
Stack Overflow
Sum of N Natural Numbers
Nth Fibonacci
Nth Fibonacci (Code)
Check if Array Sorted
First Occurrence
Last Occurrence
Print X to the power N
X to the power N (Code)
Tiling Problem
Tiling Problem (Code)
Remove Duplicates in String
Remove Duplicates (Code)
Friends Pairing Problem
Friends Pairing (Code)
Binary Strings Problem
Binary Strings (Code)
Binary Strings (Dry Run)
Merge Sort Algorithm
Merge / Combine Step
Merge Sort (Code)
Merge Sort (Summary)
Quick Sort Algorithm
Quick Sort (Code)
Worst Case Time Complexity - Quick Sort
Search in Rotated Sorted Array
Rotated Sorted (Pseudocode)
Rotated Sorted (Code)
Introduction
What is Time Complexity?
Constant Time Complexity
Big O Notation
Big O from Functions
Big O Math Formula (Optional)
Other Notations
What is Space Complexity?
Common Time Complexities
Constant & Linear TC
Quadratic TC
Practice Qs 1
Practice Qs 2
Practice Qs 3
Bubble Sort Analysis
Logarithmic TC (Binary Search Analysis)
O(n) vs O(logn) - Linear vs Log
Recursion Time Complexity
Recursive Sum of N Numbers
Recursive Factorial of N
Recursive Nth Fibonacci
Merge Sort Analysis
Power Function Analysis
Practice Qs
How to approach Coding Qs?
Introduction
Backtracking on Arrays
Find Subsets
Find Subsets (Code)
Find Permutations
Find Permutations (Code)
N Queens Qs Discussion
N Queens (Approach)
isSafe in N Queens (Approach)
N Queens (Time Complexity)
N Queens Variations
Grid Ways
Grid Ways (Code)
Grid Ways (Dry Run)
Grid Ways (Time Complexity)
Grid Ways (Optimization)
Sudoku Solver
Sudoku Solver (Code)
isSafe in Sudoku Solver
Introduction to Linked List
LL Implementation
Push Front in LL
Push Back in LL
Print LL
Insert in Middle of a LL
Deleting the Linked List
Pop Front in LL
Pop Back in LL
Iterative Search in LL
Recursive Search in LL
Reverse a Linked List
Find & Remove Nth Node from End
Find & Remove Nth (Code)
Detect Cycle in a LL
Detect a Cycle (Code)
Removing Cycle in LL
Removing Cycle (Code)
Removing Cycle (Math Proof)
List in STL
Merge Sort on a LL
Merge Sort (Split At Mid)
Merging 2 Sorted Lists
Zig Zag Linked List
Zig Zag LL (Alternate Merging)
Doubly Linked List (Push Front)
Doubly Linked List (Pop Front)
Introduction to Stack
Stack using Vector
Stack using Vector & Class Template
Stack using LinkedList
Stack in STL
Push at Bottom of Stack
Push at Bottom (Code)
Reverse a String using Stack
Reverse a Stack
Stock Span
Stock Span (Approach)
Stock Span (Code)
Next Greater Element
Next Greater Element (Code)
Valid Parentheses
Valid Parentheses (Code)
Duplicate Parentheses
Duplicate Parentheses (Code)
Max Area in Histogram
Max Area in Histogram (nextSmaller Logic)
Max Area in Histogram (Code)
Queue Introduction
Implementation using LinkedList
Circular Queue using Array
Queue in STL
Queue using 2 Stacks
Stack using 2 Queues
First non-repeating letter
First non-repeating letter (Code)
Interleave 2 Queues
Interleave 2 Queues (Code)
Queue Reversal
Double Ended Queue
Queue using Deque
Stack using Deque
Greedy Approach Introduction
Activity Selection Problem
Activity Selection (Approach)
Activity Selection (Code)
Activity Selection (Proof)
Pairs in C++
Fractional Knapsack
Fractional Knapsack (Code)
Min Absolute Difference of Pairs
Max Chain Length
Max Chain Length (Code)
Indian Coins
Indian Coins (Code)
Job Sequencing Problem
Job Sequencing Variation
Binary Trees Introduction
Levels & Subtrees
Practice Quiz
Build Tree from Preorder
Preorder Traversal
Inorder Traversal
Postorder Traversal
Level Order Traversal
Height of Binary Tree
Height of BT (Code)
Count of Nodes in BT
Sum of Nodes in BT
Diameter of a Tree ( Approach 1 )
Diameter of a Tree ( Code )
Diameter of a Tree ( Approach 2 )
Diameter of a Tree ( Code 2 )
Subtree of another Tree
Subtree of another Tree (isIdentical)
Map in C++
Top View of a Tree (Horizontal Distance)
Top View of a Tree ( Approach )
Top View of a Tree ( Code )
Kth Level of a Tree
Lowest Common Ancestor
Lowest Common Ancestor (Code)
LCA (Approach 2)
LCA (Approach 2) Code
Min Distance between Nodes
Kth Ancestor of a Node
Kth Ancestor (Code)
Transform to Sum Tree
BST Introduction
Search in BST
Insert & Build a BST
Search in BST (Code)
Delete a Node in BST
Inorder Successor
Delete a Node (Code)
Print in Range
Root to Leaf Path
Validate BST
Validate BST (Code)
Sorted Array to Balanced BST
Sorted Array to Balanced BST (Code)
BST to Balanced BST
BST to Balanced BST (Code)
Largest BST in BT
Largest BST in BT (Code)
Merge 2 BSTs
Heaps & Priority Queue (Introduction)
PQ in C++ STL
What are Heaps?
Building Heaps
Push in Heap
Push in Heap (Code)
Pop in Heap
Pop in Heap (Code)
Pop in Heap (Dry Run)
PQ for Objects
PQ for Pairs
Heap Sort (Building maxHeap)
Heap Sort (Sorting)
Nearby Cars
Nearby Cars (Code)
Connect N Ropes
Connect N Ropes (Code)
Weakest Soldier
Weakest Soldier (Code)
Sliding Window Maximum
Sliding Window Maximum (Code)
Introduction
Hash Table Data Structure
Hashing (Hash Function)
Collisions
Building Hash Table
Insert in Hash Table
Rehashing
Search in Hash Table
STL Containers
Unordered Maps
Maps
Unordered Sets
Sets
Majority Element
Majority Element (Code)
Valid Anagram
Valid Anagram (Code)
Count Distinct
Union & Intersection
Itinerary from Tickets
Itinerary from Tickets (Code)
Zero Sum Largest Subarray
Zero Sum Largest Subarray (Code)
K Sum Subarray Count
K Sum Subarray Count (Code)
Tries Introduction
Search in Trie
Building a Trie DS
Insert in Trie
Search in Trie
Word Break Problem
Word Break (Code)
Prefix Problem
Prefix (Code)
StartsWith Problem
Count Unique Substrings
Count Unique Substrings (Code)
Longest Word with all Prefix
Longest Word (Code)
Introduction to Graphs
Types of Graphs
Graph using Adjacency List
Graph using Adjacency Matrix
Edge List & Implicit Graph
Building a Graph (Adjacency List)
Breadth First Traversal (BFS)
BFS Code
Depth First Traversal (DFS)
DFS Code
Has Path Problem
Disconnected Components
Cycle in Graphs
Cycle Detection (Undirected)
Cycle Detection Code (Undirected)
Undirected approach for Directed
Cycle Detection (Directed)
Cycle Detection Code (Directed)
Cycle Detection Dry Run (Directed)
Bipartite Graph
Bipartite Graph (Code)
Bipartite Graph (Approach 2)
All Paths Problem
What is Topological Sorting?
Topological Sorting (DFS)
Topological Sorting Code (DFS)
Course Schedule I
Course Schedule II
Kahn's Algorithm (Indegree)
Topoplogical Sorting (Kahn's Algorithm)
Kahn's Algorithm Code
Kahn's Algo for Cycle Detection
Dijkstra's Algorithm (Edge Relaxation)
Dijkstra's Algorithm (Approach)
Dijkstra's Algorithm (Code)
BellmanFord Algorithm (Approach)
BellmanFord Algorithm (Code)
What is MST?
Prim's Algorithm
Prim's Algorithm (Code)
Min Cost to Connect Points
Cheapest Flights within K Stops
Cheapest Flights (Code)
Disjoint Set (Union Find)
Disjoint Set (Code)
Kruskal's Algorithm
Kruskal's Algorithm (Code)
Flood Fill Algorithm
Flood Fill (Code)
DP Introduction
DP using Fibonacci Concept
What is DP?
Fibonacci using Tabulation
Types of DP
Important DP Concepts
Climbing Stairs (Recursion)
Climbing Stairs (Memoization)
Climbing Stairs (Tabulation)
Variation of Climbing Stairs
Knapsack Problems
0-1 Knapsack
0-1 Knapsack (Recursion Code)
0-1 Knapsack (Memoization)
0-1 Knapsack (Tabulation)
Target Sum Subset
Unbounded Knapsack
Coin Change Problem
Coin Change (Code)
Rod Cutting Problem
Rod Cutting (Code)
Longest Common Subsequence
LCS (Memoization)
LCS (Tabulation)
Longest Common Substring
Longest Common Substring (Code)
Longest Increasing Subsequence
Longest Increasing Subsequence (Code)
Edit Distance
Edit Distance (Code)
WildCard Matching
WildCard Matching (Bottom Up)
Catalan's Number
Nth Catalan (Recursion)
Nth Catalan (Memoization)
Nth Catalan (Tabulation)
Count BSTs from Nodes
Mountain Ranges
Matrix Concepts (Basic Math)
Matrix Chain Multiplication
MCM (with Recursion)
MCM Code (Recursion)
MCM (Memoization)
MCM (Tabulation)
MCM Code (Tabulation)
Minimum Partitioning
Minimum Partitioning (Code)
Segment Trees Introduction
Meaning & Count of Nodes
Creating Segment Tree
Creating Segment Tree (Approach)
Creating Segment Tree (Code)
Queries on Segment Tree
Queries on Segment Tree (Code)
Update on Segment Tree
Update on Segment Tree (Code)
Range Max ST (Creation)
Range Max ST (Query)
Range Max ST (Update)
Range Min (Approach)