Complete DS Data Structure in one shot | Semester Exam | Hindi

➡ Contact Us: 👇
📞Call on: [phone]

➡ One Shot Complete Playlist for GATE CSE Exam : 👇

➡ Our One Shot Semester Exam Videos: 👇

#knowledgegate #sanchitsir #sanchitjain

*********************************************************
Content in this video:
00:00 (Chapter-0: Introduction)- About this video

02:30 (Chapter-1 Introduction): Basic Terminology, Elementary Data Organization, Built in Data Types in C. Abstract Data Types (ADT)

22:10 (Chapter-2 Array): Definition, Single and Multidimensional Arrays, Representation of Arrays: Row Major Order, and Column Major Order, Derivation of Index Formulae for 1-D,2-D,3-D and n-D Array Application of arrays, Sparse Matrices and their representations.

1:06:41 (Chapter-3 Linked lists): Array Implementation and Pointer Implementation of Singly Linked Lists, Doubly Linked List, Circularly Linked List, Operations on a Linked List. Insertion, Deletion, Traversal, Polynomial Representation and Addition Subtraction & Multiplications of Single variable & Two variables Polynomial.

1:59:35 (Chapter-4 Stack): Abstract Data Type, Primitive Stack operations: Push & Pop, Array and Linked Implementation of Stack in C, Application of stack: Prefix and Postfix Expressions, Evaluation of postfix expression, Iteration and Recursion- Principles of recursion, Tail recursion, Removal of recursion Problem solving using iteration and recursion with examples such as binary search, Fibonacci numbers, and Hanoi towers. Trade offs between iteration and recursion.

4:00:25 (Chapter-5 Queue): Create, Add, Delete, Full and Empty, Circular queues, Array and linked implementation of queues in C, Dequeue and Priority Queue.

4:45:05 (Chapter-6 PTree): Basic terminology used with Tree, Binary Trees, Binary Tree Representation: Array Representation and Pointer(Linked List) Representation, Binary Search Tree, Strictly Binary Tree ,Complete Binary Tree . A Extended Binary Trees, Tree Traversal algorithms: Inorder, Preorder and Postorder, Constructing Binary Tree from given Tree Traversal, Operation of Insertion , Deletion, Searching & Modification of data in Binary Search . Threaded Binary trees, Traversing Threaded Binary trees. Huffman coding using Binary Tree. Concept & Basic Operations for AVL Tree , B Tree & Binary Heaps

6:18:06 (Chapter-7 Graphs): Terminology used with Graph, Data Structure for Graph Representations: Adjacency Matrices, Adjacency List, Adjacency. Graph Traversal: Depth First Search and Breadth First Search.

6:42:46 (Chapter-8 Hashing): Concept of Searching, Sequential search, Index Sequential Search, Binary Search. Concept of Hashing & Collision resolution Techniques used in Hashing

[sudippattanayak]

🎯 Key Takeaways for quick navigation:

04:14 *Efficient Programming Essential*
04:54 *Solid Understanding Needed*
05:22 *Efficient Coding Crucial*
06:16 *Proper Data Arrangement*
06:41 *Organization is Key*
07:47 *Importance of Arrangement*
08:16 *Proper Item Placement*
11:42 *Modify Data Structures*
13:29 *Define new structures*
13:59 *Choose right algorithm*
14:13 *Data structure depends*
14:26 *Suitable data structure*
16:17 *Modularize structures*
16:32 *Basic structures available*
18:04 *Primitive Data Structures*
18:19 *Predefined Operations*
18:32 *Integers Operations*
18:45 *Inefficient Structures*
19:16 *Linear vs. Non-Linear*
19:44 *Non-Linear Data Structure*
20:24 *Implementation Complexity*
20:39 *Traversal Orders*
21:21 *Homogeneous and Heterogeneous*
23:09 *Quantity matters.*
24:57 *Accessing elements.*
25:11 *Array declaration basics.*
27:30 *Array Indexing Basics*
28:14 *Efficient Storage Use*
28:28 *Fast Access Methods*
29:22 *Easy to Modify*
29:37 *Specify Space Needs*
29:51 *Understand Space Allocation*
30:18 *Manage Dynamic Space*
33:05 *Serious Computer Time*
33:34 *Priority in Life*
37:14 *Upper bound*
37:27 *Formula explained*
37:41 *Perfect answer*
37:53 *Array size calculation*
38:20 *Multi-dimensional array size*
38:46 *Base address calculation*
39:42 *Random indexing*
40:11 *Base address calculation*
43:40 *1D vs 2D understanding*
48:22 *Understandable for psychology*
58:31 *Indexing Comprehension*
59:10 *Dimension Length Logic*
01:01:31 *Sparse Matrix Concept*
01:02:52 *Smart Sparse Matrix Storage*
01:04:40 *Sparse Matrix Handling*
01:08:25 *Runtime data manipulation.*
01:09:06 *Understanding linked lists.*
01:11:36 *Link and pointer part explanation.*
01:11:50 *Disadvantages of linked lists.*
01:12:18 *Simple node structure.*
01:12:57 *Dynamic size and memory efficient.*
01:13:37 *Easy insert/delete.*
01:14:47 *Consider space & time.*
01:20:00 *Creating nodes.*
01:21:49 *Basic operations.*
01:25:26 *Iterative vs. Recursive*
01:29:31 *Insert Node at Start*
01:36:55 *Implementing recursion.*
01:38:45 *Using Temp Variables*
01:39:54 *Iterative Process*
01:40:35 *Try Different Cases*
01:41:44 *Linking Nodes*
01:42:14 *Pointer Movement*
01:42:54 *Order of Operations*
01:43:17 *Head and Tail Movement*
01:44:11 *List traversal*
01:44:37 *Header list simplification*
01:44:52 *Header node usage*
01:45:06 *Special nodes in the list*
01:45:49 *Header list implementation*
01:46:04 *Understanding changes*
01:47:05 *Circular list benefits*
01:48:53 *Circular queue advantages*
01:51:03 *Techniques for managing pointers*
01:53:46 *Location Previous Next*
01:53:59 *Circular Double Linked*
01:55:06 *Link List Different*
01:55:34 *Power Multiplication Zero*
01:56:18 *Understandable Structure Understandable*
01:56:46 *Clear Simple Idea*
01:57:43 *Pointers Addition*
02:00:23 *Real-life Examples*
02:01:02 *Clothes as Stack*
02:02:42 *Understanding Stack*
02:03:35 *Push Pop Understanding*
02:03:50 *Top Bottom Basic*
02:04:04 *Stack Operations Example*
02:03:35 *Push Pop Basics*
02:03:50 *Top Bottom Concept*
02:04:17 *Value Sequence*
02:08:11 *Insertion Overflows Check*
02:08:26 *Stack Implementation Insights*
02:08:40 *Handling Default Case*
02:09:35 *Handling Full Stack*
02:10:17 *Deletion (Pop) Strategy*
02:10:31 *Indexing and Implementation*
02:10:42 *Handling Pop Operations*
02:10:54 *Starting Index Consideration*
02:12:42 *Considerations for Deletion*
02:12:56 *Stack structure basics*
02:17:34 *Stack Implementation*
02:22:24 *Stack Applications Basics*
02:24:06 *Three Notations: Infix, Prefix, Postfix*
02:25:21 *Polish Notation Introduced*
02:28:09 *Prefix evaluation*
02:28:21 *Operator priority*
02:28:49 *Expression conversion*
02:29:18 *Operator associativity*
02:30:28 *Expression conversion steps*
02:33:22 *Postfix expression.*
02:35:52 *Power precedence.*
02:38:17 *Convert expressions*
02:38:30 *Tree traversal method*
02:38:45 *Preorder traversal*
02:38:57 *Solve expressions*
02:39:51 *Solve expressions with priority*
02:40:32 *Traverse the tree*
02:41:09 *Solve expressions by traversal*
02:41:48 *Benefits of tree method*
02:43:33 *Convert expressions*
02:43:48 *Using stack help*
02:45:28 *Postfix notation*
02:45:43 *Closing bracket*
02:47:23 *Evaluate expressions*
02:49:13 *Result Calculation Process*
02:51:32 *Value Pop Process*
02:53:22 *Importance of recursion.*
02:54:19 *Handling base case.*
02:56:01 *Recursive factorial function.*
02:59:12 *Loop within loop*
Tail Recursion Example
03:07:29 *Print command understanding*
03:08:13 *Recursion understanding clear*
03:09:19 *Recursive function observation*
03:13:00 *Recursive function understanding*
03:22:24 *Sequential Number Analysis*
03:26:51 *Understanding tower patterns*
03:28:00 *Flexibility in problem-solving*
03:28:42 *Recursive thinking importance*
03:30:43 *Puzzle solving approach*
03:31:38 *Tower of Noi function call*
03:34:48 *Swap algorithm explained.*
03:36:06 *Total moves calculation.*
03:40:02 *Recursion Simple Idea*
03:40:29 *Tail Recursion Explanation*
03:41:38 *Understanding Recursion Process*
03:45:22 *Condition Applicable*
03:46:45 *Understanding Recursion*
03:47:12 *Call and Print*
03:50:39 *Preorder traversal*
03:51:05 *Understanding tree structure*
03:56:25 *Understand Recursion Better*
03:57:44 *Recursive Function Call Analysis*
04:01:08 *Direct approach analysis.*
04:01:20 *Transition from cash.*
04:02:06 *Understanding pointers.*
04:06:12 *Efficient processing.*
04:06:32 *Sequential processing.*
04:06:58 *Resource management.*
04:07:39 *Index manipulation.*
04:08:33 *Rearrangement process.*
04:09:00 *Element ordering.*
04:09:12 *Position management.*
04:09:27 *Position updating.*
04:09:39 *Queue operation flow.*
04:11:40 *Special case*
04:16:04 *Define structure*
04:20:07 *Circular Queue Basics*
04:20:21 *Implementing Queue*
04:21:03 *Insert/Delete Observations (continued)*
04:21:30 *Node Structure Continued*
04:21:44 *Handling Overflow*
04:21:58 *Inserting Elements*
04:22:21 *Checking for Empty Queue*
04:22:49 *Updating Rear Pointer*
04:23:18 *Updating Rear Pointer (continued)*
04:23:31 *Handling Deletion*
04:23:44 *Handling Deletion (continued)*
04:24:40 *Bypass q's front*
04:25:47 *Implement logic*
04:26:13 *Observe how it works*
04:27:33 *Get final result*
04:27:46 *Ensure clarity*
04:28:40 *Handle overflow*
04:29:08 *Think logically*
04:29:35 *Circular Queue Implementation*
Understand the change.
Rearrange items.
Check overflow condition.
04:40:58 *Implementation Options*
04:41:51 *Input & Output Restrictions*
04:47:02 *Tree Terminology Clarity*
04:47:44 *Tree Node Connectivity*
04:50:16 *Degree Calculation*
04:50:30 *Total Tree Concept*
04:50:59 *Node Maximum Children*
04:54:36 *Binary Tree Structure*
04:59:39 *Understanding Structure Basics*
05:00:44 *Storing Data Method*
05:01:28 *Critique of Storing Method*
05:05:45 *Preorder, inorder, and postorder traversal*
05:10:07 *Creating unique trees.*
05:10:34 *Question tree traversal.*
05:10:48 *Types of binary tree traversal.*
05:11:15 *Post-order traversal: right to left.*
05:11:29 *Explaining traversal positions.*
05:12:08 *Traversal continuation.*
05:12:35 *Final traversal positions.*
05:15:29 *Left smaller, right larger.*
05:16:13 *Inorder traversal.*
05:16:41 *Binary search.*
05:17:36 *Observing tree cases.*
05:18:47 *Handling deletions.*
05:19:00 *Deletion process.*
05:20:12 *Delete easy nodes*
05:25:16 *Sorted sequences explained.*
05:26:12 *Search algorithm example.*
05:26:52 *Confirming search steps.*
05:27:17 *Validating search sequence.*
05:30:43 *Subtree value comparison*
05:30:57 *AVL tree node values*
05:31:11 *AVL tree insertion*
05:32:33 *Identifying node problems*
05:32:49 *Handling node problems*
05:33:01 *AVL tree rotation*
05:33:16 *Identifying node issues*
05:33:58 *AVL tree balancing*
05:34:57 *AVL tree balancing*
05:36:12 *Perfect Macanism Method*
05:36:50 *Balancing explanation*
05:37:19 *Tree structure analysis*
05:37:47 *No need for recheck*
05:38:16 *Mandatory balancing*
05:38:44 *Handling imbalances*
05:39:12 *Tree status evaluation*
05:39:40 *Perfect balance achieved*
05:39:54 *Continuous practice*
05:42:07 *Copying is difficult*
05:45:28 *Check balancing factors*
05:47:51 *Left type delete*
05:48:44 *Rotate for balance*
05:49:09 *Eliminate cases*
05:49:38 *Delete left node*
05:49:51 *Balance factor -1*
05:50:45 *Direct deletion*
05:51:48 *Replacement selection*
05:52:20 *Successor determination*
05:52:32 *Last node problem*
05:53:42 *Complete Binary Tree*
05:53:55 *Left to Right*
05:55:58 *Node Properties*
05:56:13 *Heap Variants*
05:57:24 *Parent-Child Relationship*
05:58:03 *Max Heap Analysis*
05:58:31 *Understanding Heap*
06:03:42 *Minimum exchanges needed*
06:03:51 *Examining numbers pattern*
06:04:58 *Reversing indices order*
06:05:13 *Deleting elements in heap*
06:06:05 *Understanding heap deletion*
06:06:18 *Handling root deletion in heap*
06:07:36 *Various types of questions*
06:08:05 *Different types of structures*
06:08:54 *Factorial Division Result*
06:09:57 *Labeling Binary Trees*

Made with HARPA AI

[MurkhaGyaniBaba]

🎯 Key Takeaways for quick navigation:

04:14 Efficient Programming Essential
04:54 Solid Understanding Needed
05:22 Efficient Coding Crucial
06:16 Proper Data Arrangement
06:41 Organization is Key
07:47 Importance of Arrangement
08:16 Proper Item Placement
11:42 Modify Data Structures
13:29 Define new structures
13:59 Choose right algorithm
14:13 Data structure depends
14:26 Suitable data structure
16:17 Modularize structures
16:32 Basic structures available
18:04 Primitive Data Structures
18:19 Predefined Operations
18:32 Integers Operations
18:45 Inefficient Structures
19:16 Linear vs. Non-Linear
19:44 Non-Linear Data Structure
20:24 Implementation Complexity
20:39 Traversal Orders
21:21 Homogeneous and Heterogeneous
23:09 Quantity matters.
24:57 Accessing elements.
25:11 Array declaration basics.
27:30 Array Indexing Basics
28:14 Efficient Storage Use
28:28 Fast Access Methods
29:22 Easy to Modify
29:37 Specify Space Needs
29:51 Understand Space Allocation
30:18 Manage Dynamic Space
33:05 Serious Computer Time
33:34 Priority in Life
37:14 Upper bound
37:27 Formula explained
37:41 Perfect answer
37:53 Array size calculation
38:20 Multi-dimensional array size
38:46 Base address calculation
39:42 Random indexing
40:11 Base address calculation
43:40 1D vs 2D understanding
48:22 Understandable for psychology
58:31 Indexing Comprehension
59:10 Dimension Length Logic
01:01:31 Sparse Matrix Concept
01:02:52 Smart Sparse Matrix Storage
01:04:40 Sparse Matrix Handling
01:08:25 Runtime data manipulation.
01:09:06 Understanding linked lists.
01:11:36 Link and pointer part explanation.
01:11:50 Disadvantages of linked lists.
01:12:18 Simple node structure.
01:12:57 Dynamic size and memory efficient.
01:13:37 Easy insert/delete.
01:14:47 Consider space & time.
01:20:00 Creating nodes.
01:21:49 Basic operations.
01:25:26 Iterative vs. Recursive
01:29:31 Insert Node at Start
01:36:55 Implementing recursion.
01:38:45 Using Temp Variables
01:39:54 Iterative Process
01:40:35 Try Different Cases
01:41:44 Linking Nodes
01:42:14 Pointer Movement
01:42:54 Order of Operations
01:43:17 Head and Tail Movement
01:44:11 List traversal
01:44:37 Header list simplification
01:44:52 Header node usage
01:45:06 Special nodes in the list
01:45:49 Header list implementation
01:46:04 Understanding changes
01:47:05 Circular list benefits
01:48:53 Circular queue advantages
01:51:03 Techniques for managing pointers
01:53:46 Location Previous Next
01:53:59 Circular Double Linked
01:55:06 Link List Different
01:55:34 Power Multiplication Zero
01:56:18 Understandable Structure Understandable
01:56:46 Clear Simple Idea
01:57:43 Pointers Addition
02:00:23 Real-life Examples
02:01:02 Clothes as Stack
02:02:42 Understanding Stack
02:03:35 Push Pop Understanding
02:03:50 Top Bottom Basic
02:04:04 Stack Operations Example
02:03:35 Push Pop Basics
02:03:50 Top Bottom Concept
02:04:17 Value Sequence
02:08:11 Insertion Overflows Check
02:08:26 Stack Implementation Insights
02:08:40 Handling Default Case
02:09:35 Handling Full Stack
02:10:17 Deletion (Pop) Strategy
02:10:31 Indexing and Implementation
02:10:42 Handling Pop Operations
02:10:54 Starting Index Consideration
02:12:42 Considerations for Deletion
02:12:56 Stack structure basics
02:17:34 Stack Implementation
02:22:24 Stack Applications Basics
02:24:06 Three Notations: Infix, Prefix, Postfix
02:25:21 Polish Notation Introduced
02:28:09 Prefix evaluation
02:28:21 Operator priority
02:28:49 Expression conversion
02:29:18 Operator associativity
02:30:28 Expression conversion steps
02:33:22 Postfix expression.
02:35:52 Power precedence.
02:38:17 Convert expressions
02:38:30 Tree traversal method
02:38:45 Preorder traversal
02:38:57 Solve expressions
02:39:51 Solve expressions with priority
02:40:32 Traverse the tree
02:41:09 Solve expressions by traversal
02:41:48 Benefits of tree method
02:43:33 Convert expressions
02:43:48 Using stack help
02:45:28 Postfix notation
02:45:43 Closing bracket
02:47:23 Evaluate expressions
02:49:13 Result Calculation Process
02:51:32 Value Pop Process
02:53:22 Importance of recursion.
02:54:19 Handling base case.
02:56:01 Recursive factorial function.
02:59:12 Loop within loop
Tail Recursion Example
03:07:29 Print command understanding
03:08:13 Recursion understanding clear
03:09:19 Recursive function observation
03:13:00 Recursive function understanding
03:22:24 Sequential Number Analysis
03:26:51 Understanding tower patterns
03:28:00 Flexibility in problem-solving
03:28:42 Recursive thinking importance
03:30:43 Puzzle solving approach
03:31:38 Tower of Noi function call
03:34:48 Swap algorithm explained.
03:36:06 Total moves calculation.
03:40:02 Recursion Simple Idea
03:40:29 Tail Recursion Explanation
03:41:38 Understanding Recursion Process
03:45:22 Condition Applicable
03:46:45 Understanding Recursion
03:47:12 Call and Print
03:50:39 Preorder traversal
03:51:05 Understanding tree structure
03:56:25 Understand Recursion Better
03:57:44 Recursive Function Call Analysis
04:01:08 Direct approach analysis.
04:01:20 Transition from cash.
04:02:06 Understanding pointers.
04:06:12 Efficient processing.
04:06:32 Sequential processing.
04:06:58 Resource management.
04:07:39 Index manipulation.
04:08:33 Rearrangement process.
04:09:00 Element ordering.
04:09:12 Position management.
04:09:27 Position updating.
04:09:39 Queue operation flow.
04:11:40 Special case
04:16:04 Define structure
04:20:07 Circular Queue Basics
04:20:21 Implementing Queue
04:21:03 Insert/Delete Observations (continued)
04:21:30 Node Structure Continued
04:21:44 Handling Overflow
04:21:58 Inserting Elements
04:22:21 Checking for Empty Queue
04:22:49 Updating Rear Pointer
04:23:18 Updating Rear Pointer (continued)
04:23:31 Handling Deletion
04:23:44 Handling Deletion (continued)
04:24:40 Bypass q's front
04:25:47 Implement logic
04:26:13 Observe how it works
04:27:33 Get final result
04:27:46 Ensure clarity
04:28:40 Handle overflow
04:29:08 Think logically
04:29:35 Circular Queue Implementation
Understand the change.
Rearrange items.
Check overflow condition.
04:40:58 Implementation Options
04:41:51 Input & Output Restrictions
04:47:02 Tree Terminology Clarity
04:47:44 Tree Node Connectivity
04:50:16 Degree Calculation
04:50:30 Total Tree Concept
04:50:59 Node Maximum Children
04:54:36 Binary Tree Structure
04:59:39 Understanding Structure Basics
05:00:44 Storing Data Method
05:01:28 Critique of Storing Method
05:05:45 Preorder, inorder, and postorder traversal
05:10:07 Creating unique trees.
05:10:34 Question tree traversal.
05:10:48 Types of binary tree traversal.
05:11:15 Post-order traversal: right to left.
05:11:29 Explaining traversal positions.
05:12:08 Traversal continuation.
05:12:35 Final traversal positions.
05:15:29 Left smaller, right larger.
05:16:13 Inorder traversal.
05:16:41 Binary search.
05:17:36 Observing tree cases.
05:18:47 Handling deletions.
05:19:00 Deletion process.
05:20:12 Delete easy nodes
05:25:16 Sorted sequences explained.
05:26:12 Search algorithm example.
05:26:52 Confirming search steps.
05:27:17 Validating search sequence.
05:30:43 Subtree value comparison
05:30:57 AVL tree node values
05:31:11 AVL tree insertion
05:32:33 Identifying node problems
05:32:49 Handling node problems
05:33:01 AVL tree rotation
05:33:16 Identifying node issues
05:33:58 AVL tree balancing
05:34:57 AVL tree balancing
05:36:12 Perfect Macanism Method
05:36:50 Balancing explanation
05:37:19 Tree structure analysis
05:37:47 No need for recheck
05:38:16 Mandatory balancing
05:38:44 Handling imbalances
05:39:12 Tree status evaluation
05:39:40 Perfect balance achieved
05:39:54 Continuous practice
05:42:07 Copying is difficult
05:45:28 Check balancing factors
05:47:51 Left type delete
05:48:44 Rotate for balance
05:49:09 Eliminate cases
05:49:38 Delete left node
05:49:51 Balance factor -1
05:50:45 Direct deletion
05:51:48 Replacement selection
05:52:20 Successor determination
05:52:32 Last node problem
05:53:42 Complete Binary Tree
05:53:55 Left to Right
05:55:58 Node Properties
05:56:13 Heap Variants
05:57:24 Parent-Child Relationship
05:58:03 Max Heap Analysis
05:58:31 Understanding Heap
06:03:42 Minimum exchanges needed
06:03:51 Examining numbers pattern
06:04:58 Reversing indices order
06:05:13 Deleting elements in heap
06:06:05 Understanding heap deletion
06:06:18 Handling root deletion in heap
06:07:36 Various types of questions
06:08:05 Different types of structures
06:08:54 Factorial Division Result
06:09:57 Labeling Binary Trees

[shivangagrawal]

Ignore(just using comment section as bookmark)
Post order In order to tree: 5:13:10.
BST: 5:16:00
BST Deletion: 5:20:00
Heap deletion: 6:07:00
BFS traversal : 6:38:00

[mridulyadav]

17:11 premertive non premitive
21:20 homogeneous vs hetro
2:34:00 prefix postfix
2:53:00 recursion
3:00:45 recursion vs itteriation
3:08:00 recursion problems tree
3:17:00 fibnocci no.
4:13:00 que delt
4:54:00 binary tree
5:04:00 traversal tree
5:15:00 binary search tree
5:54:00 complete binary tree

[audaciousgirl-bgqf]

At 2:03:55 in prefix order after - (minus) + (plus ) will be there ? - + a*/*bc^d^efdc

[FaintArt]

Sir, one shot videos are extremely helpful, please keep continuing to make them..

[codesbite]

6:56:42 option a is right, clarify sir

[vedantabanerjee]

I really appreciate him including humor, memes beside really quality content which is compact, no fluff material. He is indeed a really good teacher!

[bishalhaldar]

4:55:34 q. binary tree height
5:10:17 q2. inorder postorder conv.
5:13:41 q3. inorder preorder conv.

[shubhamkumarme]

Wow...just fells proud after completing DSA give some positiveness..average students is now broken his line and just keep stepping with your videos ..thanks a lot sir ....I know ye sb likhte h but mai cmnt nhi krta but after completing this my soul my heart and my brain ...forced me to type this 😊🙏

[satishpaul]

2:37:56 Right answer is -+a*/*bc^d^efdc

[bytesizedShrey]

Your One Shot Semester series is hands down my secret weapon for acing exams! 🌟 The depth and clarity you bring in such a short time is mind-blowing. As my software engineering exams approach, I'm counting on your magic. 🖥💡

Could you please drop a One Shot on software engineering? It's not just a request; it's a desperate student's plea for salvation! 😅 Your videos are a game-changer, and a software engineering edition would be a total knockout. Keep rocking the educational world! 🚀📚"

[aryandadwal]

Mitochondria is the power house of the cell❌
Array starts at 0✅

[lokeshpatil]

Thank You So Much Sir, I have watched all the courses of CS/IT from your recorded lectures. This One shot video gives total overview of all topics, I would suggest every CS/IT student to watch this series for overall revision.

[Gauravyadav-wxfx]

I want that you complete other subjects like AI, Statistics, DAA, so that this channel grows like a boom, Keep uploading like this, sir, It's our good luck to witness such a next level teacher teaching here, the concepts foundation is held so tight that we feel fully confidence because of you,

[giri_aditya_]

Sir a very humble request from my side on the behalf of every student, please do a one shot on OOPM (Object oriented programming), as semester exams are very close.

[KaranSingh-emnf]

Thank you Sir 🙏
Apne itne kam time me video provide kr diya
Aap best teacher ho ...

[Vivaan]

Thanks Sir,
Exam से One Week पहले सही Time पर मिल गया ये LifeSaver Video 🙏🙏

[satyamchauhan]

Matlab man ki baat padh lete ho sir aap 😅 really searching for this type of video, Ahmedabad, Gujarat

[samaymaan]

Sir aapne 72 se start krne ko kha indexing but ye to hmesa 0 se suru hoga means array ka indexing jab tkk hum programming language bnate time ya nai programming language bnani pdegi ??