
Algorithms - rsandhu
https://www.khanacademy.org/computing/computer-science/algorithms/
======
tomwphillips
This is an excellent course and helped me get my current job.

My background is chemistry/chemical engineering. I had applied for a data
scientist position. Phone interview included a problem where I was asked about
my solution's complexity. I admitted I didn't know about it.

Still got called back for an interview on site, but the weekend before I
powered through this course. Unsurprisingly, it came up in the on-site and
they were really pleased I had learnt about it. I got the job.

I also found it useful to implement all the algorithms in Python.

~~~
michaelchisari
Python is the algorithm king as far as I'm concerned. It really gets out of
your way and lets you focus on the abstract nature of what you're trying to
accomplish.

~~~
koolba
If Python is the king, C is the court jester juggling knives.

Done well it looks amazing, elegant, and efficient, but in the wrong hands
you'll lose your hands.

~~~
apl002
Where is javascript in this medieval court?

~~~
dsacco
JavaScript is the archbishop, evangelizing the holy trinity of React, Node.js
and MongoDB.

~~~
joatmon-snoo
I think you meant React, Node, Vue, Vanilla, Backbone, Angular, [trails off]

~~~
dylz
Top 1000 javascript libraries of 2016: a year-end roundup

~~~
irrational
They change often enough that it would be better to create the list on a
monthly basis.

------
hal9000xp
It's strange they didn't cover dynamic programming at all. IMO every course
should include at least one classical example of dynamic programming. For
example:

[https://en.wikipedia.org/wiki/Longest_increasing_subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence)

[https://en.wikipedia.org/wiki/Longest_common_subsequence_pro...](https://en.wikipedia.org/wiki/Longest_common_subsequence_problem)

~~~
wopwopwop
I'd never heard of the expression "dynamic programming".

[https://en.wikipedia.org/wiki/Dynamic_programming](https://en.wikipedia.org/wiki/Dynamic_programming)

Am I to understand that it is "just" recursion with caching?

~~~
hal9000xp
People often make such conclusions about dynamic programming that it's just
caching (including myself several years ago).

I do recommend you to read this chapter:

[https://people.eecs.berkeley.edu/~vazirani/algorithms/chap6....](https://people.eecs.berkeley.edu/~vazirani/algorithms/chap6.pdf)

After reading this chapter, you can try to understand why Dijkstra and Floyd-
Warshall shortest path in graph algorithms work.

These classical and fundamental algorithms combine graph theory with dynamic
programming.

~~~
wopwopwop
Thank you for the reference.

------
SEJeff
For anyone wanting to learn algorithms from one of the other heavyweights, not
being a C developer, I found this series extremely beneficial:

[https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-
Str...](https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-
Structures/dp/0201314525)

It also helps that Robert Sedgewick has been in compsci forever (got hit PHC
in 1975) and is one of the subject matter experts in algorithms.

~~~
rajathagasthya
Or the newer book with Java code.

[https://www.amazon.com/Algorithms-4th-Robert-
Sedgewick/dp/03...](https://www.amazon.com/Algorithms-4th-Robert-
Sedgewick/dp/032157351X/ref=sr_1_1?ie=UTF8&qid=1487182924&sr=8-1&keywords=algorithms+robert+sedgewick)

Robert Sedgewick also has fantastic algorithms courses on Coursera.

~~~
MaxLeiter
My Data Structures & Algorithms class uses this book - it's fantastic. One
nitpick is the "EASYQUESTION" sorting visualizations in the book; they aren't
too easy to quickly understand (why use letters instead of numbers
demonstrating sorting algorithms or trees?

------
b3b0p
The Coursera Stanford [0] and Princeton [1] courses start again soon, February
20 to be exact. Not sure which one is better, but to refresh my atrophied CS
skills of 10 years I've joined the Stanford course. Not sure how it compares
to the Khan Algorithms course. Anyone have any feedback?

[0] [https://www.coursera.org/learn/algorithm-design-
analysis/](https://www.coursera.org/learn/algorithm-design-analysis/)

[1] [https://www.coursera.org/learn/algorithms-
part1/](https://www.coursera.org/learn/algorithms-part1/)

~~~
imakecomments
This is just my opinion and I'm sure it differs from others...

Roughgarden's class is advance and expects mathematical maturity. You may find
his course quite fast and rough if you are a beginner.

Sedgwick's class is much easier. He is a bit boring and tries to use "real
life" examples (in some instances) from the physical sciences to make the
material relatable. This in my opinion detracts from the material. Also, he
doesn't always fully explain where he got some of the big ohs here and there.

My advice? Follow MIT's OCW course (it uses CLRS). Supplement it with
Algorithms Unlocked, the Khan Academy link in OP and CLRS. If you use those 4
resources and put in the work you'll understand the material.

All 4 sources have Thomas C's DNA touch to it (he is the C in CLRS). So you'll
find it consistent when you read from one source to the other. After
reading/hearing the same thing about 4 different times in 4 different ways
it'll begin to click.

Order of easiness is probably Khan Academy > Algorithms Unlocked > MIT
Algorithms Course > CLRS.

Algorithms Unlocked is like "pre-CLRS" and Khan Academy's version is the TL;DR
version of Algorithms Unlocked.

Hope this helps.

Below are the links,

[https://www.amazon.com/Algorithms-Unlocked-Press-Thomas-
Corm...](https://www.amazon.com/Algorithms-Unlocked-Press-Thomas-
Cormen/dp/0262518805)

[https://www.amazon.com/Introduction-Algorithms-3rd-MIT-
Press...](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-
Press/dp/0262033844/ref=pd_sbs_14_img_0?_encoding=UTF8&psc=1&refRID=AYGC508DGP6YSYKSA759)

[https://www.khanacademy.org/computing/computer-
science/algor...](https://www.khanacademy.org/computing/computer-
science/algorithms)

[https://ocw.mit.edu/courses/electrical-engineering-and-
compu...](https://ocw.mit.edu/courses/electrical-engineering-and-computer-
science/6-046j-introduction-to-algorithms-sma-5503-fall-2005/video-lectures/)

~~~
b3b0p
Great feedback and insight. Appreciated. I'll checkout the MIT OCW and Khan
Academy first. I'm hardly a beginner, but my skills feel a bit rusty and want
to refresh them.

~~~
imakecomments
No problem.

------
imakecomments
As a follow up to this resource I recommend,

Algorithms unlocked: [https://www.amazon.com/Algorithms-Unlocked-Press-Thomas-
Corm...](https://www.amazon.com/Algorithms-Unlocked-Press-Thomas-
Cormen/dp/0262518805)

CLRS: [https://www.amazon.com/Introduction-Algorithms-3rd-MIT-
Press...](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-
Press/dp/0262033844/ref=pd_sbs_14_img_0?_encoding=UTF8&psc=1&refRID=8N4X7T2JSRBSJYSVSBCM)

Both include the same author as the one in this article (Thomas Cormen).

------
vga805
Another great resource I highly recommend:
[https://www.manning.com/books/grokking-
algorithms](https://www.manning.com/books/grokking-algorithms)

~~~
bogomipz
I didn't care for this book. I found though the use "doodle drawings" for
visualization to be hard to look at and distracting. The book felt half-
finished to me. For instance how does an algorithms book not include anything
on trees?

I think a much better and free alternative is:

[http://interactivepython.org/runestone/static/pythonds/index...](http://interactivepython.org/runestone/static/pythonds/index.html)

~~~
rapfaria
About the alternative, you can learn about algorithms but be prepared to not
learn them in a pythonic way.

~~~
bogomipz
I'm not sure I would say the book is "un-pythonic", but rather the book
intentionally avoids overly language specific idioms in order to reduce
algorithms to their most basic form. Once you have the basic knowledge its
trivial to implement them in any language you want, using those language
specific idioms - swaps without a temp variable or list comprehensions etc. It
is not a "Python book" per se it is an algorithms book that uses Python to
teach. I've seen many Algorithm book that use Java use a stripped-down back to
basics procedural style as well I think for the same reason. The book also
incorporate code lens and Python Tutor so you can step through your stack
frames and pause execution. This is a wonderful teaching aide, especially for
things like recursion.

[http://www.pythontutor.com/](http://www.pythontutor.com/)

------
Apocryphon
The Algorithm Design Manual by Skiena is pretty great.

[https://www.amazon.com/Algorithm-Design-Manual-Steven-
Skiena...](https://www.amazon.com/Algorithm-Design-Manual-Steven-
Skiena/dp/1848000693/ref=sr_1_1?ie=UTF8&qid=1487232535&sr=8-1)

It's nearly a third of the length of CLRS, and half of Sedgwick. Much more
precise, yet offers more in that it talks about common problem solving uses
cases with data structures and algorithms, rather than writing going through
the theoretical proofs behind them.

~~~
chillaxdude
I really love the war problems.

------
bhu1st
Here is Princeton's Algorithm text I've found useful (The code is in JAVA
though):
[http://algs4.cs.princeton.edu/home/](http://algs4.cs.princeton.edu/home/)

Pair this up with this excellent lecture by the authors Sedgewick and Wayne:
[https://www.coursera.org/learn/algorithms-
part1/home/welcome](https://www.coursera.org/learn/algorithms-
part1/home/welcome)

------
ofek
Somewhat germane,
[https://github.com/patmorin/ods](https://github.com/patmorin/ods) is a great
resource for data structures.

------
awesomepantsm
Talked to someone who wanted to work at one of the big megacorps as a software
engineer, asked for advice to pass the interview. I asked them if they could
implement quicksort. They said maybe, but they didn't really want to study
algorithms. I guess they really didn't want the job after all.

------
malloreon
If you have the KA app installed this link opens in it!

Which is great, except it takes you to the main list of subject matters, and
algorithms isn't in there.

So I'm not able to view this link on my iPad unless I uninstall KA?

~~~
lorenzhs
There should be a Safari action in the top right where usually you'd have the
battery indicator

------
fahimulhaq
We at educative.io re-published this course as a free course with
implementations in Java, C++ and Python (in addition to Javascript).

[https://www.educative.io/collection/10370001/760001](https://www.educative.io/collection/10370001/760001)

One of the authors - Professor Balkcom is our advisor as well.

------
j2kun
I understand that the focus on sorting is to have a simple application that
everyone can understand. But I can't seriously expect people to get that
excited about sorting. I sure didn't. It's not like we don't have tons of
other applications that demonstrate the same principles.

------
godmodus
I have to applaud the attempt.

And I'm kind of smirking right now, because again asymptotic got butchered.

I've spent the good part of this semester trying to get my head around a very
formal, very dense script of my own algorithms course. And I finally cracked
asymptotic. Maybe I'm just dense. But If that's the case, I'm sharing a
classroom with others who are equally dense.

We dealt with all 5 classes, big oh, small oh, theta, big omega and little
omega. We're required to always give the "most exact" classification for
best/avg/worst. Including "does not get as fast as" or "does not get as slow
as"

I'm willing to write a "freshman friendly" write up if someone's willing to
post it or use it. I'm shit at self publishing.

------
girzel
My high-school-age daughter is using Khan Academy to learn about logarithms
for her math class. She was telling me about it, and I thought "hmm, maybe I
should finally figure out what Big-O actually means". Now here we are! I guess
we'll both be on KA tonight.

------
koolba
It's hard to pick one thing to tell budding developers they have to learn but
Big-O notation is definitely up there.

The follow up to that is understanding what you're counting and why, i.e.
branches v.s. statements v.s. dereferences v.s. logical I/Os v.s. physical
I/Os ...

------
OJFord
Am I the only one to think that, for anyone capable of making it through the
course, the introduction is incredibly patronising?

Not just the everyday examples of what constitutes an algorithm, but the
voice, presentation, etc.

------
contravariant
Odd choice to start with the iterative factorial before moving on to the
recursive one. Usually it's the other way around, since the iterative
algorithm is faster and uses less memory.

~~~
mildbow
Recursive might be harder to grok to someone new because of the implied stack.

However, once you understand the iterative version, it's probably easier to
understand how the recursion is actually working.

------
bogomipz
I'm a big fan of Kahn and I like the addition of CS material to the site. I
hope they continue to add CS material.

------
uber1geek
So what are some good resources for Data Structures out there, you can vouch
for ?

------
evahop
Can anyone recommend an alternative introduction to asymptotic notation?

~~~
contravariant
Different in what way?

The general idea is that something takes O(f(n)) time if it takes _at most_
C·f(n) time for some constant C and all but finitely many values of n. The
'all but finitely many values' is what makes this definition 'asymptotic'.
Basically 'O(f(n))' ignores constant factors and the behaviour at 'small' n
(i.e. small inputs), the reasoning behind this is that an algorithm in O(f(n))
is faster than _any_ algorithm _not_ in O(f(n)) provided you make the input
big enough.

The little o, big Omega, big Theta are just small variations on this, which
won't be too hard to understand if you get the general concept, and really the
distinction isn't too important usually, just know that O(f(n)) gives _an_
upper bound, not necessarily the best possible upper bound. To understand the
big-O notation better it might help to have some basic knowledge of limits.

~~~
evahop
The information made intuitive sense to me. I just couldn't apply what was
read directly to the exercises. It felt as though something crucial had been
omitted. That something turns out to be calculus.

~~~
contravariant
You don't technically need calculus, but knowing about limits does help.

~~~
evahop
I appreciate the insight. For w/e reason this has been one of the more
difficult concepts to grasp.

------
ankurdhama
It is really sad that people still start the discussion about algorithms by
telling it as a sequence of actions or operations to accomplish a task. How to
go to airport is not an algorithm, how to cook food is not an algorithm.

~~~
ponco
While I agree "following instructions" !== "algorithm", it does serve as a
decent bit of context to people who are COMPLETELY unfamiliar with computing
let alone programming.

~~~
ankurdhama
It provides them incorrect context, if you really want to provide context then
start with long addition which everyone understands and tell them that it was
the first algorithm they learned. Physical activities are not algorithms,
algorithms are sequence of calculations on data and there are many many
examples that people know about that they learned in elementary mathematics
and that can serve as the proper context.

------
Kimalsi
as someone who doesn't know much about this and is trying to join the tech
community, what will I achieve through this?

~~~
lebanon_tn
Data structures and algorithms are foundational topics in computer science.
While they can seem daunting to beginning programmers, they become very
important as you progress into writing more advanced programs. Also, the
interview process for software engineers at most companies ask about them
almost exclusively.

~~~
throwaway2016a
> they become very important as you progress into writing more advanced
> programs

As someone with a Computer Science degree I can say that the only times I have
ever used any of the algorithms I learned directly was when writing low level
C and GoLang. I'm willing to bet 90% of programmers... even those that right
"advanced" programs do not use them day to day.

Every algorithm and data structure worth anything has been abstracted out into
easy to use libraries years ago.

~~~
stale2002
Of course! But how are you going to know WHICH library function to use if you
don't know what to look for in the first place?

Knowing that a problem at hand requires a certain solution is important.

~~~
throwaway2016a
You use the one labeled "sort" and trust the standard library chose reasonable
defaults. It's not like the standard lib is going to use bubble sort.

If the reasonable defaults aren't good enough... you're in the 10%.

~~~
stale2002
It is not about choosing "sort" it is about knowing if you need your data
sorted in the first place.

Sure, in some situations it might be obvious, but maybe not obvious for
others.

And things that are immediately, blindingly obvious to a 5 year experience
programmer may not be obvious to a newbie.

Ex: imagine if you didn't know what a hashtable or a dictionary was and just
used single variables for everything.

------
wopwopwop
Thanks for the link. However, it seems just a subset of Cormen et al.

------
bigdataanswers
why python???? ... any language with functions will do. I mean just create a
java class with all public static functions if you want it to work like python
(global functions). Its really language agnostic. Your answer will be a number
a string or a list of things. All languages can do that.

Im making an explicit opinion that python is no better than any other language
for implementing algorithms. HN please prove me wrong in an objective way so
we may all learn?

~~~
Godel_unicode
One thing that I like about Python implementations of algorithms is less
thinking about types. When I implement my sort algorithm, I just need to say >
or < and assume the caller has given those terms meaning.

Not a Java expert, can you do something similar with Java? Maybe with
generics?

~~~
jwdunne
I'm no expert but due to the language I think you need to specify types
somewhere. It just offloads it to your test code as opposed to the algorithms.

With python, your algorithm will work with the primitives without specifying
either in the algorithm or test code. You only need to specify type, i.e maybe
a new class and definitely instantiation, if you want to use something more
abstract.

This would be true of Ruby and other dynamically typed languages. For beginner
algorithms courses at least, a dynamically typed languages makes more sense
since the algorithms taught are only clouded by typing. Complexity theory
still applies and what not.

Maybe if learning algorithms that do heavy crunching, a lower level language,
probably with static types, may be used but by that point you're not going to
mind type info.

------
oferzelig
Unbelievable, a guy posts a link to some course and gets 458 HN upvotes (as of
this writing).

