Break Away: Programming And Coding Interviews

SGD 13 | 649
SGD 40

Loading the player...
Lectures
96
Language
English
Students
10
Reviews
5 (1)
Category
Development
Sub-Category
Programming Languages

15 days Money back Gurantee

Unlimited Access for 1 year

Android, iPhone and iPad Access

Certificate of Completion

Course Summary :

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.
  • 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.

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!

Pre-Requisites :

This course requires some basic understanding of a programming language, preferably C. Some solutions are in Java, though Java is not a requirement

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
      1 : Coding interviews are tough - but beatable17:11
      2 : Download for sec 1
    Section 2 - Pointer and Arrays
        3 : Introduction to pointers19:59
        4 : Pointer problems and arrays13:35
        5 : Pointer arithmetic11:43
        6 : Practice makes perfect - pointer problems07:37
        7 : Download for sec 2
      Section 3 - Strings are just pointers at heart
          8 : Working with strings14:07
          9 : Pointer as arguments to functions09:39
          10 : Practice makes perfect - string problems19:23
          11 : Download for sec 3
        Section 4 - Linked lists can be fun!
            12 : Pointers to pointers - bend your mind 10:28
            13 : Pointers to pointers - reassignment and modification11:12
            14 : Get started with linked lists17:16
            15 : Warming up to - they get tricky quickly16:19
            16 : Cruising along - linked lists are fun aren't they?18:59
            17 : Autopilot - linked lists are easy after all 16:31
            18 : Do not overlook the doubly linked list 21:04
            19 : Download for sec 4
          Section 5 - Bit Manipulation
              20 : Bit Manipulation - I10:07
              21 : Bit Manipulation - II08:39
              22 : Useful Bit Manipulation Techniques13:13
              23 : Get And Set The Nth Bit13:30
              24 : Print And Count Bits 18:54
              25 : Reverse The Bits In An Integer10:10
              26 : Download for sec 5
            Section 6 - General programming problems - practice makes perfect
                27 : Starting up - palindromes and points within a distance18:16
                28 : Play the Game Of Life and Break A Document Into Chunks18:33
                29 : Run Length Encoding And Adding Numbers Digit By Digit19:46
                30 : Sudoku Board Validation and Incrementing A Number In Another Number System19:55
                31 : Download for sec 6
              Section 7 - Big-O Notation, Sorting And Searching Algorithms
                  32 : Performance and Complexity16:02
                  33 : Big O Notation16:46
                  34 : Big O Notation More Examples19:13
                  35 : Sorting Trade-Offs10:52
                  36 : Selection Sort 15:24
                  37 : Bubble Sort14:42
                  38 : Insertion Sort14:32
                  39 : Shell Sort14:24
                  40 : Merge Sort19:23
                  41 : Quick Sort15:30
                  42 : Binary Search - search quickly through a sorted list11:34
                  43 : Download for sec 7
                Section 8 - Recursion and the recursive sense
                    44 : What is recursion - why is it so hard? 17:33
                    45 : Binary search - implemented recursively13:48
                    46 : Find all subsets of a set15:24
                    47 : Check whether 2 binary trees are the same15:33
                    48 : Implement paint fill to color a region on screen 11:42
                    49 : Build A car Given Tasks And Dependencies15:07
                    50 : Generate Anagrams Of A Word17:17
                    51 : Help A Rat Find It's Way Through a Maze13:01
                    52 : Place 8 Queens On A Board Safely17:50
                    53 : Download for sec 8
                  Section 9 - Stacks And Queues
                      54 : Meet The Stack - Simple But Powerful15:40
                      55 : Building A Stack Using Java16:53
                      56 : Match Parenthesis To Check A Well Formed Expression11:21
                      57 : Find The Minimum Element In A Stack In Constant Time08:51
                      58 : Meet The Queue - A Familiar Sight In Everyday Life14:11
                      59 : The Circular Queue - Tricky But Fast19:44
                      60 : Build A Queue With Two Stacks17:30
                      61 : Download for sec 9
                    Section 10 - Binary Trees
                        62 : Meet The Binary Tree - A Hierarchical Data Structure13:03
                        63 : Breadth First Traversal 18:43
                        64 : Depth First - Pre-OrderTraversal14:35
                        65 : Depth First - In-Order and Post-Order Traversal13:51
                        66 : Download for sec 10
                      Section 11 - Binary Search Trees
                          67 : The Binary Search Tree - an introduction09:49
                          68 : Insertion and Lookup in a Binary Search Tree17:00
                          69 : Download for sec 11
                        Section 12 - Binary Tree Problems
                            70 : Minimum Value, Maximum Depth And Mirror 12:14
                            71 : Count Trees, Print Range and Is BST14:39
                            72 : Has Path Sum, Print Paths, Least Common Ancestor14:49
                            73 : Download for sec 12
                          Section 13 - Heaps
                              74 : The Heap Is Just The Best Way to Implement a Priority Queue17:15
                              75 : Meet The Binary Heap - It's A Tree At Heart12:39
                              76 : The Binary Heap - Logically A Tree Really An Array17:13
                              77 : The Binary Heap - Making It Real With Code07:38
                              78 : Heapify!19:32
                              79 : Insert And Remove From A Heap16:34
                              80 : Download for sec 13
                            Section 14 - Revisiting Sorting - The Heap Sort
                                81 : Heap Sort Phase I - Heapify19:31
                                82 : Heap Sort Phase II - The Actual Sort17:42
                                83 : Download for sec 14
                              Section 15 - Heap Problems
                                  84 : Maximum Element In A Minimum Heap and K Largest Elements In A Stream15:54
                                  85 : Merge K Sorted Lists Into One Sorted List Using A Heap 11:40
                                  86 : Find The Median In A Stream Of Elements16:04
                                  87 : Download for sec 15
                                Section 16 - Graphs
                                    88 : Introducing The Graph15:40
                                    89 : Types Of Graphs07:21
                                    90 : The Directed And Undirected Graph 14:29
                                    91 : Representing A Graph In Code08:09
                                    92 : Graph Using An Adjacency Matrix 15:25
                                    93 : Graph Using An Adjacency List And Adjacency Set17:53
                                    94 : Comparison Of Graph Representations10:08
                                    95 : Graph Traversal - Depth First And Breadth First 14:56
                                    96 : Download for sec 16

                                Reviews

Instructor :

Loonycorn A 4-ppl team;ex-Google.

Biography

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 Unanth! We hope you will try our offerings, and think you'll like them :-)

Reviews

Average Rating
 (1 Reviews)

Image

shakti thakur

posted 3 month before

Best Course

I completed around 30% of course so far...the sample code and material provided are very good and helping in understanding the concept. The teaching style by loonycorn is great.