Kids get infinite registers and no restrictions on stack ordering. Programmers are constrained to solving it with one register and restrictions on stack put operations.
./insert we-are-not-the-same-meme
It’s even called tower of Hanoi because of the Vietnam war flashbacks.
Before studying CS, I recognized it as ‘the bioware puzzle’. They were probably copying their own scribbles fron back then.
Haskell was the hardest, but it looked the most beautiful.
Haskell was the hardest, but it looked the most beautiful.
That pretty much sums that language up
In order to write a haskell program, you must first write the corresponding haskell program.
And in order to do that, you have to imagine sisyphus happy
Strange. I find the language hideous, most likely because it resembles math, or maybe because I’m already used to the C-like syntax.
Haskell is beautiful because it resembles math
It’s also beautiful because it doesn’t have C-like syntax.
Functional programming flips your brain around backwards, but shader programming will turn it inside-out.
For more brain flipping try looking into hardware description languages (Verilog) or proof assistants (Coq).
hanoi :: Integer -> a -> a -> a -> [(a, a)] hanoi 0 _ _ _ = [] hanoi n a b c = hanoi (n-1) a c b ++ [(a, b)] ++ hanoi (n-1) c b a
From here: https://www.rosettacode.org/wiki/Towers_of_Hanoi#Haskell
Edit: I understand it now. That first line is just a really weird way to define a function.
Welp, imma try myself at an explanation. Mostly cause I haven’t written Haskell in a while either.
So, that first line:
hanoi :: Integer -> a -> a -> a -> [(a, a)]
…actually only declares the function’s type.
In this case, it’s a function that takes an Integer and three values of a generic type
a
and then returns a list of tuples of those samea
s.
So, thosea
s are just any types representing the towers. Could be strings, integers, custom data types, whatever. The returned tuples represent movements between towers.Following that are actually two definitions of the function.
The first definition:
hanoi 0 _ _ _ = []
…is the recursion base case. Function definitions are applied, whenever they match, being evaluated top-to-bottom.
This line specifies that it only matches, if that first Integer is
0
. It does not care what the remaining parameters are, so matches them with a wildcard_
.
Well, and to the right side of the equals sign, you’ve got the return value for the base case, an empty list.Then comes the more interesting line, the recursion step:
hanoi n a b c = hanoi (n-1) a c b ++ [(a, b)] ++ hanoi (n-1) c b a
This line matches for any remaining case. Those small letter names are again wildcards, but the matched value is placed into a variable with the provided name.
And then, well, it recursively calls itself, and those
++
are list concations. This line’s only real complexity is the usual Tower Of Hanoi algorithm.
Oh but we don’t play it, we put lighting into rocks and trick them into doing it.
Towers of Hanoi? I don’t think so.
I took a test once where one of the questions was to solve the tower of hanoi with 2 pegs and 3 disks.
That’s just unfair
I was lucky enough to figure out that it was a trick question, but I second guessed every answer I put on tests and homework for that professor ever since.
How is that possible? is it has a different rule?
No, it was a trick question. The test taker was supposed to pick up on that.
Example for stack
Did you guys find this hard? There are only four possible ways to move a ring, two of which are disallowed by the rules. Out of the remaining two, one of them is simply undoing what you just did.