elixirgolf.comJekyll2016-05-12T11:43:49+01:00/elixirgolf/elixirgolf@emson.co.uk/articles/elixir-palindrome-detector2016-03-18T00:00:00+00:002016-03-18T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>A palindrome is a sequence of characters which can be read forwards or backwards.<br />
For example a good word palindrome might be:</p>
<p>“<strong><em>level</em></strong>”</p>
<p>or for a sentence palindrome, you could have:</p>
<p>“<strong><em>was it a car or a cat i saw</em></strong>”</p>
<p>Your job is to write Elixir code that takes a string from the standard input and
outputs a <code>true</code> / <code>false</code> value indicating whether that string is a palindrome
or not.</p>
<p>Code will be run from <code>iex</code>, when your code is executed it will prompt for user
input and on <code>return</code> will output a <code>true</code> or <code>false</code> value.</p>
<div class="highlight"><pre><code class="language-text" data-lang="text">iex> --enter your code here--
level
true</code></pre></div>
<h3 id="rules">Rules</h3>
<ul>
<li>Punctuation and whitespace is allowed in the input string of characters, however your program should ignore
it, and should not affect whether the string is a palindrome or not.</li>
<li>Numbers are valid palindrome characters.</li>
<li>The case of the input string should not affect palindrome determination.
Therefore “<strong><em>Taco cat</em></strong>” is purrfectly valid.</li>
<li>There is no limit on the length of the input string.</li>
<li>Only use the ASCII character set.</li>
</ul>
<h3 id="submit-your-solution">Submit your solution</h3>
<p>Please submit your solution as a <strong>comment on the Github issue</strong> below, along
with your <strong>Twitter handle</strong> (we will use this to link back to you if your
solution is successful).</p>
<ul>
<li><strong><em><a href="https://github.com/emson/elixirgolf/issues/7">https://github.com/emson/elixirgolf/issues/7</a></em></strong></li>
</ul>
<h2 id="solutions">Solutions</h2>
<h3 id="winner">Winner</h3>
<p><code>--- your name here ---</code></p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Wikipedia “Palindrome”
<a href="https://en.wikipedia.org/wiki/Palindrome">https://en.wikipedia.org/wiki/Palindrome</a></li>
<li>Palindrome generator
<a href="http://www.dcode.fr/palindromes-generator">http://www.dcode.fr/palindromes-generator</a></li>
</ul>
<p><a href="/articles/elixir-palindrome-detector/">Elixir Palindrome Detector</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on March 18, 2016.</p>
/articles/99-bottles-of-elixir2016-02-26T00:00:00+00:002016-02-26T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="welcome-back">Welcome Back!</h2>
<p>We’re back! The slow start for 2016 has been because I’ve been completing an
Elixir online video course <strong><a href="http://www.elixirforbeginners.com">Elixir for Beginners http://www.elixirforbeginners.com</a></strong>. Needless to say it’s taken longer than expected, and I must apologise for that.</p>
<p>As a thank you for all your support, ElixirGolfers can have a <strong>discount coupon of 50%</strong> off: <br />
<strong><a href="https://www.udemy.com/elixir-for-beginners/?couponCode=ElixirGolf50%25">https://www.udemy.com/elixir-for-beginners/?couponCode=ElixirGolf50%25</a></strong></p>
<p>I hope you enjoy it, many thanks <br />
Ben…</p>
<h2 id="instructions">Instructions</h2>
<p>The puzzle this week is to generate verses from the old song “99 green bottles sitting on the
wall…”, but with an Elixir twist!</p>
<p>Your task is to write code that will output all 99 verses of the song.
The Elixir twist is that your program will <code>spawn</code> a <strong>new</strong> process for each verse,
and that verse must be output to the console (the primary process).
Each verse must decrease the number of bottles on the wall, and this must be sequential.
Meaning that verses can’t jump around.</p>
<p>The verse code must be generated in it’s own process and that process <code>PID</code> must
be returned with the verse. You can NOT just generate 99 processes, get the
PIDs and interpolate them with the verse’s <code>String</code>. As that is cheating ;o)</p>
<p>For example the program will work something like this:</p>
<div class="highlight"><pre><code class="language-text" data-lang="text">$> elixir bottles.exs
#PID<0.50.0> 99 bottles of Elixir on the wall, 99 bottles of Elixir.
Take one down and pass it around, 98 bottles of Elixir on the wall.
#PID<0.51.0> 98 bottles of Elixir on the wall, 98 bottles of Elixir.
Take one down and pass it around, 97 bottles of Elixir on the wall.
....
#PID<0.147.0> 2 bottles of Elixir on the wall, 2 bottles of Elixir.
Take one down and pass it around, 1 bottle of Elixir on the wall.
#PID<0.148.0> 1 bottle of Elixir on the wall, 1 bottle of Elixir.
Go code some more, 99 bottles of Elixir on the wall.</code></pre></div>
<h3 id="rules">Rules</h3>
<ul>
<li>
<p>The code will be executed using the elixir command: <code>elixir bottles.exs</code>.
We will manually copy the solutions into this file, so please just submit your
solutions as a Github issue (please see the link below).</p>
</li>
<li>
<p>Output 99 verses of the song in the following format, with a unique PID value
for each verse:</p>
</li>
</ul>
<div class="highlight"><pre><code class="language-text" data-lang="text">#PID<0.50.0> 99 bottles of Elixir on the wall, 99 bottles of Elixir.
Take one down and pass it around, 98 bottles of Elixir on the wall.</code></pre></div>
<p>NB: Note that we use the plural and singular of <code>bottle</code></p>
<div class="highlight"><pre><code class="language-text" data-lang="text">#PID<0.148.0> 1 bottle of Elixir on the wall, 1 bottle of Elixir.
Go code some more, 99 bottles of Elixir on the wall.</code></pre></div>
<ul>
<li>
<p><code>spawn</code> a <strong>new</strong> process for each verse, and that verse must be
output to the console (the primary process).</p>
</li>
<li>
<p>Each verse will sequentially decrease the number of <code>bottles</code> on the wall,
this sequence is important and must not jump up or down.</p>
</li>
</ul>
<h3 id="submit-your-solution">Submit your solution</h3>
<p>Please submit your solution as a <strong>comment on the Github issue</strong> below, along
with your <strong>Twitter handle</strong> (we will use this to link back to you if your
solution is successful).</p>
<ul>
<li><strong><em><a href="https://github.com/emson/elixirgolf/issues/6">https://github.com/emson/elixirgolf/issues/6</a></em></strong></li>
</ul>
<h2 id="solutions">Solutions</h2>
<h3 id="winner">Winner</h3>
<p><code>--- your name here ---</code></p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Wikipedia “99 Bottles of Beer”
<a href="https://en.wikipedia.org/wiki/99_Bottles_of_Beer">https://en.wikipedia.org/wiki/99_Bottles_of_Beer</a></li>
<li>99 Bottles on the wall in other languages
<a href="http://99-bottles-of-beer.net/">http://99-bottles-of-beer.net/</a></li>
</ul>
<p><a href="/articles/99-bottles-of-elixir/">99 Bottles of Elixir...</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on February 26, 2016.</p>
/articles/new-year-countdown-in-elixir2015-12-18T00:00:00+00:002015-12-18T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>2015 has been quite a year for <strong>elixir</strong>, and we wanted a way to celebrate the
comming New Year. We are thrilled that this weeks puzzle was dreamed up by one
of our contributors, <a href="https://twitter.com/stoftis">@stoftis</a>. So if you have any
puzzle ideas let us know, through email or twitter
<a href="https://twitter.com/elixirgolf">https://twitter.com/elixirgolf</a>.</p>
<p>The puzzle is to create a countdown timer that displays the number of <code>Days:Hours:Minutes:Seconds</code>
until the next New Year. This countdown timer will decrease every second until
<code>000:00:00:00</code>.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="err">$</span> <span class="n">elixir</span> <span class="n">countdown</span><span class="p">.</span><span class="n">exs</span>
<span class="mo">013</span><span class="err">:</span><span class="mo">05</span><span class="err">:</span><span class="mi">49</span><span class="err">:</span><span class="mi">08</span></code></pre></div>
<h3 id="rules">Rules</h3>
<ul>
<li>The code will be executed using the <code>elixir countdown.exs</code> terminal command. We will
manually copy all your solutions into this file, so please just submit your
solutions as below.</li>
<li>The timer will be in the following format <code>Days:Hours:Minutes:Seconds</code></li>
<li>The time should be represented as numbers, separated by colons: <code>000:00:00:00</code></li>
<li>Every second the timer should decrease by 1 second, and all the other fields
should adjust accordingly:</li>
</ul>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="mo">013</span><span class="err">:</span><span class="mo">05</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">01</span>
<span class="mo">013</span><span class="err">:</span><span class="mo">05</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">00</span>
<span class="mo">013</span><span class="err">:</span><span class="mo">04</span><span class="err">:</span><span class="mi">59</span><span class="err">:</span><span class="mi">59</span>
<span class="mo">013</span><span class="err">:</span><span class="mo">04</span><span class="err">:</span><span class="mi">59</span><span class="err">:</span><span class="mi">58</span>
<span class="p">..</span>
<span class="p">..</span>
<span class="mo">000</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">03</span>
<span class="mo">000</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">02</span>
<span class="mo">000</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">01</span>
<span class="mo">000</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">00</span><span class="err">:</span><span class="mo">00</span></code></pre></div>
<ul>
<li>The timer should only display one timer at any time, i.e. it should have some mechanism to
<strong>clear the screen or update itself</strong> every second. It should <strong>NOT</strong> display a
long list of times, like the example above.</li>
<li>The timer should countdown to the next New Year e.g. January 1st 2016.</li>
</ul>
<h3 id="bonus-credits">Bonus Credits</h3>
<p>As a bit of fun and a side project maybe consider the following <strong>flourishes</strong>:</p>
<ul>
<li>Colour the numbers</li>
<li>Allow the countdown timer to dynamically adjust to the following New Year
after this one</li>
<li>Trigger some exciting output when the countdown reaches <code>000:00:00:00</code>.</li>
</ul>
<h3 id="submit-your-solution">Submit your solution</h3>
<p>Please submit your solution as a <strong>comment on the Github issue</strong> below, along
with your <strong>Twitter handle</strong> (we will use this to link back to you if your
solution is successful).</p>
<ul>
<li><strong><em><a href="https://github.com/emson/elixirgolf/issues/5">https://github.com/emson/elixirgolf/issues/5</a></em></strong></li>
</ul>
<h2 id="solutions">Solutions</h2>
<h3 id="winner">Winner</h3>
<p><code>--- your name here ---</code></p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Wikipedia New Year
<a href="https://en.wikipedia.org/wiki/New_Year">https://en.wikipedia.org/wiki/New_Year</a></li>
<li>Example web countdown timer: <a href="http://www.timeanddate.com/countdown/newyear">http://www.timeanddate.com/countdown/newyear</a></li>
</ul>
<p><a href="/articles/new-year-countdown-in-elixir/">New Year Countdown in Elixir</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on December 18, 2015.</p>
/articles/elixir-rock-paper-scissors2015-12-11T00:00:00+00:002015-12-11T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>Recreate the classic <strong>“Rock, Paper, Scissors”</strong> game in Elixir.
The mechanics of the game are described below, or for more details see the
Wikipedia link in our resources section.</p>
<pre><code>r = rock
p = paper
s = scissors
rock: wins to scissors, loses with paper, a tie with rock.
paper: wins to rock, loses with scissors, a tie with paper.
scissors: wins to paper, loses with rock, a tie with scissors.
</code></pre>
<h3 id="rules">Rules</h3>
<ul>
<li>The user will input their choice as a String of 3 characters e.g. <code>"rps"</code></li>
<li>The program will then output as a String of 3 characters <code>"spr"</code> and a result
e.g. <code>"Draw"</code>, <code>"Win"</code>, <code>"Lose"</code></li>
<li>The program will choose it’s response output randomly</li>
<li>Each individual input character will always output one of the three possibilites</li>
<li>If the user enters blank or any other character, then the program simply
returns</li>
<li>The program should not be influenced by the user’s input, i.e. it should make
it’s choice at random</li>
</ul>
<p>For example:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="o">--</span><span class="n">enter</span> <span class="n">your</span> <span class="n">code</span> <span class="n">here</span><span class="o">--</span>
<span class="n">rps</span>
<span class="n">sprDraw</span></code></pre></div>
<p>The solution that completes this puzzle with the shortest number of characters
wins.</p>
<h3 id="submit-your-solution">Submit your solution</h3>
<p>Please submit your solution as a <strong>comment on the Github issue</strong> below, along
with your <strong>Twitter handle</strong> (we will use this to link back to you if your
solution is successful).</p>
<ul>
<li><a href="https://github.com/emson/elixirgolf/issues/4">https://github.com/emson/elixirgolf/issues/4</a></li>
</ul>
<h2 id="solutions">Solutions</h2>
<h3 id="winner">Winner</h3>
<p><code>--- your name here ---</code></p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Wikipedia Rock-Paper-Scissors
<a href="https://en.wikipedia.org/wiki/Rock-paper-scissors">https://en.wikipedia.org/wiki/Rock-paper-scissors</a></li>
</ul>
<p><a href="/articles/elixir-rock-paper-scissors/">Elixir Rock Paper Scissors</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on December 11, 2015.</p>
/articles/elixir-christmas-tree-puzzle2015-12-04T00:00:00+00:002015-12-04T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>Use your <strong>elixir</strong> coding skills to create a Christmas tree.</p>
<p>Your code should create a <strong>triangle</strong> of <code>0</code> characters that is <code>9</code> rows high.
At the top of the tree should be a <strong>star</strong> <code>*</code> and at the bottom there should be
a <strong>trunk</strong> <code>H</code>. The star and trunk should be aligned, and the start should be
directly above the top of the tree. The start and trunk are addional rows,
therefore the entire tree is a total of <code>11</code> characters high.</p>
<p>Every row of the triangle should be properly indented, such that each row is
centred on the row above.
For example:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="o">--</span><span class="n">enter</span> <span class="n">your</span> <span class="n">code</span> <span class="n">here</span><span class="o">--</span>
<span class="o">*</span>
<span class="mi">0</span>
<span class="mo">000</span>
<span class="mo">00000</span>
<span class="mo">0000000</span>
<span class="mo">000000000</span>
<span class="mo">00000000000</span>
<span class="mo">0000000000000</span>
<span class="mo">000000000000000</span>
<span class="mo">00000000000000000</span>
<span class="nc">H</span></code></pre></div>
<p>The solution that completes this puzzle with the shortest number of characters
wins. However if you want to get creative you will get an honourable mention.</p>
<h3 id="submit-your-solution">Submit your solution</h3>
<p>Please submit your solution as a <strong>comment on the Github issue</strong> below, along
with your <strong>Twitter handle</strong> (we will use this to link back to you if your
solution is successful).</p>
<ul>
<li><a href="https://github.com/emson/elixirgolf/issues/3">https://github.com/emson/elixirgolf/issues/3</a></li>
</ul>
<h2 id="solutions">Solutions</h2>
<p>Generating a Christmas tree seemed to really resonate with the everyone, as we
had the most solutions submitted so far. We also had some really fun versions,
in particular @henrik and @stoftis for their “interpretations” of what a
Christmas tree should be like.</p>
<h3 id="winner">Winner</h3>
<p>Winner: <a href="https://twitter.com/ventsislaf">@ventsislaf</a></p>
<p><code>char count 92</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">p</span><span class="p">=</span><span class="o">&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="ss">:string</span><span class="p">.</span><span class="n">centre</span><span class="ni">&1</span><span class="p">,</span><span class="mi">17</span><span class="p">;</span><span class="n">p</span><span class="p">.(</span><span class="s1">'*'</span><span class="p">);</span><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span> <span class="sc">?0</span><span class="p">,</span><span class="n">n</span><span class="o">*</span><span class="mi">2</span><span class="o">-</span><span class="mi">1</span><span class="p">);</span><span class="n">p</span><span class="p">.(</span><span class="s1">'H'</span><span class="p">)</span></code></pre></div>
<h4 id="understanding">Understanding</h4>
<p>This solution from @ventsislaf builds a Christmas tree from three components,
the star, body and trunk. The clever bit is that he figured out a generic
function for building the components.</p>
<p>To understand what this generic anonymous function does, lets rewrite it:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">p</span><span class="p">=</span><span class="o">&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="ss">:string</span><span class="p">.</span><span class="n">centre</span><span class="ni">&1</span><span class="p">,</span><span class="mi">17</span>
<span class="c1">#rewritten as</span>
<span class="n">p</span> <span class="p">=</span> <span class="o">&</span><span class="p">(</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="p">(</span> <span class="ss">:string</span><span class="p">.</span><span class="n">centre</span><span class="p">(</span><span class="ni">&1</span><span class="p">,</span> <span class="mi">17</span><span class="p">)</span> <span class="p">))</span></code></pre></div>
<p>The Erlang function <a href="http://www.erlang.org/doc/man/string.html#centre-2"><code>:string.centre/2</code></a>
will create a string where the <code>String</code>
passed to it is centred by surrounding it with blank characters. The anonymous
function above takes one parameter, the <code>String</code> to centre, and outputs it
centred within <code>17</code> characters. The number of characters is dictated by the
shape of the Chrismas tree. 9 rows will make the total width <code>17</code> characters for
the bottom branches of the Christmas tree. This anonymous function is bound to
the variable <code>p</code> and can then be used throughout the algorithm to draw each
layer of the tree.</p>
<p>The first and last rows of the tree are created by a call to the anonymous
function <code>p.('*')</code> and <code>p.('H')</code> respectively. The body of the Christmas tree is
a bit more complex.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span> <span class="sc">?0</span><span class="p">,</span><span class="n">n</span><span class="o">*</span><span class="mi">2</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span></code></pre></div>
<p>This <strong>elixir</strong> comprehension builds the triangular body of the Christmas tree.
If we rewrite it, it becomes clearer what is going on.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">n</span> <span class="p"><-</span> <span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span> <span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="p">(</span> <span class="s1">'0'</span><span class="p">,</span> <span class="n">n</span> <span class="o">*</span> <span class="mi">2</span> <span class="o">-</span> <span class="mi">1</span><span class="p">))</span></code></pre></div>
<p>The comprehension iterates over a range of interger values from <code>1..9</code> and
binds each integer to the variable <code>n</code>. This value is then used by the body of
the comprehension.<br />
First it calls the anonymous function defined previously and passes in a new
List. The List is constructed of a character List of <code>0s</code>, @ventsislaf uses the
shortcut <code>?0</code> to return the ASCII character <code>48</code> which maps to <code>0</code>. He then uses
the <a href="http://elixir-lang.org/docs/stable/elixir/List.html#duplicate/2"><code>List.duplicate/2</code></a>
function to create a new List. This function “Duplicates
the given <code>element</code> (<code>?0</code>, in our case), <code>n</code> number of times.</p>
<p>As can be seen from the formula @ventsislaf gradually increments the Character
List with <code>n * 2 - 1</code> until it reaches a maximum length of <code>17</code>. Each list is
then passed into the <code>:string.centre</code> function, and this gives us our triangular
shape.</p>
<p>A great solution, which highlights the power of tapping into Erlang functions
within <strong>elixir</strong>.</p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<p>Submitted by <a href="https://github.com/fishcakez">fishcakez</a>:</p>
<p><code>char count 94</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="ss">:io</span><span class="p">.</span><span class="n">format</span><span class="s2">"~10s~s~n~10s~n"</span><span class="p">,[</span><span class="s2">"*"</span><span class="p">,(</span><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="ss">:io_lib</span><span class="p">.</span><span class="n">format</span><span class="s2">"~n~</span><span class="si">#{</span><span class="mi">9</span><span class="o">+</span><span class="n">n</span><span class="si">}</span><span class="s2">.</span><span class="si">#{</span><span class="mi">2</span><span class="o">*</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="si">}</span><span class="s2">c"</span><span class="p">,</span><span class="s1">'0'</span><span class="p">),</span><span class="s2">"H"</span><span class="p">]</span></code></pre></div>
<p>This solution makes heavy use of the Erlang <a href="http://www.erlang.org/doc/man/io.html#format-2"><code>io.format/2</code></a>
function. fishcakez builds a List of data which he passes to the <code>io.format/2</code>
function. Understanding what this data looks like is key to understanding this
algorithm:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">[</span><span class="s2">"*"</span><span class="p">,(</span><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="ss">:io_lib</span><span class="p">.</span><span class="n">format</span><span class="s2">"~n~</span><span class="si">#{</span><span class="mi">9</span><span class="o">+</span><span class="n">n</span><span class="si">}</span><span class="s2">.</span><span class="si">#{</span><span class="mi">2</span><span class="o">*</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="si">}</span><span class="s2">c"</span><span class="p">,</span><span class="s1">'0'</span><span class="p">),</span><span class="s2">"H"</span><span class="p">]</span>
<span class="c1"># rewritten for clarity</span>
<span class="p">[</span><span class="s2">"*"</span><span class="p">,(</span><span class="o">--</span><span class="n">comprehension</span> <span class="n">here</span><span class="o">--</span><span class="p">),</span><span class="s2">"H"</span><span class="p">]</span></code></pre></div>
<p>So the <strong>elixir</strong> comprehension builds a list of data, which is inserted between
the <code>'*'</code> and the <code>'H'</code>. So the <strong>elixir</strong> comprehension builds a list of data,
which is inserted between the <code>'*'</code> and the <code>'H'</code>. Looking at this comprehension
in detail we see that it iterates over the rows from <code>1..9</code> and binds the value
to <code>n</code> like the winning example. He then uses the Erlang
<a href="http://www.erlang.org/doc/man/io_lib.html#format-2"><code>io_lib.format/2</code></a>
function to create a List of Lists describing a particular row. For instance
when <code>n = 1</code> the List output is:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span><span class="ss">:io_lib</span><span class="p">.</span><span class="n">format</span><span class="s2">"~n~</span><span class="si">#{</span><span class="mi">9</span><span class="o">+</span><span class="n">n</span><span class="si">}</span><span class="s2">.</span><span class="si">#{</span><span class="mi">2</span><span class="o">*</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="si">}</span><span class="s2">c"</span><span class="p">,</span><span class="s1">'0'</span>
<span class="c1"># gives a List of Lists we can print to the console</span>
<span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="p">[</span><span class="s1">'</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="p">[[</span><span class="mi">32</span><span class="p">,</span> <span class="p">[</span><span class="s1">' '</span><span class="p">,</span> <span class="mi">32</span><span class="p">,</span> <span class="mi">32</span><span class="p">],</span> <span class="s1">' '</span><span class="p">,</span> <span class="mi">32</span><span class="p">,</span> <span class="mi">32</span><span class="p">],</span> <span class="mi">48</span><span class="p">]]</span>
<span class="c1"># this outputs to the console</span>
<span class="mi">0</span>
<span class="ss">:ok</span></code></pre></div>
<p>Notice how the first character creates a newline, and then <code>9</code> spaces (ASCII
character <code>32</code>), preappended to a <code>0</code> (ASCII character <code>48</code>).</p>
<p>The first part of the algorithm prints <code>9</code> spaces and the content of the data.
For example:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="ss">:io</span><span class="p">.</span><span class="n">format</span><span class="s2">"~10s~s~n~10s"</span><span class="p">,</span> <span class="p">[</span><span class="s2">"*"</span><span class="p">,</span> <span class="p">[</span><span class="s1">'</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span> <span class="p">[[</span><span class="mi">32</span><span class="p">,</span> <span class="p">[</span><span class="s1">' '</span><span class="p">,</span> <span class="mi">32</span><span class="p">,</span> <span class="mi">32</span><span class="p">],</span> <span class="s1">' '</span><span class="p">,</span> <span class="mi">32</span><span class="p">,</span> <span class="mi">32</span><span class="p">],</span> <span class="mi">48</span><span class="p">]],</span> <span class="s2">"H"</span><span class="p">]</span>
<span class="o">*</span>
<span class="mi">0</span>
<span class="nc">H</span><span class="ss">:ok</span></code></pre></div>
<p>A sophisticated solution and very interesting use of <code>io.format</code> and
<code>io_lib.format</code>. Well done.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/henrik">@henrik</a>:</p>
<p><code>char count 99</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">d</span><span class="p">=</span><span class="o">&</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">s</span><span class="p">=</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="p">);</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="p">[</span><span class="n">s</span><span class="p">,</span><span class="s2">"*</span>
<span class="s2">"</span><span class="p">,(</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="p">[</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="o">-</span><span class="n">i</span><span class="p">),</span><span class="n">d</span><span class="p">.(</span><span class="sc">?0</span><span class="p">,</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span><span class="o">+</span><span class="mi">1</span><span class="p">),</span><span class="mi">10</span><span class="p">]),</span><span class="n">s</span><span class="p">,</span><span class="sc">?H</span><span class="p">]</span></code></pre></div>
<p>This solution uses the newline after the <code>"*</code> to save an extra character instead
of using <code>\n</code>. @henrik uses a similar technique as the winning solution, in that
he creates an anonymous function and binds it to a variable:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">d</span><span class="p">=</span><span class="o">&</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="o">/</span><span class="mi">2</span></code></pre></div>
<p>He can then use this function throughout his algorithm to output the various
layers of the Christmas tree. The tree is constructed from spaces and values
appended to those spaces. For example <code>s = d.(32, 8)</code> will create a list of <code>8</code>
space characters (ASCII <code>32</code>) and bind this List to the variable <code>s</code>. By using
an <strong>elixir</strong> List @henrik builds up all the Christmas tree components, which he
then outputs to the console with <code>IO.puts</code>.</p>
<p>So the List becomes a List of Lists. The first item being our variable bound to
a List of <code>8</code> spaces, then a binary String holding a <code>"*\n</code>. Although the newline
character <code>\n</code> is actually represented as one character as @henrik sneakily uses
an <code>iex</code> carriage return instead of the symbol.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">(</span><span class="k">for</span> <span class="n">i</span> <span class="p"><-</span> <span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span> <span class="ss">do</span><span class="p">:</span> <span class="p">[</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span> <span class="mi">8</span> <span class="o">-</span> <span class="n">i</span><span class="p">),</span> <span class="n">d</span><span class="p">.(</span><span class="sc">?0</span><span class="p">,</span> <span class="n">i</span> <span class="o">*</span> <span class="mi">2</span> <span class="o">+</span> <span class="mi">1</span><span class="p">),</span> <span class="mi">10</span><span class="p">])</span></code></pre></div>
<p>The algorithm that generates the body of the tree works by building multiple
Lists of spaces and characters. A comprehension iterates over each row from
<code>0..8</code> and binds this value to <code>i</code>. The first item of the generated List
gradually decrements a List of spaces until an empty List is left. The second
item gradually increments a character list of ASCII represented zeros (<code>0</code> in
ASCII is <code>48</code> which is given by <code>?0</code> for readability). Finally the last
character in the List is the ASCII value <code>10</code> which is a newline character.</p>
<p>This is what the algorithm is doing for clarity.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">[</span>
<span class="p">[</span><span class="s1">' '</span><span class="p">,</span> <span class="s1">'0'</span><span class="p">,</span> <span class="mi">10</span><span class="p">],</span>
<span class="p">[</span><span class="s1">' '</span><span class="p">,</span> <span class="s1">'000'</span><span class="p">,</span> <span class="mi">10</span><span class="p">],</span>
<span class="p">..</span>
<span class="p">[[],</span> <span class="s1">'00000000000000000'</span><span class="p">,</span> <span class="mi">10</span><span class="p">]</span>
<span class="p">]</span></code></pre></div>
<p>Just remember that <code>IO.puts</code> on a List of Lists, including character data
(codepoints) will be output as a single binary String value.</p>
<p>Finally @henrik adds the Christmas tree trunk to the end of the master List <code>,s,?H]</code>.
Again he uses the List of <code>8</code> spaces to position the trunk which is the ASCII
character <code>72</code> represented by <code>?H</code>.</p>
<p>Excellent, there are some really interesting concepts and great use of Lists.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/vanstee">@vanstee</a>:</p>
<p><code>char count 101</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">d</span><span class="p">=</span><span class="o">&</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">p</span><span class="p">=</span><span class="o">&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">9</span><span class="o">-</span><span class="ni">&1</span><span class="p">)</span><span class="o">++</span><span class="ni">&2</span><span class="p">;</span><span class="n">p</span><span class="p">.(</span><span class="mi">1</span><span class="p">,</span><span class="s1">'*'</span><span class="p">);</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="n">i</span><span class="p">,</span><span class="n">d</span><span class="p">.(</span><span class="mi">48</span><span class="p">,</span><span class="mi">2</span><span class="o">*</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">));</span><span class="n">p</span><span class="p">.(</span><span class="mi">1</span><span class="p">,</span><span class="s1">'H'</span><span class="p">)</span></code></pre></div>
<p>@vanstee uses two anonymous functions in his algorithm.<code>d=&List.duplicate/2</code> and
<code>p=&IO.puts d.(32,9-&1)++&2</code>. The first function duplicates a List of items, <code>n</code>
number of times. Lets look at the second function in a bit more detail:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">p</span><span class="p">=</span><span class="o">&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">9</span><span class="o">-</span><span class="ni">&1</span><span class="p">)</span><span class="o">++</span><span class="ni">&2</span>
<span class="c1"># rewritten as:</span>
<span class="n">p</span> <span class="p">=</span> <span class="o">&</span><span class="p">(</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="p">(</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span> <span class="mi">9</span> <span class="o">-</span> <span class="ni">&1</span><span class="p">)</span> <span class="o">++</span> <span class="ni">&2</span><span class="p">))</span>
<span class="c1"># when run will output</span>
<span class="n">iex</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span><span class="o">></span> <span class="n">p</span><span class="p">.(</span><span class="mi">2</span><span class="p">,</span> <span class="s1">'000'</span><span class="p">)</span>
<span class="mo">000</span>
<span class="ss">:ok</span></code></pre></div>
<p>This function creates a two character Lists and appends them together. The first
parameter <code>&1</code> is the size of the character List of space characters (ASCII <code>32</code>).
The second parameter <code>&2</code> is another character List of the “body” characters.</p>
<p>To create the star and trunk all @vanstee has to do is invoke his anonymous
function with the correct values: <code>p.(1,'*')</code> and <code>p.(1,'H')</code></p>
<p>Finally he builds the body of the Christmas tree with a comprehension to iterate
over each row modifying his anonymous function parameters.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="n">i</span><span class="p">,</span><span class="n">d</span><span class="p">.(</span><span class="mi">48</span><span class="p">,</span><span class="mi">2</span><span class="o">*</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span>
<span class="c1"># rewritten as:</span>
<span class="k">for</span> <span class="n">i</span> <span class="p"><-</span> <span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span> <span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="n">i</span><span class="p">,</span> <span class="n">d</span><span class="p">.(</span><span class="sc">?0</span><span class="p">,</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">))</span>
<span class="c1"># which will output:</span>
<span class="n">iex</span><span class="o">></span> <span class="k">for</span> <span class="n">i</span> <span class="p"><-</span> <span class="mi">1</span><span class="p">..</span><span class="mi">9</span><span class="p">,</span> <span class="ss">do</span><span class="p">:</span> <span class="n">p</span><span class="p">.(</span><span class="n">i</span><span class="p">,</span> <span class="n">d</span><span class="p">.(</span><span class="sc">?0</span><span class="p">,</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">))</span>
<span class="mi">0</span>
<span class="mo">000</span>
<span class="p">..</span>
<span class="mo">00000000000000000</span>
<span class="p">[</span><span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">,</span> <span class="ss">:ok</span><span class="p">]</span></code></pre></div>
<p>Well done @vanstee, who also influenced some of the other solutions.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/rubysolo">@rubysolo</a>:</p>
<p><code>char count 103</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">c</span><span class="p">=</span><span class="o">&</span><span class="p">[</span><span class="ss">:string</span><span class="p">.</span><span class="n">centre</span><span class="p">(</span><span class="ni">&1</span><span class="p">,</span><span class="mi">17</span><span class="p">),</span><span class="s1">'</span><span class="se">\n</span><span class="s1">'</span><span class="p">];</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="n">c</span><span class="p">.(</span><span class="s1">'*'</span><span class="p">)</span><span class="o">++</span><span class="p">(</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="p">.(</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span> <span class="mi">48</span><span class="p">,</span><span class="mi">2</span><span class="o">*</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">))</span><span class="o">++</span><span class="n">c</span><span class="p">.(</span><span class="s1">'H'</span><span class="p">)</span></code></pre></div>
<p>@rubysolo used the Erlang function <code>:string.centre/2</code> which he wrapped in an
anonymous function that takes a single binary String parameter. As the tree body
will only be <code>9</code> rows high we know that the width will be a maximum of <code>17</code>
characters.</p>
<p>The algorithm uses the <code>++</code> List append operator to append the star row, the
body rows and the trunk row.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="p">.(</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span> <span class="mi">48</span><span class="p">,</span><span class="mi">2</span><span class="o">*</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
<span class="c1"># rewritten as:</span>
<span class="k">for</span> <span class="n">i</span> <span class="p"><-</span> <span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span> <span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="p">.(</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="p">(</span><span class="sc">?0</span><span class="p">,</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">))</span>
<span class="c1"># which will output a List of Lists</span>
<span class="p">[</span>
<span class="p">[</span><span class="s1">' 0 '</span><span class="p">],</span>
<span class="p">[</span><span class="s1">' 000 '</span><span class="p">],</span>
<span class="p">..</span>
<span class="p">[</span><span class="s1">'00000000000000000'</span><span class="p">]</span>
<span class="p">]</span></code></pre></div>
<p>Good to see the use of Erlang in the solution. Well done.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/stoftis">@stoftis</a>:</p>
<p><code>char count 117</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">x</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">10</span><span class="p">,</span><span class="n">y</span><span class="p">=</span><span class="n">x</span><span class="o"><</span><span class="mi">1</span><span class="o">&&</span><span class="s2">"*"</span><span class="o">||</span><span class="n">x</span><span class="o">></span><span class="mi">9</span><span class="o">&&</span><span class="s2">"H"</span><span class="o">||</span><span class="s2">"0"</span><span class="p">,</span><span class="n">z</span><span class="p">=</span><span class="mi">1</span><span class="o"><</span><span class="n">x</span><span class="o">&&</span><span class="n">x</span><span class="o"><</span><span class="mi">10</span><span class="o">&&</span> <span class="nc">String</span><span class="p">.</span><span class="n">rjust</span><span class="p">(</span><span class="s2">"0"</span><span class="p">,</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="sc">?0</span><span class="p">)</span><span class="o">||</span><span class="s2">""</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="nc">String</span><span class="p">.</span><span class="n">rjust</span><span class="p">(</span><span class="n">z</span><span class="p">,</span><span class="mi">8</span><span class="p">)</span><span class="o"><></span><span class="n">y</span><span class="o"><></span><span class="n">z</span></code></pre></div>
<p>This solution makes heavy use of Strings. It uses a comprehension differently
from many of the other solutions. First it iterates over the full <code>11</code> rows i.e.
it includes both the star and trunk rows. The comprehension then uses two
filters to figure out what to pass to it’s body.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">y</span><span class="p">=</span><span class="n">x</span><span class="o"><</span><span class="mi">1</span><span class="o">&&</span><span class="s2">"*"</span><span class="o">||</span><span class="n">x</span><span class="o">></span><span class="mi">9</span><span class="o">&&</span><span class="s2">"H"</span><span class="o">||</span><span class="s2">"0"</span>
<span class="c1"># this filter can be rewritten as:</span>
<span class="n">y</span> <span class="p">=</span> <span class="p">(</span><span class="n">x</span> <span class="o"><</span> <span class="mi">1</span><span class="p">)</span> <span class="o">&&</span> <span class="s2">"*"</span> <span class="o">||</span> <span class="n">x</span> <span class="o">></span> <span class="mi">9</span> <span class="o">&&</span> <span class="s2">"H"</span> <span class="o">||</span> <span class="s2">"0"</span></code></pre></div>
<p>This filter is passed the row value bound to <code>x</code> if it is <code>0</code> then the <code>*</code> is
returned if it is <code>10</code> then the <code>H</code> is returned else <code>0</code> is returned. All these
values are bound to the variable <code>y</code>.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">z</span><span class="p">=</span><span class="mi">1</span><span class="o"><</span><span class="n">x</span><span class="o">&&</span><span class="n">x</span><span class="o"><</span><span class="mi">10</span><span class="o">&&</span> <span class="nc">String</span><span class="p">.</span><span class="n">rjust</span><span class="p">(</span><span class="s2">"0"</span><span class="p">,</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="sc">?0</span><span class="p">)</span><span class="o">||</span><span class="s2">""</span>
<span class="c1"># can be rewritten as:</span>
<span class="n">z</span> <span class="p">=</span> <span class="p">(</span> <span class="p">(</span><span class="n">x</span> <span class="o">></span> <span class="mi">1</span><span class="p">)</span> <span class="o">&&</span> <span class="p">(</span><span class="n">x</span> <span class="o"><</span> <span class="mi">10</span><span class="p">)</span> <span class="o">&&</span> <span class="p">(</span><span class="nc">String</span><span class="p">.</span><span class="n">rjust</span><span class="p">(</span><span class="s2">"0"</span><span class="p">,</span> <span class="n">x</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="sc">?0</span><span class="p">))</span> <span class="p">)</span> <span class="o">||</span> <span class="s2">""</span></code></pre></div>
<p>This filter will bind the String of <code>0</code> values to the variable <code>z</code> if the
comprehension value of x is in the body range e.g. <code>1..9</code> otherwise it returns
an empty String. The String of <code>0</code> values will adjust according to what row the
comprehension is iterating over.</p>
<p>For each row we now have a String value for both <code>y</code> and <code>z</code>, and the body of
the comprehension will output these to the console:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="nc">String</span><span class="p">.</span><span class="n">rjust</span><span class="p">(</span><span class="n">z</span><span class="p">,</span><span class="mi">8</span><span class="p">)</span><span class="o"><></span><span class="n">y</span><span class="o"><></span><span class="n">z</span></code></pre></div>
<p>This <code>String.rjust/2</code> function appends both the values of <code>y</code> and <code>z</code> to it’s
result. By using <code>rjust</code> the resulting String is right justified and padded with
the default padding , which is whitespace.</p>
<p>Elixir String functions are poweful in their own right and we don’t always have
to revert down to using Erlang functions. Good thinking @stoftis</p>
<hr />
<p>Submitted by <a href="https://twitter.com/notexactlyawe">@notexactlyawe</a>:</p>
<p><code>char count 131</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="kn">import</span> <span class="nc">String</span><span class="p">;</span><span class="n">a</span><span class="p">=</span><span class="n">duplicate</span> <span class="s2">" "</span><span class="p">,</span><span class="mi">8</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="s2">"</span><span class="si">#{</span><span class="n">a</span><span class="si">}</span><span class="s2">*"</span><span class="p">;</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="n">h</span> <span class="k">do</span> <span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="s2">"</span><span class="si">#{</span><span class="n">duplicate</span> <span class="s2">" "</span><span class="p">,</span><span class="mi">9</span><span class="o">-</span><span class="n">i</span><span class="si">}#{</span><span class="n">duplicate</span> <span class="s2">"0"</span><span class="p">,</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span><span class="o">-</span><span class="mi">1</span><span class="si">}</span><span class="s2">"</span><span class="k">end</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="s2">"</span><span class="si">#{</span><span class="n">a</span><span class="si">}</span><span class="s2">H"</span></code></pre></div>
<p>This algorithm is another all String solution which builds and outputs a String
for each row. First the <code>String</code> module is imported so that we can save
characters. Maybe we could wrap this <code>String.duplicate/2</code> function in an
anonymous function to save even more space.</p>
<p>@notexactlyawe then binds <code>8</code> blank characters to the <code>a</code> variable which acts as
padding for the star and trunk <code>a=duplicate " ",8</code>.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">a</span><span class="p">=</span><span class="n">duplicate</span> <span class="s2">" "</span><span class="p">,</span><span class="mi">8</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="s2">"</span><span class="si">#{</span><span class="n">a</span><span class="si">}</span><span class="s2">*"</span>
<span class="c1"># and</span>
<span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="s2">"</span><span class="si">#{</span><span class="n">a</span><span class="si">}</span><span class="s2">H"</span></code></pre></div>
<p>The body then uses similar techniques we’ve seen before, by building a String of
spaces and concatenating it with the body String values, using interpolation
<code>"#{}"</code>.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="n">h</span> <span class="k">do</span> <span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="s2">"</span><span class="si">#{</span><span class="n">duplicate</span> <span class="s2">" "</span><span class="p">,</span><span class="mi">9</span><span class="o">-</span><span class="n">i</span><span class="si">}#{</span><span class="n">duplicate</span> <span class="s2">"0"</span><span class="p">,</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span><span class="o">-</span><span class="mi">1</span><span class="si">}</span><span class="s2">"</span><span class="k">end</span></code></pre></div>
<p>A nice use of Strings and String interpolation. Thank you.</p>
<hr />
<h2 id="bonus-credit">Bonus Credit</h2>
<p>As a bit of fun we wanted to see what creative versions of the Christmas tree
the community could come up with. These solutions aren’t the smallest, but they
certainly show off other aspects of the <strong>elixir</strong> language.</p>
<p>Submitted by <a href="https://twitter.com/henrik">@henrik</a>:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="kn">import</span> <span class="nc">IO.ANSI</span><span class="p">;</span><span class="n">r</span><span class="p">=</span><span class="n">reset</span><span class="p">;</span><span class="n">b</span><span class="p">=</span><span class="n">blink_slow</span><span class="p">;</span><span class="n">g</span><span class="p">=</span><span class="n">green</span><span class="p">;</span><span class="n">y</span><span class="p">=</span><span class="n">yellow</span><span class="p">;</span><span class="n">d</span><span class="p">=</span><span class="o">&</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">s</span><span class="p">=</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="p">);</span><span class="n">t</span><span class="p">=</span><span class="nc">Stream</span><span class="p">.</span><span class="n">cycle</span><span class="p">([[</span><span class="n">g</span><span class="p">,</span><span class="sc">?/</span><span class="p">],[</span><span class="n">red</span><span class="p">,</span><span class="sc">?o</span><span class="p">],[</span><span class="n">g</span><span class="p">,</span><span class="sc">?\\</span><span class="p">],[</span><span class="n">y</span><span class="p">,</span><span class="n">b</span><span class="p">,</span><span class="sc">?i</span><span class="p">,</span><span class="n">r</span><span class="p">]]);</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="p">[</span><span class="n">s</span><span class="p">,</span><span class="n">y</span><span class="p">,</span><span class="n">b</span><span class="p">,</span><span class="s2">"*</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span><span class="n">r</span><span class="p">,(</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="p">[</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="o">-</span><span class="n">i</span><span class="p">),</span><span class="nc">Enum</span><span class="p">.</span><span class="n">take</span><span class="p">(</span><span class="n">t</span><span class="p">,</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span><span class="o">+</span><span class="mi">1</span><span class="p">),</span><span class="mi">10</span><span class="p">]),</span><span class="n">s</span><span class="p">,</span><span class="n">r</span><span class="p">,</span><span class="sc">?H</span><span class="p">]</span></code></pre></div>
<p>This solution was amazing and outputs a coloured Christmas tree with flashing
lights, as you can see below. (If you use iTerm2 you will need to turn on the
“blink” checkbox, to see it flash).</p>
<p><img src="https://cloud.githubusercontent.com/assets/216/11612640/b5007310-9c02-11e5-816c-4a760c3644f2.gif" alt="" /></p>
<p>Really impressive thanks very much.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/stoftis">@stoftis</a>:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">d</span><span class="p">=</span><span class="o">&</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">s</span><span class="p">=</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="p">);</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="p">[</span><span class="n">s</span><span class="p">,</span><span class="nc">IO.ANSI</span><span class="p">.</span><span class="n">yellow</span> <span class="o"><></span> <span class="s2">"* "</span><span class="p">,(</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="p">[</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="o">-</span><span class="n">i</span><span class="p">),</span><span class="n">d</span><span class="p">.(</span><span class="nc">Enum</span><span class="p">.</span><span class="n">random</span><span class="p">([</span><span class="nc">IO.ANSI</span><span class="p">.</span><span class="n">green</span><span class="p">,</span> <span class="nc">IO.ANSI</span><span class="p">.</span><span class="n">red</span><span class="p">])</span> <span class="o"><></span> <span class="nc">Enum</span><span class="p">.</span><span class="n">random</span><span class="p">(</span><span class="sx">~W(> = < ~ ~)</span><span class="p">),</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span><span class="o">+</span><span class="mi">1</span><span class="p">),</span><span class="mi">10</span><span class="p">]),</span><span class="n">s</span><span class="p">,</span><span class="sc">?H</span><span class="p">]</span></code></pre></div>
<p>A great use of colour and just shows how easy it is to add fun flourshies in <strong>elixir</strong> code.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/emson">@emson</a>:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">d</span><span class="p">=</span><span class="o">&</span><span class="nc">List</span><span class="p">.</span><span class="n">duplicate</span><span class="o">/</span><span class="mi">2</span><span class="p">;</span><span class="n">s</span><span class="p">=</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="p">);</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="p">[</span><span class="n">s</span><span class="p">,</span><span class="s2">"*</span>
<span class="s2">"</span><span class="p">,(</span><span class="k">for</span> <span class="n">i</span><span class="p"><-</span><span class="mi">0</span><span class="p">..</span><span class="mi">8</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="p">[</span><span class="n">d</span><span class="p">.(</span><span class="mi">32</span><span class="p">,</span><span class="mi">8</span><span class="o">-</span><span class="n">i</span><span class="p">),(</span><span class="k">for</span> <span class="n">x</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span><span class="ss">into</span><span class="p">:</span> <span class="p">[],</span><span class="ss">do</span><span class="p">:</span> <span class="nc">Enum</span><span class="p">.</span><span class="n">random</span> <span class="sx">~W(~ x o ~ ~)</span><span class="p">),</span><span class="mi">10</span><span class="p">]),</span><span class="n">s</span><span class="p">,</span><span class="sc">?H</span><span class="p">]</span></code></pre></div>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">.</span> <span class="o">*</span>
<span class="err">~</span><span class="n">ox</span>
<span class="err">~</span><span class="n">o</span><span class="o">~~~</span>
<span class="o">~~~~~~</span><span class="n">o</span>
<span class="err">~~</span><span class="n">o</span><span class="o">~~~~~~</span>
<span class="err">~</span><span class="n">x</span><span class="o">~~~</span><span class="n">x</span><span class="err">~</span><span class="n">x</span><span class="err">~</span><span class="n">x</span><span class="err">~</span>
<span class="err">~</span><span class="n">x</span><span class="err">~~</span><span class="n">x</span><span class="err">~~</span><span class="n">oxo</span><span class="err">~</span><span class="n">o</span><span class="err">~</span>
<span class="o">~~~</span><span class="n">ox</span><span class="err">~</span><span class="n">o</span><span class="err">~</span><span class="n">o</span><span class="o">~~~</span><span class="err">~</span><span class="n">ox</span>
<span class="o">~~~</span><span class="n">ooox</span><span class="err">~~</span><span class="n">o</span><span class="err">~</span><span class="n">o</span><span class="o">~~~</span><span class="n">xx</span>
<span class="nc">H</span></code></pre></div>
<p>The sigil <a href="http://elixir-lang.org/docs/stable/elixir/kernel.html#sigil_w/2"><code>~W(~ x o ~
~)</code></a> is a very clean way of creating simple Lists.
Thanks for this.</p>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Wikipedia Christmas tree
<a href="https://en.wikipedia.org/wiki/Christmas_tree">https://en.wikipedia.org/wiki/Christmas_tree</a></li>
<li>Erlang <code>string.centre/2</code>
<a href="http://www.erlang.org/doc/man/string.html#centre-2">http://www.erlang.org/doc/man/string.html#centre-2</a></li>
<li>Erlang <code>io.format/2</code>
<a href="http://www.erlang.org/doc/man/io.html#format-2">http://www.erlang.org/doc/man/io.html#format-2</a></li>
<li>Elixir <code>List.duplicate/2</code>
<a href="http://elixir-lang.org/docs/stable/elixir/List.html#duplicate/2">http://elixir-lang.org/docs/stable/elixir/List.html#duplicate/2</a></li>
<li>Elixir Sigils
<a href="http://elixir-lang.org/docs/stable/elixir/kernel.html#sigil_w/2">http://elixir-lang.org/docs/stable/elixir/kernel.html#sigil_w/2</a></li>
<li>Elixir <code>Enum.random</code>
<a href="http://elixir-lang.org/docs/stable/elixir/Enum.html#random/1">http://elixir-lang.org/docs/stable/elixir/Enum.html#random/1</a></li>
<li>Elixir <code>IO.ANSI</code>
<a href="http://elixir-lang.org/docs/stable/elixir/IO.ANSI.html">http://elixir-lang.org/docs/stable/elixir/IO.ANSI.html</a></li>
<li>Elixir <code>String.rjust/3</code>
<a href="http://elixir-lang.org/docs/stable/elixir/String.html#rjust/3">http://elixir-lang.org/docs/stable/elixir/String.html#rjust/3</a></li>
<li>Elixir <code>Stream.cycle/1</code>
<a href="http://elixir-lang.org/docs/stable/elixir/Stream.html#cycle/1">http://elixir-lang.org/docs/stable/elixir/Stream.html#cycle/1</a></li>
<li>Elixir comprehension <code>for</code>
<a href="http://elixir-lang.org/getting-started/comprehensions.html">http://elixir-lang.org/getting-started/comprehensions.html</a></li>
<li>Elixir docs interpolation & anonymous functions:
<a href="http://elixir-lang.org/getting-started/basic-types.html">http://elixir-lang.org/getting-started/basic-types.html</a></li>
<li>Elixir String interpolation:
<a href="http://elixir-lang.org/getting-started/basic-types.html#strings">http://elixir-lang.org/getting-started/basic-types.html#strings</a></li>
</ul>
<p><a href="/articles/elixir-christmas-tree-puzzle/">Elixir Christmas Tree Puzzle</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on December 04, 2015.</p>
/articles/elixir-quine-self-replicating-program2015-11-27T00:00:00+00:002015-11-27T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>Write an elixir quine. A <a href="https://en.wikipedia.org/wiki/Quine_%28computing%29">Quine</a>
is a computer program which takes no input and produces a copy of its own source code as its
only output. They are “self-replicating” or “self-reproducing” programs, and
your task is to either create the <strong>shortest</strong> or the most <strong>creative</strong> elixir quine.</p>
<p>There will be two winners, one for the shortest and the other for the most
creative. Creative is open to interpretation, however these are the sort of things we
consider creative:</p>
<ul>
<li>best use of language (elixir or erlang), maybe use processes</li>
<li>interpretation of a quine, e.g. prints the output in reverse</li>
<li>maybe switches between languages elixir/erlang</li>
</ul>
<p>The rule is that you enter your code into <code>iex</code> and press return, the output
will be your code. This can then be copied and pasted back into <code>iex</code> and will
produce the same output. It maybe that your code requires pasting back into
<code>iex</code> multiple times, but at some “reasonable” count it should reproduce the
original code.</p>
<p>A Ruby example might be:</p>
<div class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">irb</span><span class="o">></span> <span class="nb">lambda</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">x</span> <span class="o">+</span> <span class="n">x</span><span class="o">.</span><span class="n">inspect</span><span class="p">}</span><span class="o">.</span><span class="n">call</span><span class="s2">"lambda{|x| puts x + x.inspect}.call"</span>
<span class="nb">lambda</span><span class="p">{</span><span class="o">|</span><span class="n">x</span><span class="o">|</span> <span class="nb">puts</span> <span class="n">x</span> <span class="o">+</span> <span class="n">x</span><span class="o">.</span><span class="n">inspect</span><span class="p">}</span><span class="o">.</span><span class="n">call</span><span class="s2">"lambda{|x| puts x + x.inspect}.call"</span>
<span class="o">=></span> <span class="kp">nil</span></code></pre></div>
<h4 id="no-cheating-quines">No cheating quines</h4>
<p>Quines, per definition, cannot receive any form of input, including reading a
file, which means a quine is considered to be “cheating” if it looks at its own
source code.</p>
<p>This JavaScript example cheats by calling itself with the <code>a()</code> call.
Essentially in this case the <code>function</code> code is a file.</p>
<div class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="n">function</span> <span class="n">a</span><span class="p">()</span> <span class="p">{</span>
<span class="n">document</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="s2">"a()"</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">a</span><span class="p">()</span></code></pre></div>
<p><strong>Please submit your solutions as comments to the Github issue:</strong><br />
<strong><a href="https://github.com/emson/elixirgolf/issues/1">https://github.com/emson/elixirgolf/issues/1</a></strong></p>
<h2 id="solutions">Solutions</h2>
<p>This weeks puzzle was less popular than last weeks, probably because
Quines are quite abstract, however we had a few interesting solutions.
More importantly there were things to learn from.</p>
<h3 id="winner">Winner</h3>
<p>Winner: <a href="https://twitter.com/rubysolo">@rubysolo</a></p>
<p><code>char count: 46</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">q</span><span class="p">=<<</span><span class="s2">"q=~p;:io.format q,[q]"</span><span class="p">>>;</span><span class="ss">:io</span><span class="p">.</span><span class="n">format</span> <span class="n">q</span><span class="p">,[</span><span class="n">q</span><span class="p">]</span></code></pre></div>
<h4 id="understanding">Understanding</h4>
<p>The key to this Quine is the Erlang function <code>:io.format/2</code>. This function
takes 2 parameters <code>Format</code> and <code>Data</code>, which it uses to write the Data to
the standard output device in accordance to the Format provided.</p>
<p>For example, using the Format <code>"~p"</code>, it will write the Data using standard syntax
and will output lists of printable characters as strings. Interestingly the Data
will replace the <code>~p</code>value, this means you can surround it with other text for example
<code>"hello ~p world"</code>.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="ss">:io</span><span class="p">.</span><span class="n">format</span> <span class="s2">"hello ~p world"</span><span class="p">,</span> <span class="p">[</span><span class="s2">"my"</span><span class="p">]</span>
<span class="n">hello</span> <span class="p"><<</span><span class="s2">"my"</span><span class="p">>></span> <span class="n">world</span><span class="ss">:ok</span></code></pre></div>
<p>NB. the <code>:ok</code> atom is just the standard return response so we can ignore it for
our Quine purposes.</p>
<p>Next we build the String to be passed to <code>:io.format</code>. This String is
the clever bit, as it will be crafted in such a way that <code>:io.format</code> will use
it to substitue the <code>~p</code> value with itself. If we substitue the Data parameter
with <code>"BOOM"</code> you can see what <code>:io.format</code> does. It converts the <code>["BOOM"]</code>
list to a binary (String) <code><<"BOOM">></code>. Notice that the <code><<>></code> <strong>elixir</strong>
bitstrings are returned.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="ss">:io</span><span class="p">.</span><span class="n">format</span> <span class="s2">"q=~p;:io.format q,[q]"</span><span class="p">,</span> <span class="p">[</span><span class="s2">"BOOM"</span><span class="p">]</span>
<span class="n">q</span><span class="p">=<<</span><span class="s2">"BOOM"</span><span class="p">>>;</span><span class="ss">:io</span><span class="p">.</span><span class="n">format</span> <span class="n">q</span><span class="p">,[</span><span class="n">q</span><span class="p">]</span><span class="ss">:ok</span></code></pre></div>
<p>As <code><<>></code> bitstrings are returned we need to surround our Format String with
them. Finally we bind the whole value to the variable <code>q</code>, and remember to
separate the 2 conditions with <code>;</code>.</p>
<p>A great solution, which demonstrates the symbiotic relationship between Erlang and
<strong>elixir</strong>.</p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<p>Honourable mention solutions are ordered by influence rather than on char count.
This is because often a particular solution will influence others.</p>
<p>Submitted by <a href="https://twitter.com/phani_mahesh">@Phani_Mahesh</a>:</p>
<p><code>char count: 90</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="s2">"fn x->IO.puts~s(\#{inspect x}|>\#{x}) end.()"</span><span class="o">|></span><span class="k">fn</span> <span class="n">x</span><span class="p">-></span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="sx">~s(</span><span class="si">#{</span><span class="n">inspect</span> <span class="n">x</span><span class="si">}</span><span class="sx">|></span><span class="si">#{</span><span class="n">x</span><span class="si">}</span><span class="sx">)</span> <span class="k">end</span><span class="p">.()</span></code></pre></div>
<h4 id="understanding-1">Understanding</h4>
<p>Typically a Quine takes a String of code and rebuilds it with a “builder”
function. This “builder” function reassembles the code when it is executed.
In the solution @Phani_Mahesh has provided, he uses the following function,
<code>fn x -> IO.puts ~s(#{inspect x}|>#{x}) end.()</code>. If we tidy it up and pass in a
String value we can see what it does:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="n">f</span> <span class="p">=</span> <span class="k">fn</span> <span class="n">x</span> <span class="p">-></span> <span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="sx">~s(</span><span class="si">#{</span><span class="n">inspect</span> <span class="n">x</span><span class="si">}</span><span class="sx">|></span><span class="si">#{</span><span class="n">x</span><span class="si">}</span><span class="sx">)</span> <span class="k">end</span>
<span class="c1">#Function<6.54118792/1 in :erl_eval.expr/5></span>
<span class="n">iex</span><span class="o">></span> <span class="n">f</span><span class="p">.(</span><span class="s2">"BOOM"</span><span class="p">)</span>
<span class="s2">"BOOM"</span><span class="o">|></span><span class="nc">BOOM</span>
<span class="ss">:ok</span></code></pre></div>
<p>As we can see it uses the <code>|></code> pipe operator to pipe a string into a non-String
version of itself. This is interesting as @Phani_Mahesh’s function
<code>fn x -> IO.puts ~s(#{inspect x}|>#{x}) end.()</code> has an empty anonymous function
invocation applied to the end <code>end.()</code> which takes no parameters. Actually it
does take parameters as the <code>|></code> is passing the String value into the first
arity position, therefore there is no need to declare it.</p>
<p>The function also uses the <code>~s</code> sigil to return a String representation of
whatever is within it’s brackets <code>~s(#{inspect x}|>#{x})</code>. Note that the <code>#{}</code>
interpolation will be applied, and that we can use <code>inspect</code> without prefixing
the module e.g. <code>IO.inspect</code>. So the <code>inspect</code> will return the String surrounded
by <code>""</code> quotes.</p>
<p>Finally the String used to pass to the function is almost an exact
representation of the function, apart from the escape characters <code>\</code>. These will
prevent the String from interpolating the value between the <code>#{}</code> characters.</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="s2">"fn x->IO.puts~s(\#{inspect x}|>\#{x}) end.()"</span>
<span class="s2">"fn x->IO.puts~s(\#{inspect x}|>\#{x}) end.()"</span></code></pre></div>
<p>Excellent, well done.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/coderdennis">@CoderDennis</a>:</p>
<p><code>char count: 82</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="s2">"(&(IO.puts~s(\#{inspect&1}|>\#{&1}))).()"</span><span class="o">|></span><span class="p">(</span><span class="o">&</span><span class="p">(</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="sx">~s(</span><span class="si">#{</span><span class="n">inspect</span><span class="ni">&1</span><span class="si">}</span><span class="sx">|></span><span class="si">#{</span><span class="ni">&1</span><span class="si">}</span><span class="sx">)</span><span class="p">)).()</span></code></pre></div>
<h4 id="understanding-2">Understanding</h4>
<p>This solution is based on @Phani_Mahesh’s solution, however @CoderDennis has
taken it further and realised that he can use the anonymous function capture
syntax.</p>
<p>Thus the function:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="s2">"fn x -> IO.puts ~s(</span><span class="si">#{</span><span class="n">inspect</span> <span class="n">x</span><span class="si">}</span><span class="s2"> |> </span><span class="si">#{</span><span class="n">x</span><span class="si">}</span><span class="s2">) end.()"</span></code></pre></div>
<p>Becomes:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">(</span><span class="o">&</span><span class="p">(</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="sx">~s(</span><span class="si">#{</span><span class="n">inspect</span><span class="ni">&1</span><span class="si">}</span><span class="sx"> |> </span><span class="si">#{</span><span class="ni">&1</span><span class="si">}</span><span class="sx">)</span><span class="p">)).()</span></code></pre></div>
<p>Here <code>x</code> becomes the capture parameter <code>&1</code>, and the function syntax <code>fn x -> x
end</code> becomes <code>&(&1)</code>. Finally the whole anonymous function is invoked with
<code>.()</code>, for example, <code>(&(&1)).("BOOM")</code>.</p>
<p>Good thinking, well done.</p>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Wikipedia Quine
<a href="https://en.wikipedia.org/wiki/Quine_%28computing%29">https://en.wikipedia.org/wiki/Quine_%28computing%29</a></li>
<li>Erlang <code>io.format/2</code>: <a href="http://www.erlang.org/doc/man/io.html#format-2">http://www.erlang.org/doc/man/io.html#format-2</a></li>
<li>Elixir docs <code><<>>/1</code> bitstrings:
<a href="http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#%3C%3C%3E%3E/1">http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#%3C%3C%3E%3E/1</a></li>
<li>Elixir docs interpolation & anonymous functions:
<a href="http://elixir-lang.org/getting-started/basic-types.html">http://elixir-lang.org/getting-started/basic-types.html</a></li>
<li>Elixir docs sigils: <a href="http://elixir-lang.org/getting-started/sigils.html">http://elixir-lang.org/getting-started/sigils.html</a></li>
</ul>
<p><a href="/articles/elixir-quine-self-replicating-program/">Elixir Quine Self-Replicating Program</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on November 27, 2015.</p>
/articles/the-elixir-caesar-cipher2015-11-20T00:00:00+00:002015-11-20T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>Write an elixir <a href="https://en.wikipedia.org/wiki/Caesar_cipher">Caesar Cipher</a>
program that will encrypt a message. Your program should prompt the user for
input (<code>IO.gets</code>), and they will enter the following:</p>
<pre><code>number,and a message
</code></pre>
<ul>
<li><code>number</code> - This is the number of characters to shift the Caesar Cipher e.g.
<code>3</code> will shift the alphabet to <code>xyzabcdefghijklmnopqrstuvw</code></li>
<li><code>message</code> - This is alphabetic, lowercase and whitespace is permitted (whitespace will
simply map to whitespace of the encoded text).</li>
</ul>
<p>The output will be lowercase with whitespace.</p>
<p>For example:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="o">--</span><span class="n">enter</span> <span class="n">your</span> <span class="n">code</span> <span class="n">here</span><span class="o">--</span>
<span class="mi">3</span><span class="p">,</span><span class="n">abc</span> <span class="n">defg</span> <span class="n">hijklmnopqrstuvwxyz</span>
<span class="n">xyz</span> <span class="n">abcd</span> <span class="n">efghijklmnopqrstuvw</span></code></pre></div>
<p>The solution that completes this puzzle with the shortest number of characters
wins.</p>
<h3 id="update">Update</h3>
<p>So this weeks <strong>elixirgolf</strong> probably needed a better definition as there
were some queries around cycling of the letters, and the bounds of the numbers
passed in etc. However it did lead to some very creative answers and as our goal
is to use these puzzles as a learning tool, we are going to be lenient.</p>
<h2 id="solutions">Solutions</h2>
<p>There was a lot of buzz around the Caesar cipher puzzle. Many of the
solutions were very creative and influenced one another. As a result the winning
solution was an evolution of ideas. Therefore we will give credit to all those who
contributed.</p>
<h3 id="winner">Winner</h3>
<p>All though not initially the winner @henrik persevered and managed to produce a
working Caesar cipher in a staggering 103 characters! His solution
was built from his own concepts and inspiration from both @gregvaughn and @MPAhrens.</p>
<p>Winner: <a href="https://twitter.com/henrik">@henrik</a></p>
<p><code>char count: 103</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">p</span><span class="p">]=</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">)</span><span class="o">|></span><span class="nc">String</span><span class="p">.</span><span class="n">split</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="k">for</span><span class="p"><<</span><span class="n">c</span><span class="p"><-</span><span class="n">p</span><span class="p">>>,</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="o"><</span><span class="mi">97</span><span class="o">&&</span><span class="n">c</span><span class="o">||</span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="mi">26</span></code></pre></div>
<p><a href="https://twitter.com/henrik">@henrik</a> uses the same approach as
<a href="https://twitter.com/gregvaughn">@gregvaughn</a> to extract the shift number and
message, as well as calculating the mapping cycle (see Greg’s solution for a detailed description).</p>
<p><code>...for<<c<-p>>,do:...</code> Henrik uses the trick <a href="https://twitter.com/MPAhrens">@MPAhrens</a> developed
to convert the message <code>p</code>, into a character list. He does this by wrapping the entire
comprehension body in a binaray e.g. <code><< "a" >></code>. Notice how the comprehension
body <code>c <- p</code> is wrapped in the binary, this saves 12 characters.</p>
<p>Well done and also a big well done to both @gregvaughn and @MPAhrens</p>
<h3 id="second-place">Second Place</h3>
<p><a href="https://twitter.com/gregvaughn">@gregvaughn</a> was in the pole position with his solution.
Although the rules were a bit fuzzy around the bounds of the “shift” number, his solution
met the basic criteria. It also influenced the winning solution.</p>
<p>Second: <a href="https://twitter.com/gregvaughn">@gregvaughn</a></p>
<p><code>char count: 114</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="c1"># for an offset range of -26 to + 26</span>
<span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">p</span><span class="p">]=</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">)</span><span class="o">|></span><span class="nc">String</span><span class="p">.</span><span class="n">split</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="k">for</span> <span class="n">c</span><span class="p"><-</span><span class="n">to_char_list</span><span class="p">(</span><span class="n">p</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="o"><</span><span class="mi">97</span><span class="o">&&</span><span class="n">c</span><span class="o">||</span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="mi">26</span></code></pre></div>
<p>First this solution gets the user’s input <code>IO.gets("")|>String.split","</code>, which
will be the String <code>3,abc def</code> and uses the <code>|></code> operator to pass this String
value to the <code>String.split/2</code> function. Once split around the <code>,</code> the number is
bound to <code>n</code> and the message is bound to the <code>p</code> variable (<code>[n,p]</code>).</p>
<p>The algorithm then takes the message <code>p</code> and converts it into a character list,
which is just a list of ASCII integers <code>to_char_list(p)</code>. So now @gregvaughn
uses comprehension <code>for c<-to_char_list(p),do:...</code> to iterate over each of the
integer values binding them to the variable <code>c</code>.</p>
<p>The real work of the algorithm takes place in the body of the comprehension,
where @gregvaughn calculates the new value of the ASCII integer based on the
“shift” number <code>...do: c<97&&c||97+rem c-71-String.to_integer(n),26</code>. First the
algorithm checks to see if the ASCII value is less than <code>97</code> (the ASCII number for
the letter <code>a</code>) if it is then it must be a space or other none alphabetic
character, if it is then that character is returned <code>c<97&&c</code>. The logic
reads: if <code>c</code> is less than <code>97</code> then return <code>c</code>.</p>
<p>If <code>c</code> is great than <code>97</code> then the algorithm must remap the ASCII character value
based on the “shift” number <code>n</code>, this is triggered from the <code>||</code> (or) operator.
To remap the original letter to the new letter we need to increment the
ASCII value by our value of <code>n</code>, but we need to handle values great than 26
(the number of letters in the Alphabet).</p>
<p>First we take the base value of <code>a</code> which is <code>97</code> and add our “shift” value by
converting our ASCII letter value to a value in the range of <code>26</code> using <code>c-71</code>,
we then subtract our “shift” number from this value while converting it to an
Integer <code>String.to_integer(n)</code>. Finally we find the remainder of <code>26</code> using
<code>rem c-71-String.to_integer(n),26</code>, and add it to <code>97</code>. At last we have the
mapped value of <code>c</code> and we convert this character list to a String using
<code>IO.puts</code>. If the value of <code>n</code> is out of the range <code>-26..+26</code> then we get other
printable characters e.g. when <code>n=30</code> output is <code>]^_ `ab</code></p>
<p>A great solution thanks.</p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<p>Submitted by <a href="https://twitter.com/andrei_here">@andrei_here</a>:</p>
<p><code>char count: 88</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">{</span><span class="bp">_</span><span class="p">,[</span><span class="n">n</span><span class="p">,</span><span class="n">c</span><span class="p">]}=</span><span class="ss">:io</span><span class="p">.</span><span class="n">fread</span><span class="s2">""</span><span class="p">,</span><span class="s1">'~d,~s'</span><span class="p">;</span><span class="ss">:io</span><span class="p">.</span><span class="n">format</span><span class="s2">"~s"</span><span class="p">,[(</span><span class="k">for</span> <span class="n">x</span><span class="p"><-</span><span class="n">c</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">x</span><span class="o">></span><span class="mi">96</span><span class="o">&&</span><span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="mi">97</span><span class="o">+</span><span class="n">n</span><span class="p">,</span><span class="mi">26</span><span class="p">)</span><span class="o">+</span><span class="mi">97</span><span class="o">||</span><span class="n">x</span><span class="p">)]</span></code></pre></div>
<p>This solution isn’t a winner but is definately in the spirit of <strong>elixirgolf</strong>,
which is to use puzzles for learning the <a href="http://elixir-lang.org">elixir
language</a>.</p>
<p>Unfortunately this solution doesn’t cycle the correct way i.e. <code>abc</code> should map to <code>xyz</code>, when
the shift number is <code>3</code>. Also the solution can only handle single words i.e. no
space separation. However it does have some very interesting concepts:</p>
<p><code>{_,[n,c]}=:io.fread"",'~d,~s';</code> Uses the Erlang <a href="http://www.erlang.org/doc/man/io.html#fread-2">io.fread</a>
function that reads characters from the standard input. The format of the input
is defined as <code>'~d,~s'</code> which defines digits, a comma and a single string.
The result of this input is bound to the List variable <code>n</code> (for digits) and <code>c</code> (for the message) the <code>:ok</code>
atom which <code>io.fread</code> returns is ignored with the wildcard <code>_</code>. Note that the
value of <code>c</code> is a character list e.g. <code>'abc'</code>.</p>
<p>@andrei_here then uses the character list to change the mapping of the
characters. As a character list is just a list of integers he is able to use a
comprehension to get each value and “shift” it by 26 characters <code>(for x<-c,do:
x>96&&rem(x-97+n,26)+97||x)</code>. As we still have our data as a character list
@andrei_here uses the Erlang function <code>:io.format</code> to format the character list
into a string, note that it is wrapped in square brackets.</p>
<hr />
<p>Submitted by <a href="https://twitter.com/gregvaughn">@gregvaughn</a></p>
<p><code>char count: 114</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="c1"># for an offset range of -26 to + 26</span>
<span class="c1"># 114 characters</span>
<span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">p</span><span class="p">]=</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">)</span><span class="o">|></span><span class="nc">String</span><span class="p">.</span><span class="n">split</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="k">for</span> <span class="n">c</span><span class="p"><-</span><span class="n">to_char_list</span><span class="p">(</span><span class="n">p</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="o"><</span><span class="mi">97</span><span class="o">&&</span><span class="n">c</span><span class="o">||</span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="mi">26</span>
<span class="c1"># for any offset range</span>
<span class="c1"># 122 characters</span>
<span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">p</span><span class="p">]=</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">)</span><span class="o">|></span><span class="nc">String</span><span class="p">.</span><span class="n">split</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="k">for</span> <span class="n">c</span><span class="p"><-</span><span class="n">to_char_list</span><span class="p">(</span><span class="n">p</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="o"><</span><span class="mi">97</span><span class="o">&&</span><span class="n">c</span><span class="o">||</span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="n">rem</span><span class="p">(</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="mi">26</span><span class="p">),</span><span class="mi">26</span></code></pre></div>
<p><a href="https://gist.github.com/gvaughn/b295e69b4eb302a4fab5">https://gist.github.com/gvaughn/b295e69b4eb302a4fab5</a></p>
<hr />
<p>Submitted by <a href="https://twitter.com/henrik">@henrik</a></p>
<p><code>char count: 124</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">s</span><span class="p">]=</span><span class="nc">String</span><span class="p">.</span><span class="n">split</span> <span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">),</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span> <span class="nc">Regex</span><span class="p">.</span><span class="n">replace</span><span class="sx">~r/\S/</span><span class="p">,</span><span class="n">s</span><span class="p">,</span><span class="k">fn</span><span class="p"><<</span><span class="n">c</span><span class="p">>>-></span><span class="n">q</span><span class="p">=</span><span class="n">c</span><span class="o">-</span><span class="n">rem</span> <span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="mi">26</span><span class="p">;</span><span class="n">q</span><span class="o"><</span><span class="sc">?a</span><span class="o">&&</span><span class="mi">26</span><span class="o">+</span><span class="n">q</span><span class="o">||</span><span class="n">q</span><span class="p">;</span><span class="k">end</span></code></pre></div>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="c1"># If we combine "my" Regex.replace with Greg Vaughn's smarter maths, we get to</span>
<span class="c1"># 121 together:</span>
<span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">s</span><span class="p">]=</span><span class="nc">String</span><span class="p">.</span><span class="n">split</span> <span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">),</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span> <span class="nc">Regex</span><span class="p">.</span><span class="n">replace</span><span class="sx">~r/\S/</span><span class="p">,</span><span class="n">s</span><span class="p">,</span><span class="k">fn</span><span class="p"><<</span><span class="n">c</span><span class="p">>>-></span><span class="sc">?a</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="n">rem</span><span class="p">(</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="mi">26</span><span class="p">),</span><span class="mi">26</span><span class="k">end</span>
<span class="c1"># Just for fun: Using Stream.cycle as suggested by Martin Svalin:</span>
<span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">s</span><span class="p">]=</span><span class="nc">String</span><span class="p">.</span><span class="n">split</span> <span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">),</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span> <span class="nc">Regex</span><span class="p">.</span><span class="n">replace</span><span class="sx">~r/\S/</span><span class="p">,</span><span class="n">s</span><span class="p">,</span><span class="k">fn</span><span class="p"><<</span><span class="n">c</span><span class="p">>>-></span><span class="nc">Enum</span><span class="p">.</span><span class="n">at</span> <span class="nc">Stream</span><span class="p">.</span><span class="n">cycle</span><span class="p">(</span><span class="sc">?z</span><span class="p">..</span><span class="sc">?a</span><span class="p">),</span><span class="sc">?z</span><span class="o">-</span><span class="n">c</span><span class="o">+</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="k">end</span>
<span class="c1"># Just for fun: Using Code.eval_string to convert to int and char list at the</span>
<span class="c1"># same time… (The "do" block contents are borrowed from Greg Vaughn)</span>
<span class="p">{</span><span class="n">s</span><span class="p">,</span><span class="ss">n</span><span class="p">:</span> <span class="n">n</span><span class="p">}=</span><span class="nc">Code</span><span class="p">.</span><span class="n">eval_string</span> <span class="nc">String</span><span class="p">.</span><span class="n">replace</span><span class="p">(</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">),</span><span class="sx">~r/(.+),(.*)</span><span class="se">\n</span><span class="sx">/</span><span class="p">,</span><span class="s2">"n=\\1;'\\2'"</span><span class="p">);</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="k">for</span> <span class="n">c</span><span class="p"><-</span><span class="n">s</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="n">c</span><span class="o"><</span><span class="mi">97</span><span class="o">&&</span><span class="n">c</span><span class="o">||</span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="n">rem</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="mi">26</span><span class="p">),</span><span class="mi">26</span>
<span class="c1"># Just for fun: if we limit to single digits we can do:</span>
<span class="p"><<</span><span class="n">n</span><span class="p">,</span><span class="sc">?,</span><span class="p">,</span><span class="n">s</span><span class="p">::</span><span class="n">bits</span><span class="p">>>=</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="s2">""</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span> <span class="nc">Regex</span><span class="p">.</span><span class="n">replace</span><span class="sx">~r/\S/</span><span class="p">,</span><span class="n">s</span><span class="p">,</span><span class="k">fn</span><span class="p"><<</span><span class="n">c</span><span class="p">>>-></span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="mi">71</span><span class="o">-</span><span class="n">n</span><span class="o">+</span><span class="sc">?0</span><span class="p">,</span><span class="mi">26</span><span class="k">end</span>
<span class="c1"># or even</span>
<span class="p"><<</span><span class="n">n</span><span class="p">,</span><span class="sc">?,</span><span class="p">,</span><span class="n">s</span><span class="p">::</span><span class="n">bits</span><span class="p">>>=</span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="s2">""</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span> <span class="nc">Regex</span><span class="p">.</span><span class="n">replace</span><span class="sx">~r/\S/</span><span class="p">,</span><span class="n">s</span><span class="p">,</span><span class="k">fn</span><span class="p"><<</span><span class="n">c</span><span class="p">>>-></span><span class="mi">97</span><span class="o">+</span><span class="n">rem</span> <span class="n">c</span><span class="o">-</span><span class="n">n</span><span class="o">-</span><span class="mi">23</span><span class="p">,</span><span class="mi">26</span><span class="k">end</span>
<span class="c1"># If you don't need to "wrap" (so you can do d->a but not a->x).</span>
<span class="c1"># `import String; … split … to_integer` is the exact same char count as not</span>
<span class="c1"># importing.</span>
<span class="kn">import</span> <span class="nc">String</span><span class="p">;[</span><span class="n">n</span><span class="p">,</span><span class="n">s</span><span class="p">]=</span><span class="n">split</span> <span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">),</span><span class="s2">","</span><span class="p">;</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span> <span class="nc">Regex</span><span class="p">.</span><span class="n">replace</span><span class="sx">~r/\S/</span><span class="p">,</span><span class="n">s</span><span class="p">,</span><span class="k">fn</span><span class="p"><<</span><span class="n">c</span><span class="p">>>-></span><span class="n">c</span><span class="o">-</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="k">end</span></code></pre></div>
<p>For more details see @henrik’s gist: <a href="https://gist.github.com/henrik/f7a58f2bc02cd4b20099">https://gist.github.com/henrik/f7a58f2bc02cd4b20099</a></p>
<hr />
<p>Submitted by <a href="https://twitter.com/MPAhrens">@MPAhrens</a></p>
<p><code>char count: 131</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">fn</span><span class="p">[</span><span class="n">n</span><span class="p">,</span><span class="n">m</span><span class="p">]-></span><span class="k">for</span><span class="p"><<</span><span class="n">x</span><span class="p"><-</span><span class="n">m</span><span class="p">>>,</span><span class="ss">into</span><span class="p">:</span> <span class="s2">""</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="p"><<(</span><span class="k">if</span> <span class="n">x</span><span class="o"><</span><span class="sc">?a</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="mi">32</span><span class="p">,</span><span class="ss">else</span><span class="p">:</span> <span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="o">-</span><span class="sc">?a</span><span class="p">,</span><span class="mi">26</span><span class="p">)</span><span class="o">+</span><span class="sc">?a</span><span class="p">)>></span><span class="k">end</span><span class="p">.(</span><span class="nc">String</span><span class="p">.</span><span class="n">split</span> <span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="p">(</span><span class="s2">""</span><span class="p">),</span><span class="s2">","</span><span class="p">)</span></code></pre></div>
<p>The solution provided by @MPAhrens works as follows. He creates a giant
anonymous function that he calls, inline, with an <code>IO.gets ""</code> call which he
splits. The function broken down looks like this:</p>
<pre><code>fn [n,m] -> [n,m] end.(String.split IO.gets(""),"," )
</code></pre>
<p>He then uses a comprehension that uses the very interesting technique of
wrapping the entire body in a binary <code><<x<-m>></code> this has the benfit of
converting the message string <code>m</code> to a character list and binding each integer
to <code>x</code>. His comprehension also uses the <code>into: ""</code> function, which returns a
function that collects values alongside the initial accumulation value.
Basically for each iteration of the comprehension the character value is
appended to the string <code>""</code>.</p>
<p>The comprehension body then does the mapping calculation:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="p"><<(</span><span class="k">if</span> <span class="n">x</span><span class="o"><</span><span class="sc">?a</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="mi">32</span><span class="p">,</span><span class="ss">else</span><span class="p">:</span> <span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="o">+</span><span class="nc">String</span><span class="p">.</span><span class="n">to_integer</span><span class="p">(</span><span class="n">n</span><span class="p">)</span><span class="o">-</span><span class="sc">?a</span><span class="p">,</span><span class="mi">26</span><span class="p">)</span><span class="o">+</span><span class="sc">?a</span><span class="p">)>></span></code></pre></div>
<p>Again he wraps the entire body in a binary <code><<>></code>, then he uses an <code>if/else</code>
function to determine if the message character value is below the letter
<code>a</code> (ASCII <code>97</code>) if it is, it assumes that it is a space character and the ASCII value
<code>32</code> is returned. Otherwise @MPAhrens calculates the new character mapping.</p>
<p>The calculation finds the remainder <code>rem(X_VALUE, 26)</code> of the current character ASCII value
<code>x</code> and adds the “shift” number (while converting it to an integer) less the
ASCII value of <code>?a</code>. The result is then added to the ASCII value of <code>?a</code>.</p>
<p>Great solution and we really liked the interesting use of binaries.</p>
<p><a href="https://gist.github.com/mpahrens/9262c76aa5388834a0d9">https://gist.github.com/mpahrens/9262c76aa5388834a0d9</a></p>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Caesar Cipher on Wikipedia: <a href="https://en.wikipedia.org/wiki/Caesar_cipher">https://en.wikipedia.org/wiki/Caesar_cipher</a></li>
<li>Erlang <code>:io.fread</code>: <a href="http://www.erlang.org/doc/man/io.html#fread-2">http://www.erlang.org/doc/man/io.html#fread-2</a></li>
<li>Comprehension docs <code>for</code>:
<a href="http://elixir-lang.org/getting-started/comprehensions.html">http://elixir-lang.org/getting-started/comprehensions.html</a></li>
<li>More comprehension docs:
<a href="http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#for/1">http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#for/1</a></li>
<li>Elixir <code>into</code> collectable function:
<a href="http://elixir-lang.org/docs/stable/elixir/Collectable.html#into/1">http://elixir-lang.org/docs/stable/elixir/Collectable.html#into/1</a></li>
<li>Elixir <code><<>>/1</code> bitstrings:
<a href="http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#%3C%3C%3E%3E/1">http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#%3C%3C%3E%3E/1</a></li>
</ul>
<p><a href="/articles/the-elixir-caesar-cipher/">The Elixir Caesar Cipher</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on November 20, 2015.</p>
/articles/elixir-fizzbuzz-golf2015-11-17T00:00:00+00:002015-11-17T00:00:00+00:00elixirgolfelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>Write an elixir program that will print the numbers from <code>1</code> to <code>100</code>,
replacing numbers divisible by <code>3</code> with <code>Fizz</code>,
numbers divisible by <code>5</code> with <code>Buzz</code> and numbers divisible by both <code>3</code> and <code>5</code> with <code>FizzBuzz</code>.
All other numbers should be returned as normal.</p>
<p>For example:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="o">--</span><span class="n">enter</span> <span class="n">your</span> <span class="n">code</span> <span class="n">here</span><span class="o">--</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="nc">Fizz</span>
<span class="mi">4</span>
<span class="nc">Buzz</span>
<span class="nc">Fizz</span>
<span class="mi">7</span>
<span class="mi">8</span>
<span class="nc">Fizz</span>
<span class="nc">Buzz</span>
<span class="mi">11</span>
<span class="nc">Fizz</span>
<span class="mi">13</span>
<span class="mi">14</span>
<span class="nc">FizzBuzz</span>
<span class="p">..</span>
<span class="p">..</span>
<span class="mi">97</span>
<span class="mi">98</span>
<span class="nc">Fizz</span>
<span class="nc">Buzz</span></code></pre></div>
<h2 id="solutions">Solutions</h2>
<h3 id="winner">Winner</h3>
<p>The winning solution was submitted by <a href="https://twitter.com/andrei_here">@andrei_here</a>:</p>
<p><code>char count: 89</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span><span class="o">></span> <span class="k">for</span> <span class="n">x</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="sc">?d</span><span class="p">,</span><span class="n">z</span><span class="p">=(</span><span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span><span class="o"><</span><span class="mi">1</span><span class="o">&&</span><span class="s2">"Fizz"</span><span class="o">||</span><span class="s2">""</span><span class="p">)</span><span class="o"><></span><span class="p">(</span><span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="mi">5</span><span class="p">)</span><span class="o"><</span><span class="mi">1</span><span class="o">&&</span><span class="s2">"Buzz"</span><span class="o">||</span><span class="s2">""</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="n">z</span><span class="o">==</span><span class="s2">""</span><span class="o">&&</span><span class="n">x</span><span class="o">||</span><span class="n">z</span>
<span class="mi">1</span>
<span class="mi">2</span>
<span class="p">..</span>
<span class="p">..</span>
<span class="mi">97</span>
<span class="mi">98</span>
<span class="nc">Fizz</span>
<span class="nc">Buzz</span></code></pre></div>
<p>This solution uses a comprehension <code>for x<-1..</code> to iterate over the range of numbers.
The <code>?d</code> is a clever trick that saves one character, this is because the character <code>'d'</code>
is <code>100</code> in ASCII and by using the <code>?</code> we get the integer value of the character.</p>
<p>Comprehensions can consist of between 2 and 3 components: a generator, a filter (optional) and a body.
In this solution Andrei abuses the filter, where he builds up the string
<code>"FizzBuzz"</code> and binds it to the variable <code>z</code>.
The <code>"Fizz"</code> string is determined when the range passes a value <code>x</code> into the
<code>rem</code> function. If <code>x / 3</code> then the remainder is <code>0</code>. Andrei manages to save one
character by using <code><1</code> instead of <code>==0</code>. If <code>x</code> is divisible by <code>3</code> then the
<code>&&</code> returns a <code>"Fizz"</code> string otherwise the <code>||</code> returns an empty string.</p>
<p>The <code><></code> concatenates the <code>"Fizz"</code> string with a similar <code>"Buzz"</code> string, at
which point the body of the comprehension is called. All this does is check to
see whether the <code>z</code> is an empty string if so it returns the value of the
variable <code>x</code> otherwise it returns the appropriate <code>"Fizz", "Buzz", "FizzBuzz"</code>.</p>
<p>This all weighs in at 89 characters! Well done.</p>
<p>To see some of Andrei’s other attempts checkout his Gist:
<a href="https://gist.github.com/zyro/e60e75ef3a3c3f08e5ef">https://gist.github.com/zyro/e60e75ef3a3c3f08e5ef</a></p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<p>Submitted by <a href="https://twitter.com/henrik">@henrik</a>:</p>
<p><code>char count: 99</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="sc">?d</span><span class="p">,</span><span class="n">r</span><span class="p">=</span><span class="o">&</span><span class="p">(</span><span class="n">rem</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="ni">&1</span><span class="p">)</span><span class="o">==</span><span class="mi">0</span><span class="o">&&</span><span class="nc">IO</span><span class="p">.</span><span class="n">write</span><span class="ni">&2</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="p">(</span><span class="n">f</span><span class="p">=</span><span class="n">r</span><span class="p">.(</span><span class="mi">3</span><span class="p">,</span><span class="s2">"Fizz"</span><span class="p">);</span><span class="n">b</span><span class="p">=</span><span class="n">r</span><span class="p">.(</span><span class="mi">5</span><span class="p">,</span><span class="s2">"Buzz"</span><span class="p">);</span><span class="n">f</span><span class="o">||</span><span class="n">b</span><span class="o">||</span><span class="n">r</span><span class="p">.(</span><span class="mi">1</span><span class="p">,</span><span class="n">n</span><span class="p">);</span><span class="ss">:io</span><span class="p">.</span><span class="n">nl</span><span class="p">)</span></code></pre></div>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="sc">?d</span><span class="p">,</span><span class="n">r</span><span class="p">=</span><span class="o">&</span><span class="p">(</span><span class="n">rem</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="ni">&1</span><span class="p">)</span><span class="o">==</span><span class="mi">0</span><span class="o">&&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="ni">&2</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="n">r</span><span class="p">.(</span><span class="mi">15</span><span class="p">,</span><span class="s2">"FizzBuzz"</span><span class="p">)</span><span class="o">||</span><span class="n">r</span><span class="p">.(</span><span class="mi">3</span><span class="p">,</span><span class="s2">"Fizz"</span><span class="p">)</span><span class="o">||</span><span class="n">r</span><span class="p">.(</span><span class="mi">5</span><span class="p">,</span><span class="s2">"Buzz"</span><span class="p">)</span><span class="o">||</span><span class="n">r</span><span class="p">.(</span><span class="mi">1</span><span class="p">,</span><span class="n">n</span><span class="p">)</span></code></pre></div>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="k">for</span> <span class="n">n</span><span class="p"><-</span><span class="mi">1</span><span class="p">..</span><span class="sc">?d</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="nc">Enum</span><span class="p">.</span><span class="n">find</span> <span class="p">[{</span><span class="mi">15</span><span class="p">,</span><span class="s2">"FizzBuzz"</span><span class="p">},{</span><span class="mi">3</span><span class="p">,</span><span class="s2">"Fizz"</span><span class="p">},{</span><span class="mi">5</span><span class="p">,</span><span class="s2">"Buzz"</span><span class="p">},{</span><span class="mi">1</span><span class="p">,</span><span class="n">n</span><span class="p">}],</span><span class="k">fn</span><span class="p">({</span><span class="n">d</span><span class="p">,</span><span class="n">t</span><span class="p">})-></span><span class="n">rem</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">d</span><span class="p">)</span><span class="o">==</span><span class="mi">0</span><span class="o">&&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="k">end</span></code></pre></div>
<p>Checkout Henrik’s Gist and see further explainations:
<a href="https://gist.github.com/henrik/6ca434c0c5cb66ed29d7">https://gist.github.com/henrik/6ca434c0c5cb66ed29d7</a></p>
<hr />
<p>Submitted by <a href="https://twitter.com/emson">@emson</a>:</p>
<p><code>char count: 129</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">s</span><span class="p">=</span><span class="o">&</span><span class="p">(</span><span class="ni">&1</span><span class="o">==</span><span class="mi">1</span><span class="o">&&</span> <span class="ni">&2</span><span class="o">||</span><span class="nc">String</span><span class="p">.</span><span class="n">slice</span><span class="p">(</span><span class="s2">"FizzBuzz"</span><span class="p">,</span><span class="ni">&1</span><span class="o">==</span><span class="mi">10</span><span class="o">&&</span><span class="mi">4</span><span class="o">||</span><span class="mi">0</span><span class="p">,</span><span class="ni">&1</span><span class="o">==</span><span class="mi">6</span><span class="o">&&</span><span class="mi">4</span><span class="o">||</span><span class="mi">8</span><span class="p">));</span><span class="nc">Enum</span><span class="p">.</span><span class="n">each</span> <span class="mi">1</span><span class="p">..</span><span class="sc">?d</span><span class="p">,</span><span class="o">&</span><span class="nc">IO</span><span class="p">.</span><span class="n">puts</span> <span class="n">s</span><span class="p">.(</span><span class="n">rem</span><span class="p">(</span><span class="n">trunc</span><span class="p">(</span><span class="ss">:math</span><span class="p">.</span><span class="n">pow</span> <span class="ni">&1</span><span class="p">,</span><span class="mi">4</span><span class="p">),</span><span class="o">-</span><span class="mi">15</span><span class="p">),</span><span class="ni">&1</span><span class="p">)</span></code></pre></div>
<p>This attempt is influenced by the HackerRank article
<a href="https://blog.hackerrank.com/fizzbuzz/">https://blog.hackerrank.com/fizzbuzz/</a>.
Here we create an anonymous function that slices the <code>"FizzBuzz"</code> string
in different ways according to the numbers passed to it. The numbers are
generated using <a href="https://en.wikipedia.org/wiki/Fermat's_little_theorem">Fermat’s little
theorem</a>, which proved to
be an interesting way of calculating whether the numbers cleanly divide the
values from 1 to 100.</p>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Elixir docs <code>Enum.at</code>:
<a href="http://elixir-lang.org/docs/stable/elixir/Enum.html#at/3">http://elixir-lang.org/docs/stable/elixir/Enum.html#at/3</a></li>
<li>Comprehension docs <code>for</code>:
<a href="http://elixir-lang.org/getting-started/comprehensions.html">http://elixir-lang.org/getting-started/comprehensions.html</a></li>
<li>More comprehension docs:
<a href="http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#for/1">http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#for/1</a></li>
<li>HackerRank FizzBuzz: <a href="https://blog.hackerrank.com/fizzbuzz/">https://blog.hackerrank.com/fizzbuzz/</a></li>
<li>Fermat’s little theorem:
<a href="https://en.wikipedia.org/wiki/Fermat's_little_theorem">https://en.wikipedia.org/wiki/Fermat's_little_theorem</a></li>
</ul>
<p><a href="/articles/elixir-fizzbuzz-golf/">Elixir FizzBuzz Golf</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on November 17, 2015.</p>
/articles/number-to-even-odd-string2015-11-11T00:00:00+00:002015-11-11T00:00:00+00:00Ben Emsonelixirgolf@emson.co.uk
<h2 id="instructions">Instructions</h2>
<p>Use the <code>IO.gets</code> function to gather an integer from user input and return
a string where EACH digit is converted to an <code>"e"</code> or an <code>"o"</code> string character.
This string character is determined by whether the integer digit at that index
is odd or even.</p>
<p>For example:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="o">></span> <span class="o">--</span><span class="n">enter</span> <span class="n">your</span> <span class="n">code</span> <span class="n">here</span><span class="o">--</span>
<span class="mi">13387</span>
<span class="s2">"oooeo"</span></code></pre></div>
<h2 id="solutions">Solutions</h2>
<h3 id="winner">Winner</h3>
<p>The winning solution was submitted by <a href="https://twitter.com/henrik">@henrik</a>:</p>
<p><code>char count: 66</code></p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="n">iex</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span><span class="o">></span> <span class="s2">"</span><span class="si">#{</span><span class="k">for</span> <span class="n">x</span><span class="p"><-(</span><span class="n">to_char_list</span> <span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="s1">''</span><span class="p">),</span><span class="n">x</span><span class="o">></span><span class="mi">10</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="nc">Enum</span><span class="p">.</span><span class="n">at</span><span class="s1">'eo'</span><span class="p">,</span><span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span><span class="si">}</span><span class="s2">"</span>
<span class="mi">12231</span>
<span class="s2">"oeeoo"</span></code></pre></div>
<p>Starting in the middle it <code>IO.gets</code> the user’s input, and converts this binary
string into a character list (a list of integer values). Note that the last
character will be a <code>\n</code> which is ASCII value <code>10</code>.</p>
<p>It uses a comprehension (<code>for x<-...</code>) to take each integer from our list and
apply the <code>x>10</code> filter. As all the string values are greater than <code>10</code> they
pass through, where as the <code>\n</code> escapes. The values are then passed to the body
of our comprehension <code>do: Enum.at....</code></p>
<p>In the body, the integer value bound to <code>x</code> is divided by <code>2</code> determining whether it is even or
odd. This <code>rem</code>ainder value is then used by <code>Enum.at</code> to return the
corresponding <code>"e"</code> or <code>"o"</code> character.</p>
<p>Finally the code is wrapped in an interpolated string <code>"#{}"</code> to convert the
character list into a binary string.</p>
<h3 id="honourable-mentions">Honourable mentions</h3>
<p>Submitted by <a href="https://twitter.com/henrik">@henrik</a>:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="s2">"</span><span class="si">#{</span><span class="k">for</span> <span class="n">x</span><span class="p"><-</span><span class="s1">'13387'</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="nc">Enum</span><span class="p">.</span><span class="n">at</span><span class="s1">'eo'</span><span class="p">,</span><span class="n">rem</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span><span class="si">}</span><span class="s2">"</span></code></pre></div>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="s2">"</span><span class="si">#{</span><span class="nc">Enum</span><span class="p">.</span><span class="n">map</span><span class="s1">'13387'</span><span class="p">,</span><span class="o">&</span><span class="p">%{</span><span class="mi">0</span><span class="p">=></span><span class="sc">?e</span><span class="p">,</span><span class="mi">1</span><span class="p">=></span><span class="sc">?o</span><span class="si">}</span><span class="s2">[rem(&1,2)]}"</span></code></pre></div>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="s2">"</span><span class="si">#{</span><span class="k">for</span> <span class="n">x</span><span class="p"><-</span><span class="s1">'13387'</span><span class="p">,</span><span class="ss">do</span><span class="p">:</span> <span class="nc">Enum</span><span class="p">.</span><span class="n">at</span><span class="s1">'eoeoeoeoeo'</span><span class="p">,</span><span class="n">x</span><span class="o">-</span><span class="mi">48</span><span class="si">}</span><span class="s2">"</span></code></pre></div>
<hr />
<p>Submitted by <a href="https://twitter.com/meadsteve">@meadsteve</a>:</p>
<div class="highlight"><pre><code class="language-elixir" data-lang="elixir"><span class="kn">import</span> <span class="nc">String</span><span class="p">;</span><span class="k">for</span> <span class="n">s</span><span class="p"><-</span><span class="ss">:stdio</span><span class="o">|></span><span class="nc">IO</span><span class="p">.</span><span class="n">gets</span><span class="o">|></span><span class="n">codepoints</span><span class="p">,</span><span class="n">s</span> <span class="o">!=</span><span class="s2">"</span><span class="se">\n</span><span class="s2">"</span><span class="p">,</span><span class="n">x</span><span class="p">=</span><span class="n">s</span><span class="o">|></span><span class="n">to_integer</span><span class="o">|></span><span class="n">rem</span><span class="p">(</span><span class="mi">2</span><span class="p">),</span><span class="ss">do</span><span class="p">:</span> <span class="nc">Enum</span><span class="p">.</span><span class="n">at</span><span class="s1">'eo'</span><span class="p">,</span><span class="n">x</span></code></pre></div>
<hr />
<h2 id="resources">Resources</h2>
<ul>
<li>Elixir docs <code>Enum.at</code>:
<a href="http://elixir-lang.org/docs/stable/elixir/Enum.html#at/3">http://elixir-lang.org/docs/stable/elixir/Enum.html#at/3</a></li>
<li>Comprehension docs <code>for</code>:
<a href="http://elixir-lang.org/getting-started/comprehensions.html">http://elixir-lang.org/getting-started/comprehensions.html</a></li>
<li>More comprehension docs:
<a href="http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#for/1">http://elixir-lang.org/docs/stable/elixir/Kernel.SpecialForms.html#for/1</a></li>
<li>String interpolation:
<a href="http://elixir-lang.org/getting-started/basic-types.html#strings">http://elixir-lang.org/getting-started/basic-types.html#strings</a></li>
</ul>
<p><a href="/articles/number-to-even-odd-string/">Number to Even/Odd String</a> was originally published by elixirgolf at <a href="">elixirgolf.com</a> on November 11, 2015.</p>