Keith Schwarz

It looks like this was written by Keith Schwarz: http://www.keithschwarz.com

> Remember Google infamously rejecting Max Howell, the original Homebrew author If Donald Knuth interviewed with Google, he would fail too because he would need 24 hours to solve a hard level leetcode question[1]. Unfortunately, Google loves throwing those kind of questions at interviewees and expect them to come up with solutions within 1 hour interview, lol. [1] - http://keithschwarz.com/interesting/code/?dir=find-duplicate

Also, take a look at http://www.keithschwarz.com/interesting/ It is an amazing archive of all kinds of neat algorithms and data structures.

A minor grumble, but the filenames are not intuitive at all to me... It makes finding what I'm looking for a bit difficult. alea.py clea.py dlea.py flea.py ilea.py lea.py olea.py plea.py tlea.py Also if anyone is interested in floating point weights, look at the alias method. Good tutorial here: http://www.keithschwarz.com/darts-dice-coins/ EDIT: User rawnlq beat me to mentioning the alias method. I second the recommendation.

There is a great article on engineering a whole bunch of increasingly good solutions the discrete random sampling problem. http://www.keithschwarz.com/darts-dice-coins/ And the corresponding HN discussion. https://news.ycombinator.com/item?id=3401510

Worth taking a look at: http://www.keithschwarz.com/interesting/

An excellent writeup on different techniques to do this: http://www.keithschwarz.com/darts-dice-coins/

That's the same guy that did the fantastic writeup of Dijkstra's Smoothsort: http://www.keithschwarz.com/smoothsort/

Coming up with algorithms on the spot isn't a viable strategy for technical interviews any more, even if you're a super-genius. Here's a question that the page author claims took Donald Knuth 24 hours to solve [1], which is classified on Leetcode as a Medium(!) difficulty question [2]. Leetcode Medium questions are typically the cut-off point for most FAANG-tier interview questions--and while this is a hard medium, I know someone who got a variation of it at a Meta interview, and was expected to solve it in 30 minutes. So unless you're 48 times faster at inferring algorithms than one of the best algorists in the world, memorizing tricks is the game you have to play if you want a FAANG-adjacent job! Of course, then the natural reaction is "if your hiring process would pass on Donald Knuth, your hiring process is broken," which is absolutely true, already known, and (apparently) deemed acceptable. [1] https://keithschwarz.com/interesting/code/?dir=find-duplicate [2] https://leetcode.com/problems/find-the-duplicate-number/

It depends a bit on exactly what you mean. But eg if you want to write a new hash table (with a new hash function), you'd want to do pretty similar-ish analysis to figure out whether it's a good idea. I used some neat math in my time to justify much simpler algorithms than what we were using before. (But not hash table related.) https://www.keithschwarz.com/darts-dice-coins/ is also a joy to read. (As mentioned in the discussion on https://news.ycombinator.com/item?id=8006336 ) Have a look at eg https://www.eecs.harvard.edu/~michaelm/postscripts/handbook2001.pdf for some more in this flavour.

The Suffix Array is surprisingly cool and useful https://en.wikipedia.org/wiki/Suffix_array The Alias Table for sampling a discrete distribution in O(1) time is a very clever idea https://www.keithschwarz.com/darts-dice-coins/

Maybe everyone's using this problem as their first screen: https://keithschwarz.com/interesting/code/?dir=find-duplicate

Keith Schwarz maintains an "Archive of interesting code" which has lots of C++ implementations: https://www.keithschwarz.com/interesting/

This can be generalized to having any distribution, simulating a die: http://www.keithschwarz.com/darts-dice-coins/

This is a bad idea. because one missing comma could screw up the program not mention which compilers they would likely run the program. That being said if you are comfortable with basics you can learn a lot from this book http://www.keithschwarz.com/coursereader.pdf

Btw, the instructor of this course has a very interesting side project exploring different data structures http://www.keithschwarz.com/interesting/

I remember while learning data structures and implementing them, I landed on http://www.keithschwarz.com/interesting/. It was enlightenment for me. By browsing through these examples I learned about good programming practices. Most importantly how commenting your code can help you even when you return after few years to fix something in it.

A lecturer at Stanford CS (Keith Schwarz) also has a good collection of various implementations of interesting algorithms: http://www.keithschwarz.com/interesting/

I was hoping to see an implementation the alias method [1] for sampling from discrete distributions! Nonetheless very cool. [1] http://en.wikipedia.org/wiki/Alias_method or http://www.keithschwarz.com/darts-dice-coins/

A few other good resources: Bit hacks: https://graphics.stanford.edu/~seander/bithacks.html Algorithm implementations: http://www.keithschwarz.com/interesting/

Euclid's Algorithm is certainly Algorithms 101, his discussion of it - far from it: http://www.keithschwarz.com/interesting/code/?dir=euclid

Some are interesting, but there's lots of mundane and generally boring stuff too, e.g. [1] [1] http://www.keithschwarz.com/interesting/code/?dir=argmax

Some source - with a lot of comments - that claims to implement the algorithm: http://www.keithschwarz.com/interesting/code/?dir=inplace-merge

University Of Washington CSEP501: Compiler Construction http://courses.cs.washington.edu/courses/csep501/ Keith Schwartz Stanford Compiler course CS143 http://www.keithschwarz.com/cs143/ Stanford's Engineering Compiler course on Lagunita https://lagunita.stanford.edu/courses/Engineering/Compilers/Fall2014/a… Matt Might's courses are self educational blueprints http://matt.might.net/teaching/compilers/ Book Introduction to Compilers and Language Design https://www3.nd.edu/~dthain/compilerbook/ I'm not a fan of uncurated link dumps, however: Awesome compilers link aggregation on Github https://github.com/aalhour/awesome-compilers

There's been a few flash runtimes in javascript and other languages. Most of them have been long abandoned. https://github.com/tobeytailor/gordon https://www.gnu.org/software/gnash/ In development: https://github.com/lightspark/lightspark https://github.com/ruffle-rs/ruffle And then the most recent one, CheerpX, which as I understand it runs the Adobe flash runtime itself via wasm: https://leaningtech.com/pages/cheerpxflash.html Which brings me to Java. Java left the browser even before flash did. Not all of these are javascript jvms, but all of them are intended to run Java applications in the browser (some are transpilers, others require code changes): https://leaningtech.com/pages/cheerpj.html https://github.com/java2script/java2script (this links to some less-complete projects) https://github.com/Jivings/jsJVM https://github.com/nurv/BicaVM https://github.com/st-js/st-js/ https://github.com/plasma-umass/doppio https://github.com/jtulach/bck2brwsr https://www.keithschwarz.com/+script/ https://github.com/robterrell/orto https://github.com/jdstroy/JavaPoly https://gitlab.com/neoexpert/jvm/-/blob/master/jsjvm/README.md