Break Away: Programming And Coding Interviews
Course Description
Programming interviews are like standard plays in professional sport – prepare accordingly. Don’t let Programming Interview gotchas get you down!
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’s Covered:
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.
Bit Manipulation: Work with bits and bit operations.
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
Data Structures: Understand queues, stacks, heaps, binary trees and graphs in detail along with common operations and their complexity. Includes code for every data structure along with solved interview problems based on these data structures.
Stepbystep 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.
Talk to us!
Mail us about anything – anything! – and we will always reply ðŸ™‚
What are the requirements?
This course requires some basic understanding of a programming language, preferably C. Some solutions are in Java, though Java is not a requirement
What am I going to get from this course?
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!
What is the target audience?
YEP! New engineering graduate students who are interviewing for software engineering jobs
YEP! Professionals from other fields with some programming knowledge looking to change to a software role
YEP! Software professionals with several years of experience who want to brush up on core concepts
NOPE! Other technology related professionals who are looking for a high level overview of pointer concepts.
Curriculum
Section 1: Introduction  

Lecture 1 
Coding interviews are tough – but beatable

17:11  
Section 2: Pointer and Arrays  
Lecture 2 
Introduction to pointers

19:59  
Lecture 3 
Pointer problems and arrays

13:35  
Lecture 4 
Pointer arithmetic

11:43  
Lecture 5 
Practice makes perfect – pointer problems

07:37  
Section 3: Strings are just pointers at heart  
Lecture 6 
Working with strings

14:07  
Lecture 7 
Pointer as arguments to functions

09:39  
Lecture 8 
Practice makes perfect – string problems

19:23  
Section 4: Linked lists can be fun!  
Lecture 9 
Pointers to pointers – bend your mind

10:28  
Lecture 10 
Pointers to pointers – reassignment and modification

11:12  
Lecture 11 
Get started with linked lists

17:16  
Lecture 12 
Warming up to – they get tricky quickly

16:19  
Lecture 13 
Cruising along – linked lists are fun aren’t they?

18:59  
Lecture 14 
Autopilot – linked lists are easy after all

16:31  
Lecture 15 
Do not overlook the doubly linked list

21:03  
Section 5: Bit Manipulation  
Lecture 16 
Bit Manipulation – I

10:07  
Lecture 17 
Bit Manipulation – II

08:39  
Lecture 18 
Useful Bit Manipulation Techniques

13:13  
Lecture 19 
Get And Set The Nth Bit

13:30  
Lecture 20 
Print And Count Bits

18:54  
Lecture 21 
Reverse The Bits In An Integer

10:10  
Section 6: General programming problems – practice makes perfect  
Lecture 22 
Starting up – palindromes and points within a distance

18:16  
Lecture 23 
Play the Game Of Life and Break A Document Into Chunks

18:33  
Lecture 24 
Run Length Encoding And Adding Numbers Digit By Digit

19:46  
Lecture 25 
Sudoku Board Validation and Incrementing A Number In Another Number System

19:55  
Section 7: BigO Notation, Sorting And Searching Algorithms  
Lecture 26 
Performance and Complexity

16:02  
Lecture 27 
Big O Notation

16:46  
Lecture 28 
Big O Notation More Examples

19:13  
Lecture 29 
Sorting TradeOffs

10:52  
Lecture 30 
Selection Sort

15:24  
Lecture 31 
Bubble Sort

14:42  
Lecture 32 
Insertion Sort

14:32  
Lecture 33 
Shell Sort

14:24  
Lecture 34 
Merge Sort

19:23  
Lecture 35 
Quick Sort

15:30  
Lecture 36 
Binary Search – search quickly through a sorted list

11:34  
Section 8: Recursion and the recursive sense  
Lecture 37 
What is recursion – why is it so hard?

17:33  
Lecture 38 
Binary search – implemented recursively

13:48  
Lecture 39 
Find all subsets of a set

15:24  
Lecture 40 
Check whether 2 binary trees are the same

15:33  
Lecture 41 
Implement paint fill to color a region on screen

11:42  
Lecture 42 
Build A car Given Tasks And Dependencies

15:07  
Lecture 43 
Generate Anagrams Of A Word

17:17  
Lecture 44 
Help A Rat Find It’s Way Through a Maze

13:01  
Lecture 45 
Place 8 Queens On A Board Safely

17:50  
Section 9: Stacks And Queues  
Lecture 46 
Meet The Stack – Simple But Powerful

15:40  
Lecture 47 
Building A Stack Using Java

16:53  
Lecture 48 
Match Parenthesis To Check A Well Formed Expression

11:21  
Lecture 49 
Find The Minimum Element In A Stack In Constant Time

08:51  
Lecture 50 
Meet The Queue – A Familiar Sight In Everyday Life

14:11  
Lecture 51 
The Circular Queue – Tricky But Fast

19:44  
Lecture 52 
Build A Queue With Two Stacks

17:30  
Section 10: Binary Trees  
Lecture 53 
Meet The Binary Tree – A Hierarchical Data Structure

13:03  
Lecture 54 
Breadth First Traversal

18:43  
Lecture 55 
Depth First – PreOrderTraversal

14:35  
Lecture 56 
Depth First – InOrder and PostOrder Traversal

13:51  
Section 11: Binary Search Trees  
Lecture 57 
The Binary Search Tree – an introduction

09:49  
Lecture 58 
Insertion and Lookup in a Binary Search Tree

17:00  
Section 12: Binary Tree Problems  
Lecture 59 
Minimum Value, Maximum Depth And Mirror

12:14  
Lecture 60 
Count Trees, Print Range and Is BST

14:39  
Lecture 61 
Has Path Sum, Print Paths, Least Common Ancestor

14:49  
Section 13: Heaps  
Lecture 62 
The Heap Is Just The Best Way to Implement a Priority Queue

17:15  
Lecture 63 
Meet The Binary Heap – It’s A Tree At Heart

12:39  
Lecture 64 
The Binary Heap – Logically A Tree Really An Array

17:13  
Lecture 65 
The Binary Heap – Making It Real With Code

07:38  
Lecture 66 
Heapify!

19:32  
Lecture 67 
Insert And Remove From A Heap

16:34  
Section 14: Revisiting Sorting – The Heap Sort  
Lecture 68 
Heap Sort Phase I – Heapify

19:31  
Lecture 69 
Heap Sort Phase II – The Actual Sort

17:42  
Section 15: Heap Problems  
Lecture 70 
Maximum Element In A Minimum Heap and K Largest Elements In A Stream

15:54  
Lecture 71 
Merge K Sorted Lists Into One Sorted List Using A Heap

11:40  
Lecture 72 
Find The Median In A Stream Of Elements

16:04  
Section 16: Graphs  
Lecture 73 
Introducing The Graph

15:40  
Lecture 74 
Types Of Graphs

07:21  
Lecture 75 
The Directed And Undirected Graph

14:29  
Lecture 76 
Representing A Graph In Code

08:09  
Lecture 77 
Graph Using An Adjacency Matrix

15:25  
Lecture 78 
Graph Using An Adjacency List And Adjacency Set

17:53  
Lecture 79 
Comparison Of Graph Representations

10:08  
Lecture 80 
Graph Traversal – Depth First And Breadth First

14:56  
Section 17: Graph Algorithms  
Lecture 81 
Topological Sort In A Graph

17:30  
Lecture 82 
Implementation Of Topological Sort

06:56  
Lecture 83 
Design A Course Schedule Considering Prereqs For Courses

13:01 
Instructor Biography
Loony Corn, A 4person team;exGoogle; Stanford, IIM Ahmedabad, IIT
Loonycorn is us, Janani Ravi, Vitthal Srinivasan, Swetha Kolalapudi and Navdeep Singh. Between the four of us, we have studied at Stanford, IIM Ahmedabad, the IITs and have spent years (decades, actually) working in tech, in the Bay Area, New York, Singapore and Bangalore.
Janani: 7 years at Google (New York, Singapore); Studied at Stanford; also worked at Flipkart and Microsoft
Vitthal: Also Google (Singapore) and studied at Stanford; Flipkart, Credit Suisse and INSEAD too
Swetha: Early Flipkart employee, IIM Ahmedabad and IIT Madras alum
Navdeep: longtime Flipkart employee too, and IIT Guwahati alum
We think we might have hit upon a neat way of teaching complicated tech courses in a funny, practical, engaging way, which is why we are so excited to be here on Udemy!
We hope you will try our offerings, and think you’ll like them ðŸ™‚
Course Features
 Lectures 0
 Quizzes 0
 Duration 50 hours
 Skill level All level
 Language English
 Students 1343
 Assessments Self