कीजिये तैयारी Programming & Coding Interviews की
4.7 (20 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,256 students enrolled
Wishlisted Wishlist

Please confirm that you want to add कीजिये तैयारी Programming & Coding Interviews की to your Wishlist.

Add to Wishlist

कीजिये तैयारी Programming & Coding Interviews की

A course that teaches pointers, linked lists, general programming, algorithms and recursion like no one else
4.7 (20 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
1,256 students enrolled
Created by Loony Corn
Last updated 3/2016
English
Current price: $10 Original price: $20 Discount: 50% off
1 day left at this price!
30-Day Money-Back Guarantee
Includes:
  • 20.5 hours on-demand video
  • 133 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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!
View Curriculum
Requirements
  • This course requires some basic understanding of a programming language, preferably C. Some solutions are in Java, though Java is not a requirement
Description

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


Using discussion forums

Please use the discussion forums on this course to engage with other students and to help each other out. Unfortunately, much as we would like to, it is not possible for us at Loonycorn to respond to individual questions from students:-(

We're super small and self-funded with only 2-3 people developing technical video content. Our mission is to make high-quality courses available at super low prices.

The only way to keep our prices this low is to *NOT offer additional technical support over email or in-person*. The truth is, direct support is hugely expensive and just does not scale.

We understand that this is not ideal and that a lot of students might benefit from this additional support. Hiring resources for additional support would make our offering much more expensive, thus defeating our original purpose.

It is a hard trade-off.

Thank you for your patience and understanding!


Who 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.
Students Who Viewed This Course Also Viewed
Curriculum For This Course
82 Lectures
20:28:16
+
Introduction
2 Lectures 20:45

Programming/Coding Interviews stand between you and your dream job. 

Preview 01:46

Coding interviews are nothing like software engineering jobs, they tend to be stressful and focus on the hardest parts of a software engineer's jobs. However, getting your core concepts right, with a lot of practice is the secret sauce to cracking the coding interview.
Preview 18:59
+
Pointer and Arrays
4 Lectures 58:57
Pointers are the foundation of all hard interview problems, visualizing memory layout using pointers helps us understand what's really happening under the covers.
Preview 20:00

Practice is the key to understanding key pointer concepts, solve pointer problems by visualizing the memory layout.

Arrays are pointers at heart, work with them exactly like you would with pointers.

Preview 16:30

Pointers know how much space the data they point to occupies. Which means you can access all elements of an array with a single pointer, pointer arithmetic is pretty cool!
Pointer arithmetic
13:04

A whole bunch of practice with pointer problems. These should be easy because you will have the memory layout right there to help you visualize things.
Practice makes perfect - pointer problems
09:23
+
Strings are just pointers at heart
3 Lectures 48:34

Strings are character pointers which are equivalent to character arrays. Solve functions from the string.h library for practice dealing with pointers.

Preview 17:46

Pointers as arguments to functions have subtleties which need to be understood to use them correctly. Understand reassignment and modifications of pointers in a function and see how the original pointers are affected in the calling code.
Pointer as arguments to functions
10:48

Let's solve some harder problems from the string.h library, remember the little details like string termination, null inputs all matter in an interview!
Practice makes perfect - string problems
20:00
+
Linked lists can be fun!
7 Lectures 01:46:03
Pointers just hold addresses of a memory location, which means we can have pointers to pointers to pointers. Sounds complicated? No worries, there are examples to help you understand these every step of the way.
Pointers to pointers - bend your mind
12:04

Pointers to pointers requires a heightened conceptualization of memory layout. See detailed visuals on how pointer modification and reassignment work. User defined types or structs can also have pointers to them, memory layout and visualization of struct pointers.
Pointers to pointers - reassignment and modification
13:10

Linked lists are favorite interview questions for software engineering roles. If you can work linked lists you're on your way to tackling more complicated problems. Understand the memory set up of linked lists and start with a few problems to gain confidence.

Get the length of a linked list, access the nth element in a list, and append an element to the end of the list - all this while handling null lists and other details.

Preview 16:54

For a simple concept, linked lists can get surprisingly tricky very quickly. Practice and practice again to gain mastery over linked list problems

Append an element to the end of the list - all this while handling null lists and other details.

Warming up - Linked List get Tricky Quickly -1
07:04

For a simple concept, linked lists can get surprisingly tricky very quickly. Practice and practice again to gain mastery over linked list problems.

Use the linked list as a stack and implement pop, delete all the elements in a list - tricky memory freeing here, insert an element at a specified position and in a sorted list - these are similar but the edge cases differ.

Preview 20:01

Once you've actually solved all the examples we've got so far, you'll find that linked lists are fun! This class has a particularly difficult sample problem which will introduce you to the fast and slow pointers which traverse a linked list at different speeds. Useful for a lot of tricky maneuvering.

Append one list to another and split a list into two by using fast and slow pointers. This second problem is much, much harder than it seems.

Cruising along - linked lists are fun aren't they?
18:25

By now you should be able to solve linked list problems in your sleep. Let's practice a few last ones to gain complete master over them.

Remove duplicates from a sorted list, move the first node from one list to another, merge two sorted lists and finally reverse a linked list.

Autopilot - linked lists are easy after all
18:25
+
Bit Manipulation
6 Lectures 01:18:45
We dig into the bitwise AND, OR and NOT operations - visually inspecting how they work.
Preview 10:47

We continue with bit manipulation - the right shift and left shift operators are very powerful, but they have 2 issues that you should be sure to understand: overflow, and fill.
Bit Manipulation - II
09:33

Before diving headlong into bit manipulation problems it's helpful to learn a few useful tricks which help you build a strong foundation to visualize working with bits.
Useful Bit Manipulation Techniques
13:34

Functions to get the nth bit of an integer and to set the nth bit of an integer. These are the building block functions and the concepts underlying these will be used for harder bit manipulation problems.

Get And Set The Nth Bit
13:43

Print all the bits used to represent an integer from the most significant bit to the least significant. Learn some subtle details about the shift right (>>) with negative numbers!

Count the number of 1s in an integer, and learn a neat trick which allows you to do it in complexity O(number of 1s).

Print And Count Bits
19:47

Reverse the bits in an integer. This pulls together a whole bunch of stuff from the last few problems. As in the case of hard problems, visualizing the process is key to solving this!
Reverse The Bits In An Integer
11:21
+
General programming problems - practice makes perfect
5 Lectures 01:21:25
During coding interviews you might encounter questions which you can work out from first principles. You should be nailing these! Let's start with figuring out whether a string is a palindrome and finding all the points within a certain distance from another point.
Preview 19:27

Play the game of life where every cell can change states from live to dead based on its neighbours.


Play the Game Of Life
11:09


Move on to breaking a document into chunks to send down to a client subject to very specific constraints.
Break A Document Into Chunks
10:49

Run length encoding involves specifying the number of times a character is repeated in a string. Decoding run-length-encoded strings can be pretty tricky, let's find a solution for both.

If a number were represented by its digits, can you write code to add 2 numbers represented in this way? Let's walk through a solution and see if you can get this right.

Run Length Encoding And Adding Numbers Digit By Digit
20:00

Write code to check whether a Sudoku board is valid. This should work for both complete and incomplete boards. Sudoku is tricky and this has many conditions to check.

Lastly set up your own numeric system and then increment a number represented in that system by 1.

Sudoku Board Validation and Incrementing A Number In Another Number System
20:00
+
Big-O Notation, Sorting And Searching Algorithms
11 Lectures 02:53:48

What is the performance of your code? How do you measure this? What is complexity and what is its relationship with performance?

Performance and Complexity
15:56

The Big O notation is used to express complexity based on the size of the input specified for any algorithm. How is Big O expressed, how is it calculated and many examples to drive the concepts home!
Preview 18:09

The Big O notation becomes much clearer when you practice find the complexity of some sample pieces of code. Let's see how many of these you get right!
Big O Notation More Examples
18:16

A sorting algorithm is not just defined by its complexity, there are a whole bunch of other characteristics which can be used to determine which sorting algorithm is the right one for a system. Let's understand what these characteristics are and what are the trade offs we might make.
Sorting Trade-Offs
10:05

The simplest and most naive sorting algorithm.
Preview 14:36

Closely allied with selection sort is bubble sort. Its an adaptive sort with the same time complexity as selection sort.
Preview 14:43

Insertion sort is an improvement over both bubble sort and selection sort. Let's see how exactly it works and why it's preferred in many cases.

Insertion Sort
15:34

Shell sort builds on top of insertion sort, it improves the complexity of it's running time by partitioning the list in a clever way.
Shell Sort
15:13

This belongs to a class of algorithms which uses divide and conquer to break the problem set into smaller pieces. This also makes a time-space trade off to get a faster running time.
Preview 20:00

Quick sort is the sort of choice for developers of programming libraries. Let's see what makes it so attractive.
Quick Sort
19:16

Binary search is a pretty nifty way to search through a sorted list in O(Log N) time. It's also an interview favorite so make sure you understand it well!
Binary Search - search quickly through a sorted list
12:00
+
Recursion and the recursive sense
9 Lectures 02:23:56
Recursion is pretty hard at the beginning. Let's look at an example of reversing a string and see how we can use recursion to solve the problem. Visualize the input and every step and see how the magic of recursion works.
What is recursion - why is it so hard?
17:50

  1. We've already seen and understood binary search. This is a perfect first problem to tackle using recursion. Make sure you try it yourself first before seeing the solutions in the class.
Preview 14:24

A classic problem which can be solved recursively. Try out a few smaller sets and see how their subsets look to find patterns.
Find all subsets of a set
16:43

Binary trees lend themselves to problems which have really beautiful recursive solutions. The problem may seem hard but the solutions end up being simple. Checking for whether 2 trees are the same is one such problem.

Check whether 2 binary trees are the same
16:32

Paint fill allows you to color regions on screen while using drawing software. Implement a recursive solution to paint fill a region on the display screen.
Implement paint fill to color a region on screen
13:42

Say you were given all the tasks needed to build a complete car. These tasks may depend on one another. Set up a data structure to represent a task and it's dependencies and write code to build a car.

Build A car Given Tasks And Dependencies
15:54

An anagram of a word is simply a word with the letters of the original word rearranged. This is complicated but lends itself well to a recursive solution.
Preview 16:18

There can be several paths out of a maze. Help a rat placed anywhere in maze to find it's way out.
Help A Rat Find It's Way Through a Maze
12:45

Another classic problem with an elegant recursive solution.
Place 8 Queens On A Board Safely
19:48
+
Stacks And Queues
7 Lectures 01:43:08
The stack is a very simple and easy to understand data structure. However it lies underneath many complicated real world problems and is incredibly useful.
Preview 15:36

Let's build a stack for real using Java. It'll have all the operations we're interested in - push, pop, peek, size etc. It can hold any data type, it's a generic class.
Preview 16:35

Problems which use stacks as a part of their solutions are very common in programming interviews. Matching parenthesis to check for well formed expressions is a classic interview question - let's solve this using the stack we're already implemented.
Match Parenthesis To Check A Well Formed Expression
11:19

Another interview question implemented. You have space available but your processing needs to be very fast indeed. How would you keep track of the minimum element of a stack as it changes?
Preview 08:47

The queue belongs to the same linear data structure family as the stack but it's behavior is very different. Queues are much more intuitive as there are plenty of real world examples where a queue is the fair and correct way of processing.
Meet The Queue - A Familiar Sight In Everyday Life
13:16

A common, fast but slightly tricky implementation of the queue is the array where the last element wraps around to the first. An interview favorite, let's see how to implement the circular queue.

The Circular Queue - Tricky But Fast
19:59

We know the stack, and we know the queue. This problem brings them together. It's possible to mimic the behavior of a queue using 2 stacks in the underlying implementation. Let's write the most efficient code possible to make this work.
Build A Queue With Two Stacks
17:36
+
Binary Trees
4 Lectures 58:47
The binary tree is an incredibly useful hierarchical data structure. Many other, more complex data structures, use the binary tree as the foundation. Let's see what a binary tree looks like and learn some simple terminology associated with the tree.
Meet The Binary Tree - A Hierarchical Data Structure
13:28

Traversing a binary tree can be done in variety of ways. The breadth first traversal visits and processes nodes at every level before moving on to the next. Let's visualize breadth first traversal and see how it's implemented.
Breadth First Traversal
17:23

Depth first traversal can be of 3 types based on the order in which the node is processed relative to it's left and right sub-trees. Pre-order traversal processes the node before processing the left and then the right sub trees.

Depth First - Pre-OrderTraversal
14:43

Depth first traversal can be of 3 types based on the order in which the node is processed relative to it's left and right sub-trees.

In-order traversal processes the left subtree, then the node itself and then it's right sub trees. Post-order traversal processes the node *after* it's left and right subtrees.

The algorithms are all remarkably similar and very easy once you use recursion.

Depth First - In-Order and Post-Order Traversal
13:13
6 More Sections
About the Instructor
Loony Corn
4.3 Average rating
4,195 Reviews
31,179 Students
75 Courses
An ex-Google, Stanford and Flipkart team

Loonycorn is us, Janani Ravi and Vitthal Srinivasan. Between us, we have studied at Stanford, been admitted to IIM Ahmedabad and have spent years  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

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 :-)