Grokking Algorithms: An illustrated guide for programmers and other curious people

Read Online and Download Ebook Grokking Algorithms: An illustrated guide for programmers and other curious people

Free Ebook Grokking Algorithms: An illustrated guide for programmers and other curious people

The method to get this book Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People is extremely simple. You could not go for some locations and spend the moment to just locate guide Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People In fact, you might not always get the book as you agree. However here, just by search and discover Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People, you could get the listings of guides that you truly expect. In some cases, there are numerous books that are showed. Those publications certainly will certainly astonish you as this Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People collection.

Grokking Algorithms: An illustrated guide for programmers and other curious people

Grokking Algorithms: An illustrated guide for programmers and other curious people


Grokking Algorithms: An illustrated guide for programmers and other curious people


Free Ebook Grokking Algorithms: An illustrated guide for programmers and other curious people

When someone concerns you to go to the collection and also obtain some books to review, exactly what's your reaction? Often, that's not the correct time to visit it. Yeah, lazy is the big reason of why many people choose to go to the library. You might also have no enough time to select. Currently, we present for you reserve soft data or internet book to read. Without mosting likely to the library, without spending time for mosting likely to guide stores, this type of publication is offered by online with net link in the beginning.

Numerous obligations in this current period need the book not only from the most recent publication, however additionally from the old book collections. Why not? We serve you all collections from the oldest to the latest books worldwide collections. So, it is extremely completed. When you feel that the book that you have is truly book that you want to check out now, it's so pleasured. But, we actually suggest you to read Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People for your personal necessity.

Now, we have to tell you little thing about the info related to the Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People When you actually have such certain time to prepare something or have the downtime to check out a publication select this. This is not just advised for you. This is additionally recommended for all individuals on the planet. So, when you really feel love in this book, quicker get it or you will certainly be left behind of others. This is just what we will certainly inform to you regarding the factor you should get it asap, just in this site.

When providing Grokking Algorithms: An Illustrated Guide For Programmers And Other Curious People as one of the collections of several books below, we think that it can be among the very best publications detailed. It will have lots of fans from all countries viewers. And specifically, this is it. You can really expose that this publication is exactly what we believed initially. Well currently, allow's seek for the other publication title if you have got this book review. You might discover it on the search column that we supply.

Grokking Algorithms: An illustrated guide for programmers and other curious people

Product details

Paperback: 256 pages

Publisher: Manning Publications; 1 edition (May 2016)

Language: English

ISBN-10: 1617292230

ISBN-13: 978-1617292231

Product Dimensions:

7.5 x 0.5 x 9.2 inches

Shipping Weight: 12.6 ounces (View shipping rates and policies)

Average Customer Review:

4.6 out of 5 stars

125 customer reviews

Amazon Best Sellers Rank:

#17,754 in Books (See Top 100 in Books)

This was a good attempt at something marvelous, unfortunately it is only that: an attempt; the book falls rather short. I dearly wanted to give a very positive review for this book as the premise of it was incredibly promising. I purchased it, and it sat on my bookshelf several months before I opened it beyond a quick peruse of a few pages. Those brief glances at the opening pages only added to my excitement about sitting down with the book later.However, once I actually did get the time to read this book cover to cover, I was immensely disappointed. The three stars given are primarily because the book starts off very strong; the coverage of binary search and the intro to Big-O provides precisely what was promised. Yet, these are only about the first 20 pages. After this beginning, the book becomes somewhat erratic, I cannot for the life of me understand why more of the sorting algorithms were not covered. The only sorts covered are quicksort and selection sort. There is a section titled 'Mergesort vs Quicksort' in which merge sort is only mentioned, not described or explained at all, and this is only a single paragraph; insertion sort gets only a sentence.The book's treatment of recursion is fantastic, but gets at my worst frustration with this book: the author discusses and thoroughly describes basic recursion, providing excellent illustrations of the call stack during execution and tracing the entire execution of a recursive function. At the end of this exercise, he mentions tail recursion (a critical aspect of recursion that more than merited the explanation, which would not have taken much more considering he’d already explained the call stack) and says it's beyond the scope of the book. However, the second half of the book is then dedicated to advanced topics like K-nearest neighbors (solid explanation) and just mentioning things that one would end up studying elsewhere on one's own. A whole chapter is dedicated to Dijkstra's Algorithm (again, solid coverage), which is a somewhat advanced algorithm that benefits from his illustrations and descriptions, but leaves to question, who made the decision to leave out a more complete description of recursion and thorough coverage of searches and sorts in lieu of what at the end seems like filler chapters? Anyone who is at the point of needing to understand those two algorithms likely won't read an illustrated book on the topic; to me, these topics supplant those someone intrigued by the idea of this book might've come seeking.There are errors, but they're no biggie. The very first piece of code in the book contains an omission that causes it to malfunction (setting of the variable 'mid' should divide the sum of 'high' and 'low' by 2). I came to realize it may have been due to a page layout or typesetting issue as I found the same problem in several chapters. It seems the edges of the code are partially covered by images. The coverage of Big-O beyond the intro chapter is a little weak, and only helped because I had some previous knowledge of the concepts surrounding it, and the fact that much of the explanation is repeated several times, so some bits finally sink in. I could see how someone coming to this book hoping to have 'aha' moments about algorithms would be left very lost.The author also uses the technique of describing how something works in a simple way and then a section later taking it all back and saying 'this is really how it works'. I've seen this before, and it can be effective, but a writer must take care the manner in which he simplifies the initial example. This happens rather confusingly in the explanation of hash tables (associative arrays) in relation to their performance. If you're following his description of them, its clear that him saying they return values 'instantly' is somewhat odd particularly when you understand what O(1) actually means. When he follows up to clarify, which he does by describing how hash tables can be slow in some cases, the clarification isn't really satisfying as you didn't really absorb the chapter wondering if perhaps you missed something before since hash tables were glowingly described as the data structure to end all data structures. He then goes into discussing (incompletely) the implementation of hash tables, which he keeps saying 'you'll never have to do'. He then trails off with a brief description of things to consider when using them without really implementing a hash table in code as suggested (examples 'using' hash tables are given, but the mention of 'implementing' them comes after this and indicates an upcoming example which never materializes).I wrote this review only as a warning. The implementation of the book is a solid 2 stars considering the price; the first half gets it to 3. The book is about 50% as described, 50% the author seemingly trying to prove he has a CS degree. Perhaps friends told him the book was too simplistic. Unfortunate. The heavy appearance of 5 star reviews here greatly misled me. Reading them afterward, it seems most are praising the idea of the book and not its actual execution. Had I read it during the return period, I would have returned it. I am a intermediate-level programmer. I understood most of these topics at a basic level beforehand. I ordered this book because I had been recommending it to others, who wanted to learn about algorithms from scratch, as the premise of it sounded excellent. I finally decided to read it myself since I've been raving about it for the last year; I wish I had read it first. It's a fun read, but don't expect any epiphanies. If you're a beginner, you're actually better off searching "basic sorting/searching algorithms" online and learning from YouTube videos until you can grasp the content of a college textbook (or one of the programming interview prep books which cover algorithms very thoroughly without the math of a university text). This book starts off great, but finishes more like a set of blog posts written over the course of a year, by a person who couldn't wait to prove to you how smart he was becoming day by day. I know many times a project can start off as one thing, and then after input by many people and via your own desires to do something great, lose its way; it seems that may have happened here with the author deciding that the basic algorithms were too mundane, and choosing to try and explain more impressive concepts which somewhat ironically, are ‘beyond the scope of this book’.

I've taken 2 undergraduate level courses on data structures and algorithms. I've written several programs that were assigned to me in order to demonstrate my mastery of the concepts explicated in this book, and yet I always felt I had a very superficial grasp of these ideas. Enough to pass a test; that is enough to reword the explanations or definitions provided to me in my course's official texts, but never enough truly grasp it.This book was incredible for me. But it if you've trudged through algorithms courses before and feel like you barely gleaned anything.

I'm not big on rating things, but I had to for this amazing book. This is by far the best introduction to algorithms out there, especially if you have not encountered them before. If you're a dev new to coding from some other field and lack a CS background, start here. If you are a VISUAL LEARNER, start here. If you like light, easy text to get acquainted with an idea, start here. If you want to learn the basics and learn them well, start here. After you read this book you'll be ready for the more dense ones.

Just my opinion - I thought it was a little too advanced for a "true" beginner (i.e. at 53 going back to school full time for CS after gulp 30 yrs). Might be best for those with a tad more recent schooling or experience. Having said that its well organized and well written. I suspect after my first semester and getting back into the "groove of things", it will suite my needs more than it currently does. I would also make a suggestion to the author to create a video/on-line course (i.e. udacity, lynda, etc).

This book takes a very stripped down, illustrated approach to introducing some basic algorithms and programming concepts. It's a broad, shallow dive, but is quick and easy to understand for what it covers, esp compared to going directly to the math or reading dense text. Good if you like illustrations & visual examples, and if you want only a cursory introduction to the concepts and examples of a few well-known useful algorithms. It sort of adopts the approach of the "Head First" series with little cartoons and hand-drawn examples & conceptual illustrations. It does seem a bit like class notes and is *too* simplified to really be of much practical use though.I'd say probably start here if you're totally new to the topic, and/or only want some bare-bones laymen's explanations.After this, look at Jay Wengrow's "Common Sense Guide to Data Structures and Algorithms" from Pragmatic Programmers, which is similar to this book, but walks through its examples and implementations in (a little) more depth.

Grokking Algorithms: An illustrated guide for programmers and other curious people PDF
Grokking Algorithms: An illustrated guide for programmers and other curious people EPub
Grokking Algorithms: An illustrated guide for programmers and other curious people Doc
Grokking Algorithms: An illustrated guide for programmers and other curious people iBooks
Grokking Algorithms: An illustrated guide for programmers and other curious people rtf
Grokking Algorithms: An illustrated guide for programmers and other curious people Mobipocket
Grokking Algorithms: An illustrated guide for programmers and other curious people Kindle

Grokking Algorithms: An illustrated guide for programmers and other curious people PDF

Grokking Algorithms: An illustrated guide for programmers and other curious people PDF

Grokking Algorithms: An illustrated guide for programmers and other curious people PDF
Grokking Algorithms: An illustrated guide for programmers and other curious people PDF

Grokking Algorithms: An illustrated guide for programmers and other curious people


Home