Customer Reviews

Cracking the Coding Interview, Fourth Edition: 150 Programming Interview Questions and Solutions

5 star:		(30)
4 star:		(7)
3 star:		(5)
2 star:		(1)
1 star:		(0)

 

 

My background: worked as a software developer for 5 years before changing companies and I needed to freshen up my interview skills. Having conducted dev interviews before, I wanted to be as prepared as possible.

I used this book as a practice guide for my interviews with Microsoft, Amazon, and Google. Got offered to two of the companies through practicing the questions in this book over and over again. I was only caught off guard by one or two questions during my interviews through at least 15 interview loops. Most of the interview questions at the above companies follow the same two dozen or so coding patterns and the questions in this book thoroughly covers them. Learn the coding patterns from this book and you won't be surprised or nervous during your loops. I tried not to act too surprised when 1/5 of the questions from my interviews were straight from the book.

If you are planning to appear for a technical interview at any big software-firm, I highly recommend studying this book.

When I started my preparation, the entire process seemed really daunting. There is so much to study, and there is vast amount of study-material available out there. I was really confused on what/how to prepare. A friend of mine suggested me this book and so I read it.

To summarize, this book is an awesome compilation of problems, strategies and approaches you must know for doing well in a Tech interview.

It starts with chapters focusing on non-coding aspects (company-info, resume, behavioral etc.). I feel that, thoroughly covering just these first 30 pages is suffice for doing well in the 'HR' parts of tech-interviews.

After that, it contains 150 questions grouped by categories, covering all the relevant areas. And finally it has useful information, solutions and discussions for all the questions.

Qu. "If I memorize solutions for all these questions, Can I crack an Interview?" Ans. No Way!
Rather, if you slog through these questions, learning techniques; I am sure you will be able to solve questions on that day.

Solving problems through the book, I learnt different [ingenious] approaches. And with practice, I was be able to [/tried to] identify patterns in new questions that I faced.

I particularly love 3 chapters- "Recursion", "Moderate Interview Problems", "Hard Interview Problems". Because they contain some really neat algorithms :)

Hope this review helps.. And all the best for your interview :)

I'm a software engineer at a billion-dollar company, with about 10 years of experience after college. I decided to interview at a promising early-stage startup and thus bought two interview books (this one and Programming Interview Exposed) to brush up on things and get back that interviewing magic. (I had been at my last job for over 5 years, so it has been a while.)

This book is good in some ways. The best thing about it is the set of problems in it. It's quite comprehensive: every area I could think of is covered. Even the knowledge-based chapters (e.g., on threading, or networking, or low-level programming) are surprisingly up-to-date and representative of the type of stuff that is asked. So if you want to get a big list of problems and at least a good stab at the solutions (if you're stuck), it's much better to get this book (as opposed to looking for problems on the Internet).

So why only two stars? The biggest issue is that there are tons of errors in this book. I can't tell you how many, but I know I personally found at least 5. Some are trivial -- the book may say something is O(n) space, when it's O(1) space. Some are egregious -- the smart pointer implementation, which is compressed to one page in the solution section, is utterly broken. (For example, operator=() fails to give up ownership of what it points to before the assignment, before taking ownership of the new object. That is a completely wrong solution to the problem! What if an inexperienced reader reads this section and becomes confused?) Books like this should not have mistakes, especially not a 4th edition.

Sometimes the problem isn't clearly stated, so that trying to solve it is very difficult without more explanation. Flipping to the solution reveals what the problem was, but then what was the point?

In general, when reading this book, once gets the sense that it was thrown together. It seems like it wasn't edited in the most basic ways; for example, URLs are referred to as "urls" all over the text. That doesn't really matter, of course, but it is indicative of the type of publication it is. It's like someone wrote up an elaborate text file and then basically just sent it off to be published. Very cheap and kind of unprofessional.

Finally, the book's solutions (while usually 100% correct) typically don't try to explain and expose the thinking process behind a solution. True, sometimes it's quite obvious, so there's no point. But sometimes, it's not obvious -- it would be helpful to a potential interviewee to get a glimpse into HOW to get to the solution, instead of basically just being given the solution. This isn't always the case in the book, but most of the time it is.

So, there you go. If you want a nice collection of problems that's representative and up-to-date, this is your book; but don't expect an error-free and carefully edited or explained work.

"Cracking the coding interview" (4th ed, 2008) by Gayle Laakman is a
good book, but so is the very similar book "Programming Interviews
Exposed: Secrets to Landing Your Next Job" (2nd edn), John Mongan,
Noah Suojanen and Eric Giguère (2nd edn, 2007) . Which should you
choose? Here are the main differences:

- "Exposed" is much more readable: it explains the solutions in
English before giving code, whereas "Cracking" often just presents
code with minimal explanation. Another nice thing is that "Exposed"
presents the solution in stages, so you can read the first part of the
solution to get a hint, and then try again. By contrast, "Cracking"
just gives the key idea right away, so even a "peek" at the solutions
means it's game over (modulo coding issues, which are usually easy).

- "Cracking" has more questions, and they generally seem to be a bit
harder. They are sorted in order of increasing difficulty, which is
helpful.

- "Cracking" gives solutions in Java, although the code seems to have
some errors (see other reviews on amazon). "Exposed" gives solutions
in a mix of languages (C++, Java, C#), although they only use one
language per question.

- "Cracking" contains some grammatical errors (for example, Gayle
often mixes up "eg" and "ie"). In addition, many explanations would be much clearer with
an example.

- Both books are similar in length (about 300 pages), and their "non
technical" advice is very similar.

- Overall, "Exposed" is easier to read, but "Cracking" has more
content. Tough call.

There is also the good book "Algorithms For Interviews" by Adnan Aziz
and Amit Prakash (2010), which contains much harder questions,
focusing on clever algorithms and not on implementation details. Do
not attempt this book before mastering "Cracking" and/or "Exposed",
you will find it demoralizing! But it's probably worth trying some of
these harder problems, to see how "fancier" algorithms (like Dijkstra,
or max-flow min-cut, or dynamic programming) can be applied in
creative ways.

Getting into one of the top companies in the software industry, is not normally an easy task. There are certain things they're looking for and if you don't know what they are and how to prepare, you'll most likely get the dreaded "Thank You" email or phone call.

This book will prepare you for what to expect from companies like Microsoft, Google, Amazon, Yahoo and Apple. Then it will give you the tools to solve the problems that they will throw at you during an interview. Follow the instructions, and you'll have a chance to stay in the hunt. Try to memorize answers and you'll be eaten alive.

Get a whiteboard, practice the problems without looking at the answers until you're done. Don't use your IDE to help you and learn to think through problems without knowing the answer in advance.

This book helped me get into Microsoft.

Good luck!

In general this is a good book to cover technical interview questions and some very useful tips for how to prepare and act for the on-site interview on technical questions. However, there are still several obvious errors in the books, especially codes and some formulas. For example,

in page 47 Question: What is the running time of this code?
The two sample codes are exactly the same and the first one should be something not using StringBuffer().

And in page 258, in the middle paragraph
Time_Stamp(P2_1) - Time_Stamp(P2_N)
should be
Time_Stamp(P2_1) - Time_Stamp(P1_N)

Hope this error can be identified by readers and they can still get the job.

This is a great book regardless you plan to go for an interview or not. Every chapter of the book starts with basic theory which will allow the reader to wake up the brain before going for the questions. Each chapter has great interview questions and answers are very well explained. Not only that some questions are given with two answers where the second answer is optimized version of the code. Also first chapter of this book has very good information about the nature of the big software companies such as Amazon, Google, Microsoft. I highly recommend this book regardless you prepare for an interview or not. Cracking the Coding Interview, Fourth Edition: 150 Programming Interview Questions and Solutions

I recently checked this book out from the library (sorry, Gayle) to get a look at what kind of questions get asked in interviews. ''Cracking'' covers a wide range of problems and generally gives pretty nice solutions. If you read this book and get comfortable with the material that it contains, it should make you feel a lot more confident about getting grilled at your next interview. My main complaint is with the number of mistakes:

* Some of the algorithms are wrong. For instance, problem 5.1 asks you to clear a range of bits and then write a new value there, but it fails to clear the topmost bit. Problem 5.3 asks for the next smallest number that contains the same number of 1's as the input, but goes into an infinite loop if none exists (say, for an input of 1). There are many others.

* Some of the code is obtuse. Problem 4.5 wants the in-order successor of a given node in a binary tree. The solution starts
if (e.parent == null || e.right != null) { p = leftMostChild(e.right); }
Why should one try to find the leftmost (or leftMost) child of a null pointer? Well, it turns out to be harmless, because the code as written returns null and returning null is the right thing to do in this situation. But it certainly fails the test of "say what you mean."

* 4.5 exhibits another common problem, namely that the explanatory comments seem at variance with the following code. Another example is right next door in 4.4, where it says "We thus use a dummy node to indicate when we have finished one level and are starting on the next," while the code does no such thing. It looks as though at some point, the code was updated and the comments were not!

* Other comments are incomplete and inaccurate. Problem 2.5 (finding a loop in a linked list) has the right answer, but the explanation is only correct if k < n (i.e., the non-looping initial segment is shorter than the loop). The solution itself is Floyd's algorithm, and this is just presented as a rabbit pulled out of a hat. It would have been nice to mention Brent's algorithm as well, especially since that is somewhat less "magical."

All in all, I found the book helpful in setting a good variety of problems and encouraging me to whip up working code to solve them. I felt nimbler in my thinking and coding as a result and learned a few tricks along the way. But I was disappointed at the slipshod approach to quality, especially in a 4th edition.

Even rock star coders need to prepare for coding interviews, and this book is THE way to do that. The author has interviewed with virtually every tech company out there, worked for what are (in my opinion) the three coolest tech companies (Google, Microsoft and Apple), and spent three years as an interviewer for Google. According to her bio, she interviewed for 120 people at Google alone!

The book covers every aspect of the interview process: creating a good resume, preparing for both behavioral and technical questions, coming up with good algorithms during the interviews, how to write good interview code, mistakes to avoid, etc. The advice is very concrete, applicable and useful. I can definitely say that it made a huge difference in my interview process (and my subsequent job offers).

In addition to all that stuff, the book offers 150 programming interview questions (and answers), from the most common basic questions, to advanced algorithm questions. And, though I don't encourage trying to memorize interview questions, I have actually been asked several of these questions while interviewing with Microsoft, Google, Amazon, Facebook, etc.

Regardless of how much interviewing experience you have, this book will make you perform substantially better. I found myself more easily able to think through problems, and less likely to make mistakes.

I would recommend that any interviewee prep with this book.

Though I personally have mixed feelings on the value of so-called "coding interviews," the harsh reality is that all the top companies ask programmers to code on the spot. If you're a software engineer, you're almost sure to face this type of interview - and this book is basically required reading for it. DO NOT walk into one of those interviews without reading this book first.