Funny, I go on a trip to Penghu followed by a four-day science camp
and also get dragged into drawing classes and some sort of movie
advising joint, and this is what I decide to blog about.
Since it’s summer, I went back to
Rankk and solved stuff. This is lots
of fun if you’re good with computers, plus a little math, cryptography,
and general puzzling. I’m still stuck on level 8… oh well. Since the
levels didn’t seem very indicative of difficulty to me, I decided to do
some analysis.
New challenges have been added to Rankk over time, so my metric of
difficulty is the number of solvers divided by the time from release to
now. Of course this is far from perfect; for example, a challenge’s
author doesn’t always seem consistently counted as a solver, problems
with lower numbers and problems that will help level up are more likely
to get checked out by new rankkers, and so on. But this is just for
fun.
“I have been told that any encryption becomes safer if the underlying
algorithm is maximally obscured, what is most conveniently done by
coding it in Haskell.” – rankk
Functional programming is terribly addicting! Partly I think the
completely different way of thinking makes it feel like learning
programming, and falling in love with it, all over again. Partly there’s
this evil sense of satisfaction from using $
s (and later
<$>
s and =<<
s and
&&&
s) to improve readability for initiated
Haskellers and worsen it for everybody else. Partly it’s because
Learn You a Haskell for Great
Good! is such a fun read — there are too many funny bits to list
but my favorite so far is when the author analyzes the first verse of
Avril Lavigne’s Girlfriend.
Although I think my code in Haskell tends to be more readable than in
other languages, code obfuscation in Haskell is almost natural: all you
have to do is refactor the wrong function to be “pointfree”, which means
that even though it’s a function that takes arguments, you define it
without parameters by manipulating and joining a bunch of other
functions. Example (plus a few other tiny obfuscations):
isPrime = liftA2 (&&) (liftA2 ($) (all . ((.) (0 /=)) . rem) (flip
takeWhile [2..] . (flip (.) $ liftA2 (*) id id) . (>=))) ((<) 1)
QQ wordpress why no Haskell highlighting (Editor’s note from
2017: The migration should highlight this now!)
Also, for some reason, you can do this in Haskell:
ghci> let 2 + 2 = 5 in 2 + 2
5
(via Haskell for the
Evil Genius)
Okay, but seriously now. I wrote this about my journey to learn
functional programming in the
programming babble post half a
year ago:
The main obstacle I have is that it’s hard to optimize or get
asymptotics when computation is expensive (a big problem if you’re
trying to learn through Project Euler problems, particularly ones with
lots of primes).
Okay I don’t actually know how this pointless rambling got so long. I
know the longer it is the more people will just tend to skim, because I
do that all the time. So I went back and refactored—er, rewrote all the
somewhat tangential bits (wow these puns are too easy) into footnotes.
Manually. Obviously if I have to do this again I’ll write a script for
it. But the post is still really long, and I bet nobody will read the
whole thing. Oh well.
Life updates: I got out of the hospital Friday two-and-a-half weeks
ago, went to the preliminaries of NPSC (a national team programming
contest) with classmates, threw up a lot, went back into the hospital,
and came out again. I wrote a lot of stuff about the experience and how
much it sucked (hint: a lot) when I started this draft around
that time, but now putting so much detail in this post feels weird. I’m
mostly good now.
Three years ago NPSC was the only programming contest I really knew
of; now I’ve participated in quite a few more, both online and locally,
but it’s still the only contest I’ve entered that gives you real-time
verdicts. I believe it inherits this from being modeled after ACM-ICPC,
but that’s for college people and I’m less clear on how it works. All
the other contests, namely
TopCoder,
CodeForces,
USACO, and the other local individual
competition (there doesn’t appear to be an English name so for the
purpose of this post I’ll just call it “Nameless Local”; there’s a
nation-wide competition in one-and-a-half weeks!), have system tests
after the contest that don’t allow you to resubmit afterwards. They all give pretests that you get
to know about right away, just to catch super-silly non-algorithmic
mistakes like failing to remove the debug statements or reading input
from the wrong place, but these contain weak test cases and don’t
guarantee that the solution will pass the system tests and get full
score.