My BlogMy blog site.2026-04-21T00:00:00+00:00https://altariarite.github.io/posts/feed.xmlLeetcoding in Haskell2026-04-21T00:00:00+00:002026-04-21T00:00:00+00:00https://altariarite.github.io/posts/haskell-edu/<p>I like Haskell, but I feel like a fraud. That's because I haven't done
anything beyond <em>Introduction to functional programming</em>. But today that's going
to change!</p>
<p>I found 2 interesting second book on Haskell.</p>
<ul>
<li><em>Category Theory for Programmers</em>: hopefully I can finally understand Monad</li>
<li><em>Haskell High Performance Programming</em>: learning tricks and optimizations</li>
<li>Maybe also <em>Effective Haskell</em>?</li>
</ul>
<p>Also, I tried to attend programming contest with Haskell once. Wrote an O(n^3) solution
and failed miserably.</p>
<p>I am trying to pick that up again. Do some selective problems
on the <a rel="nofollow noreferrer external" href="https://cses.fi/problemset/list/">CSES Problem Set</a>, until I reach the
same level as I am writing Elixir or Python.</p>
<p>I also found <a rel="nofollow noreferrer external" href="https://www.youtube.com/watch?v=h_D4P-KRNKs&list=PLguYJK7ydFE4aS8fq4D6DqjF6qsysxTnx&index=1">Tsoding</a>
on youtube and learned how to get started. Recording some notes below:</p>
<h2 id="interact">interact<a class="zola-anchor" href="#interact" aria-label="Anchor link for: interact" style="visibility: hidden;"></a>
</h2>
<pre class="giallo z-code"><code data-lang="haskell"><span class="giallo-l"><span>ghci</span><span class="z-keyword">></span><span class="z-keyword"> :</span><span>t interact</span></span>
<span class="giallo-l"><span class="z-entity z-name">interact</span><span class="z-keyword"> ::</span><span> (</span><span class="z-storage z-type">String</span><span class="z-keyword"> -></span><span class="z-storage z-type"> String</span><span>)</span><span class="z-keyword"> -></span><span class="z-storage z-type"> IO</span><span class="z-support z-constant"> (</span><span class="z-support z-constant">)</span></span></code></pre>
<p>This is the single most important function IMO, because a big set back I have when
starting is: how can you do anything real with Haskell? Well <code>interact</code> lets you do
just that. Quoting the doc:</p>
<blockquote>
<p><code>interact f</code> takes the entire input from stdin and applies <code>f</code> to it.
The resulting string is written to the stdout device.</p>
</blockquote>
<p>This works nicely because you can then write a pure function <code>solve</code>, and
compose it with the I/O logic.</p>
<p>Let's look at an example taken from the CSES problem Missing Number:</p>
<pre class="giallo z-code"><code data-lang="plain"><span class="giallo-l"><span>You are given all numbers between 1,2,...,n except one.</span></span>
<span class="giallo-l"><span>Your task is to find the missing number.</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span>Input:</span></span>
<span class="giallo-l"><span>5</span></span>
<span class="giallo-l"><span>2 3 1 5</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span>Output:</span></span>
<span class="giallo-l"><span>4</span></span></code></pre>
<p>In this case the core logic really is a function <code>solve :: [Int] -> Int</code>. But we
still need to handle the I/O.</p>
<pre class="giallo z-code"><code data-lang="haskell"><span class="giallo-l"><span class="z-keyword">import</span><span class="z-entity z-name"> Data.List</span><span> (</span><span class="z-entity z-name">find</span><span>)</span></span>
<span class="giallo-l"><span class="z-keyword">import</span><span class="z-entity z-name"> Data.Maybe</span><span> (</span><span class="z-entity z-name">fromJust</span><span>)</span></span>
<span class="giallo-l"><span> </span></span>
<span class="giallo-l"><span class="z-entity z-name">solve</span><span class="z-keyword"> ::</span><span> [</span><span class="z-storage z-type">Int</span><span>]</span><span class="z-keyword"> -></span><span class="z-storage z-type"> Int</span></span>
<span class="giallo-l"><span>solve l </span><span class="z-keyword">=</span><span> fromJust </span><span class="z-keyword">$</span><span> find </span><span>(</span><span class="z-keyword">`</span><span class="z-keyword">notElem</span><span class="z-keyword">`</span><span> l</span><span>)</span><span> [</span><span class="z-constant">1</span><span class="z-keyword">..</span><span>]</span></span>
<span class="giallo-l"><span> </span></span>
<span class="giallo-l"><span>main </span><span class="z-keyword">=</span><span> interact </span><span class="z-keyword">$</span><span> show</span><span class="z-keyword">.</span><span>solve</span><span class="z-keyword">.</span><span>map read</span><span class="z-keyword">.</span><span>tail</span><span class="z-keyword">.</span><span>words</span></span></code></pre>
<p>Lets break down the <code>show.solve.map read.tail.words</code> bit.</p>
<h2 id="composing-functions">Composing functions<a class="zola-anchor" href="#composing-functions" aria-label="Anchor link for: composing-functions" style="visibility: hidden;"></a>
</h2>
<p>The <code>.</code> function is called pointfree programming for some
confusing reasons. I was really afraid to use it but hopefully the below can make
the usage clear.</p>
<pre class="giallo z-code"><code data-lang="haskell"><span class="giallo-l"><span>ghci</span><span class="z-keyword">></span><span> words </span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-constant">\n</span><span class="z-string">2 3 1 5</span><span class="z-constant">\n</span><span class="z-punctuation z-definition z-string">"</span></span>
<span class="giallo-l"><span>[</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">2</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">3</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">1</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-punctuation z-definition z-string">"</span><span>]</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span>ghci</span><span class="z-keyword">></span><span> tail </span><span>(</span><span>words </span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-constant">\n</span><span class="z-string">2 3 1 5</span><span class="z-constant">\n</span><span class="z-punctuation z-definition z-string">"</span><span>)</span></span>
<span class="giallo-l"><span>[</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">2</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">3</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">1</span><span class="z-punctuation z-definition z-string">"</span><span>,</span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-punctuation z-definition z-string">"</span><span>]</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span>ghci</span><span class="z-keyword">></span><span> map read </span><span>(</span><span>tail </span><span>(</span><span>words </span><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-constant">\n</span><span class="z-string">2 3 1 5</span><span class="z-constant">\n</span><span class="z-punctuation z-definition z-string">"</span><span>)</span><span>)</span><span class="z-keyword"> ::</span><span> [</span><span class="z-storage z-type">Int</span><span>]</span></span>
<span class="giallo-l"><span>[</span><span class="z-constant">2</span><span>,</span><span class="z-constant">3</span><span>,</span><span class="z-constant">1</span><span>,</span><span class="z-constant">5</span><span>]</span></span></code></pre>
<p>We want to get rid of all the parenthese. In Elixir (or bash) we would do something
like this:</p>
<pre class="giallo z-code"><code data-lang="elixir"><span class="giallo-l"><span class="z-punctuation z-definition z-string">"</span><span class="z-string">5</span><span class="z-constant">\n</span><span class="z-string">2 3 1 5</span><span class="z-constant">\n</span><span class="z-punctuation z-definition z-string">"</span></span>
<span class="giallo-l"><span class="z-keyword">|></span><span class="z-entity z-name"> words</span></span>
<span class="giallo-l"><span class="z-keyword">|></span><span class="z-entity z-name"> tail</span></span>
<span class="giallo-l"><span class="z-keyword">|></span><span class="z-entity z-name"> map</span><span> read</span></span>
<span class="giallo-l"><span class="z-keyword">|></span><span class="z-entity z-name"> solve</span></span>
<span class="giallo-l"><span class="z-keyword">|></span><span class="z-entity z-name"> show</span></span></code></pre>
<p>In Haskell we do it from right to left, hence <code>show.solve.map read.tail.words</code></p>