Interviews preparation for Programming & Coding

About Course

• Programming interviews are like standard plays in professional sport - prepare accordingly. Don't let Programming Interview gotchas get you down!

  • The course instruction is in Hindi
  • Programming interviews differ from real programming jobs in several important aspects, so they merit being treated differently, just like set pieces in sport.
  • Just like teams prepare for their opponent's playbooks in professional sport, it makes sense for you to approach programming interviews anticipating the interviewer's playbook
  • This course has been drawn by a team that has conducted hundreds of technical interviews at Google and Flipkart

What you will get from this course?

• • Pointers: Memory layout of pointers and variables, pointer arithmetic, arrays, pointers to pointers, pointers to structures, argument passing to functions, pointer reassignment and modification - complete with visuals to help you conceptualize how things work.
  • Strings: Strings, Character pointers, character arrays, null termination of strings, string.h function implementations with detailed explanations.
  • Linked lists: Visualization, traversal, creating or deleting nodes, sorted merge, reversing a linked list and many many problems and solutions, doubly linked lists.
  • Sorting and searching algorithms: Visualize how common sorting and searching algorithms work and the speed and efficiency of those algorithms
  • Recursion: Master recursion with lots of practice! 8 common and uncommon recursive problems explained. Binary search, finding all subsets of a subset, finding all anagrams of a word, the infamous 8 Queens problem, executing dependent tasks, finding a path through a maze, implementing PaintFill, comparing two binary trees
  • Step-by-step solutions to dozens of common programming problems: Palindromes, Game of Life, Sudoku Validator, Breaking a Document into Chunks, Run Length Encoding, Points within a distance are some of the problems solved and explained.
  • Trees and Binary Search Trees
  • Heaps and Binary Heaps
  • Graphs
  • Know how to approach and prepare for coding interviews
  • Understand pointer concepts and memory management at a very deep and fundamental level
  • Tackle a wide variety of linked list problems and know how to get started when asked linked list questions as a part of interviews
  • Tackle a wide variety of general pointer and string problems and know how to answer questions on them during interviews
  • Tackle a wide variety of general programming problems which involve just plain logic, no standard algorithms or data structures, these help you get the details right

Topics covered in this course

• Section 1: Introduction
  	Lecture 1	Introduction	01:46
  	Lecture 2	Coding interviews are tough - but beatable	18:59
  Section 2: Pointer and Arrays
  	Lecture 3	Introduction to pointers	20:00
  	Lecture 4	Pointer problems and arrays	16:30
  	Lecture 5	Pointer arithmetic	13:04
  	Lecture 6	Practice makes perfect - pointer problems	09:23
  Section 3: Strings are just pointers at heart
  	Lecture 7	Working with strings	17:46
  	Lecture 8	Pointer as arguments to functions	10:48
  	Lecture 9	Practice makes perfect - string problems	20:00
  Section 4: Linked lists can be fun!
  	Lecture 10	Pointers to pointers - bend your mind	12:04
  	Lecture 11	Pointers to pointers - reassignment and modification	13:10
  	Lecture 12	Get started with linked lists	16:54
  	Lecture 13	Warming up - Linked List get Tricky Quickly -1	07:04
  	Lecture 14	Warming up to - Linked List get tricky Quickly -2	20:01
  	Lecture 15	Cruising along - linked lists are fun aren't they?	18:25
  	Lecture 16	Autopilot - linked lists are easy after all	18:25
  Section 5: Bit Manipulation
  	Lecture 17	Bit Manipulation - I	10:47
  	Lecture 18	Bit Manipulation - II	09:33
  	Lecture 19	Useful Bit Manipulation Techniques	13:34
  	Lecture 20	Get And Set The Nth Bit	13:43
  	Lecture 21	Print And Count Bits	19:47
  	Lecture 22	Reverse The Bits In An Integer	11:21
  Section 6: General programming problems - practice makes perfect
  	Lecture 23	Starting up - palindromes and points within a distance	19:27
  	Lecture 24	Play the Game Of Life	11:09
  	Lecture 25	Break A Document Into Chunks	10:49
  	Lecture 26	Run Length Encoding And Adding Numbers Digit By Digit	20:00
  	Lecture 27	Sudoku Board Validation and Incrementing A Number In Another Number System	20:00
  Section 7: Big-O Notation, Sorting And Searching Algorithms
  	Lecture 28	Performance and Complexity	15:56
  	Lecture 29	Big O Notation	18:09
  	Lecture 30	Big O Notation More Examples	18:16
  	Lecture 31	Sorting Trade-Offs	10:05
  	Lecture 32	Selection Sort	14:36
  	Lecture 33	Bubble Sort	14:43
  	Lecture 34	Insertion Sort	15:34
  	Lecture 35	Shell Sort	15:13
  	Lecture 36	Merge Sort	20:00
  	Lecture 37	Quick Sort	19:16
  	Lecture 38	Binary Search - search quickly through a sorted list	12:00
  Section 8: Recursion and the recursive sense
  	Lecture 39	What is recursion - why is it so hard?	17:50
  	Lecture 40	Binary search - implemented recursively	14:24
  	Lecture 41	Find all subsets of a set	16:43
  	Lecture 42	Check whether 2 binary trees are the same	16:32
  	Lecture 43	Implement paint fill to color a region on screen	13:42
  	Lecture 44	Build A car Given Tasks And Dependencies	15:54
  	Lecture 45	Generate Anagrams Of A Word	16:18
  	Lecture 46	Help A Rat Find It's Way Through a Maze	12:45
  	Lecture 47	Place 8 Queens On A Board Safely	19:48
  Section 9: Stacks And Queues
  	Lecture 48	Meet The Stack - Simple But Powerful	15:36
  	Lecture 49	Building A Stack Using Java	16:35
  	Lecture 50	Match Parenthesis To Check A Well Formed Expression	11:19
  	Lecture 51	Find The Minimum Element In A Stack In Constant Time	08:47
  	Lecture 52	Meet The Queue - A Familiar Sight In Everyday Life	13:16
  	Lecture 53	The Circular Queue - Tricky But Fast	19:59
  	Lecture 54	Build A Queue With Two Stacks	17:36
  Section 10: Binary Trees
  	Lecture 55	Meet The Binary Tree - A Hierarchical Data Structure	13:28
  	Lecture 56	Breadth First Traversal	17:23
  	Lecture 57	Depth First - Pre-OrderTraversal	14:43
  	Lecture 58	Depth First - In-Order and Post-Order Traversal	13:13
  Section 11: Binary Search Trees
  	Lecture 59	The Binary Search Tree - an introduction	09:25
  	Lecture 60	Insertion and Lookup in a Binary Search Tree	18:46
  Section 12: Binary Tree Problems
  	Lecture 61	Minimum Value, Maximum Depth And Mirror	13:02
  	Lecture 62	Count Trees, Print Range and Is BST	15:28
  	Lecture 63	Has Path Sum, Print Paths, Least Common Ancestor	16:43
  Section 13: Heaps
  	Lecture 64	The Heap Is Just The Best Way to Implement a Priority Queue	15:55
  	Lecture 65	Meet The Binary Heap - It's A Tree At Heart	12:24
  	Lecture 66	The Binary Heap - Logically A Tree Really An Array	18:02
  	Lecture 67	The Binary Heap - Making It Real With Code	07:42
  	Lecture 68	Heapify!	19:57
  	Lecture 69	Insert And Remove From A Heap	15:14
  Section 14: Revisiting Sorting - The Heap Sort
  	Lecture 70	Heap Sort Phase I - Heapify	19:56
  	Lecture 71	Heap Sort Phase II - The Actual Sort	19:56
  Section 15: Heap Problems
  	Lecture 72	Maximum Element In A Minimum Heap and K Largest Elements In A Stream	15:26
  	Lecture 73	Merge K Sorted Lists Into One Sorted List Using A Heap	13:09
  	Lecture 74	Find The Median In A Stream Of Elements	17:49
  Section 16: Graphs
  	Lecture 75	Introducing The Graph	14:08
  	Lecture 76	Types Of Graphs	07:58
  	Lecture 77	The Directed And Undirected Graph	14:02
  	Lecture 78	Representing A Graph In Code	09:37
  	Lecture 79	Graph Using An Adjacency Matrix	15:13
  	Lecture 80	Graph Using An Adjacency List And Adjacency Set	18:25
  	Lecture 81	Comparison Of Graph Representations	10:10
  	Lecture 82	Graph Traversal - Depth First And Breadth First	15:41

Who should buy this course?

• • New engineering graduate students who are interviewing for software engineering jobs
  • Professionals from other fields with some programming knowledge looking to change to a software role
  • Software professionals with several years of experience who want to brush up on core concepts
  • Other technology related professionals who are looking for a high level overview of pointer concepts can not buy this course.
  • This course requires some basic understanding of a programming language, preferably C. Some solutions are in Java, though Java is not a requirement