Tim Visée

lazymc

Thu, 11 Nov 2021 00:00:00 +0000
Put your Minecraft server to rest when idle. </blockquote>

Visit project page on GitHub</a></li> </ul>
lazymc</code> puts your Minecraft server to rest when idle, and wakes it up when players connect.
Some Minecraft servers (especially modded) use an insane amount of resources when nobody is playing. lazymc helps by stopping your server when idle, until a player connects again.
lazymc functions as proxy between clients and the server. It handles all incoming status connections until the server is started and then transparently relays/proxies the rest. All without them noticing. </video>
Click to see screenshots</summary></a> </a> </a> </a> </details> Features</a></li> Requirements</a></li> Usage</a></li> Compile from source</a></li> </ul> View more on the project pages over at: GitHub</a></li> GitLab</a></li> </ul>


Merge Mania
Mon, 11 Oct 2021 00:00:00 +0000
</a></p>

Visit project page on GitHub</a></li>
</ul>
A real-time team based merging/trading game to play using your phone.</p>

Played in teams for a set time period</li>
Players, in a team, use their phone to play the game</li>
Each team has money</em>, energy</em> and an inventory grid with their items</em></li>
Factory items, on your grid, produce items at a set interval, on your grid</li>
Merge</strong> two items of the same type into a better item</li>
Discover new items and tiers as you play</li>
Players run between outposts to earn energy</em></li>
Energy</em> is used to buy additional factories</em> on the grid, producing new items</li>
Buy lots of factories to gain items as quickly as possible</li>
Merge & sell smart to earn as much as possible</li>
After playing, the team earning the most wins</li>
</ul>

    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>


    
        
        
        
        
    </a>
</p>
</p>


Player explanation</a></li>
How to use</a></li>
</ul>
View more on the project pages over at:</em></p>

GitHub</a></li>
GitLab</a></li>
</ul>


Firefox tricks: efficient QuantumBar usage
Tue, 07 Sep 2021 00:00:00 +0000

    
        
        
        
        
    </a>
</p>
The Firefox QuantumBar</a> (formerly AwesomeBar, or just
address bar) is surprisingly capable. There's a lot you can do with it to
quickly navigate through your browser. It's one of the things which makes
Firefox so comfy to me.</p>
I like to be as quick as possible without leaving the keyboard. For this, I use
scope characters</em>, bookmark keywords</em>, and DuckDuckGo bangs</em>. In this article
I'll go through these features and hope to show you something new, no add-ons
required.</p>
</span>
Restrict characters, scopes
    </a>

</h2>
By default, when you type search terms in the address bar, the suggestion list
shows various suggestions types, including search results, bookmarks, and open
tabs. I usually find these to be spot-on already.</p>
When looking for a specific type of result through, like an open tab, you can
speed up the process by adding special characters with a whitespace in the
address bar before (or after) your search terms. Firefox is vague about its
naming, so I call these scope characters.</p>
Available scope characters:</p>

%</code>: limit to open tabs</li>
^</code>: limit to browser history</li>
*</code>: limit to bookmarks</li>
+</code>: limit to tagged bookmarks</li>
#</code>: limit to pages where search terms are part of title or tag</li>
$</code>: limit to pages where search terms are part of the address</li>
?</code>: limit to search suggestions</li>
</ul>
Imagine you want to jump to an open Google tab, simply type:</p>
% google
</span></code></pre>

    
        
        
        
        
    </a>
</p>
Or you want to find an MDN</em> bookmark on Progressive web apps</em> you added to
your huge bookmarks collection ages ago. Proton</a> even shows a fancy
hint now:</p>
* mdn pwa
</span></code></pre>

    
        
        
        
        
    </a>
</p>
Simple! By the way, use Ctrl</kbd>+L</kbd></kbd> or
F6</kbd> to quickly focus the address bar.</p>
Firefox documentation lists this feature here</a>. It has changed a
bit during Firefox's lifetime as you can see here</a>.</p>
Bookmark keywords, smart triggers
    </a>

</h2>
Almost every browser supports bookmarks. However, Firefox allows you to
configure a bookmark keyword to make them easily accessible and interactive.</p>
The keyword acts as a trigger in the address bar. You basically extend the scope
characters above with your bookmarks to your liking.</p>
You may add a new bookmark through the bookmark manager (Ctrl</kbd>+Shift</kbd>+O</kbd></kbd>) or editing an
existing one, then the Keyword</em> field shows up. This is where you specify your
keyword term to trigger it with. You may put %s</code> in the bookmark URL, which
will be replaced with what you type after the trigger keyword, making them
interactive.</p>

    
        
        
        
        
    </a>
</p>
The simplest example would be to quickly jump to your favorite site. Set a
bookmark with the d</code> keyword. Type d</code> in your address bar and hit enter to
instantly jump to your bookmarked webpage. Though this isn't so interesting.</p>
Here are some better examples I use a lot:</p>
Bookmark: specific search engine
    </a>

</h4>
Quickly search with a specific search engine:</p>
d what is the answer to life
</span>wiki bikeshedding
</span></code></pre>

    
        
        
        
        
    </a>
</p>

Tap to see bookmark config</summary>

Keyword: d</code>

Url: https://duckduckgo.com/?q=%s</code></p>
Keyword: wiki</code>

Url: https://en.wikipedia.org/wiki/Special:Search/%s</code></p>
</blockquote>
</details>
Bookmark: jump to subreddit
    </a>

</h4>
Quickly jump to your favorite subreddit:</p>
r/ linuxmasterrace
</span></code></pre>

    
        
        
        
        
    </a>
</p>

Tap to see bookmark config</summary>

Keyword: r/</code>

Url: https://reddit.com/r/%s</code></p>
</blockquote>
</details>
Bookmark: translate
    </a>

</h4>
Quickly translate something between English and Dutch:</p>
ennl bikeshedding
</span>nlen fietsenstalling
</span></code></pre>

    
        
        
        
        
    </a>
</p>

Tap to see bookmark config</summary>

Keyword: ennl</code>

Url: _{^{https://translate.google.com/?sl=en&tl=nl&op=translate&text=%s</code></sup></sub></p>}}
Keyword: nlen</code>

Url: _{^{https://translate.google.com/?sl=nl&tl=en&op=translate&text=%s</code></sup></sub></p>
</blockquote>
</details>}}DuckDuckGo bangs
    </a>

</h2>
For the final trick, we use the default search engine to extend address bar
functionality.</p>
DuckDuckGo</a> provides an insane amount of !bangs</code></a>. These
function similar to bookmark keywords, but are preconfigured. DuckDuckGo has
more than 13K bangs available</a> for popular sites, most you can come up
with just work</em>. Simply prefix your search terms with the appropriate bang and
hit Enter</kbd>. Super powerful!</p>
The only caveat is that it requires you to
change</a> your default search engine to DuckDuckGo
to use it easily.</p>
Here are some example queries:</p>

!g Amsterdam</code></a>: Search Amsterdam</code> via Google, if DuckDuckGo couldn't find it</li>
!maps Amsterdam</code></a>: Show Amsterdam</code> on Google Maps</li>
!so Rust string character count</code></a>: Find a solution on StackOverflow</li>
!rust String</code></a>: Search String</code> in Rust documentation</li>
!timer 3m</code></a>: Set a 3-minute timer</li>
!wa solve x^2+4x+6=0</code></a>: Solve equation with WolframAlpha</li>
!bangs</code></a>: there's so many more...</em></li>
</ul>
Lastly, not clearly listed, DuckDuckGo has an I'm Feeling Ducky</em> feature using
just the !</code> bang. It will redirect you to the first search result instantly:</p>

! Coldplay magic</code></a></li>
! jamming cat</code></a></li>
! timvisee</code></a></li>
</ul>
I hope you've learned something new and useful to be just that little bit more
efficient using the Firefox QuantumBar.</p>


Send
Wed, 19 May 2021 00:00:00 +0000

    
        
        
        
        
    </a>
</p>

Try it out: https://send.vis.ee/</a></li>
Visit project page on GitHub</a></li>
</ul>
Send lets you share files with end-to-end encryption and a link that
automatically expires. So you can keep what you share private and make sure your
stuff doesn’t stay online forever.</p>
Send has originally been developed by Mozilla, but was discontinued. I forked
the project as a community effort to keep the project up-to-date and alive.</p>
I provide a public instance</a> as part of this effort. Find
a list of other instances here</a>. Or host your own</a>
instance.</p>

View more on the project pages over at:</em></p>

GitHub</a></li>
GitLab</a></li>
</ul>
Also see these related projects:</em></p>

ffsend</code></a> (command-line interface for Send)</span></li>
</ul>


Elegant bash conditionals
Tue, 02 Mar 2021 00:00:00 +0000
The if-statement is a very basic thing, not just in bash, but in all of programming.
I see them used quite a lot in shell scripts,
even though in many cases they can be replaced with something much more elegant.</p>
In this rather short article, I'll show how control operators can be used
instead.
Many probably know about this, but don't realize how to use them nicely.
This will help you write cleaner shell scripts in the future.</p>
Here is what a simple if-statements looks like in bash:</p>
if </span>[</span> expression </span>]
</span>then
</span>    </span>command
</span>fi
</span>
</span># or
</span>if </span>[</span> expression </span>]</span>; then </span>command</span>; fi
</span></code></pre>
Ughh. Let's improve!</p>
</span>Control operators
    </a>

</h2>
Bash provides control operators</a> to build sequences of
commands.
Some of these are conditional and allow logical branching based on the success
state of the last run command.</p>
We will just focus on these two logical operators:</p>

&&</code>: the AND operator, run the following command only if previous succeeded</li>
||</code>: the OR operator, run the following command only if previous failed</li>
</ul>
Exit codes
    </a>

</h2>
You might wonder how bash considers whether a command succeeded.
This is where exit codes</a> come in.
When a program exits a numeric status code is returned.
A value of 0</code> means the program succeeded, any other value means it failed.</p>
The exit code is normally hidden.
The status of the last run command is stored in the ?</code> variable.
You may inspect it by invoking:</p>
echo </span>$</span>?
</span></code></pre>
E.g., listing with ls</code> normally returns 0</code>, but this value differs if the
directory doesn't exist or if an error occurred.</p>
ls ~</span>/            </span># exit code: 0
</span>ls ~</span>/nonexistent </span># exit code: 2
</span></code></pre>
This will function similarly to almost any program.</p>
Chaining commands
    </a>

</h2>
Let's go over some examples to show how these control operators can be used.</p>
Imagine you want to source</a> the ~/.profile</code> file, but only if it
is readable:</p>
if </span>[ </span>-r </span>~</span>/.profile </span>]</span>; then
</span>    </span>source </span>~</span>/.profile
</span>fi
</span></code></pre>
We can simplify this using control operators:</p>
[ </span>-r </span>~</span>/.profile </span>] </span>&& </span>. </span>~</span>/.profile
</span></code></pre>
Only if the readability check expression is truthful/succeeds, we want to source
the file, so we use the &&</code> operator.</p>


To require invoking user to be root, we can do the following:</p>
[ </span>$</span>EUID </span>-ne</span> 0 </span>] </span>&& </span>echo</span> You must be root </span>&& </span>exit</span> 1
</span></code></pre>
The echo</code> command exists with 0</code>, so this propagates to exit</code> if the
first expression is truthful.</p>


If we'd like to print our profile file contents with a success message,
or an error message on reading failure, we can do the following:</p>
cat ~</span>/.profile </span>&& </span>echo</span> This is your profile </span>|| </span>echo</span> Failed to read profile
</span></code></pre>


You can make these command sequences as long as you want. Useful for
building install scripts that go through a series of steps. You could define
bash functions for each step and orchestrate the installation like this:</p>
init </span>&& </span>configure </span>&& </span>install </span>&& </span>cleanup </span>|| </span>echo</span> Install failed
</span></code></pre>
Or format it differently to make long sequences better readable:</p>
init </span>&&
</span>  </span>configure </span>&&
</span>  </span>install </span>&&
</span>  </span>cleanup </span>||
</span>  </span>echo</span> Install failed
</span></code></pre>
Nice to know
    </a>

</h2>
There are many</a> more control operators,
including list terminators, pipe operators, and others.</p>
The [</code> (commonly used in if-statements) isn't just a shell feature.
It is a binary on Unix-like systems, usually located at /usr/bin/[</code>,
so it can be used anywhere.
It returns the exit code 0</code> if the expression was truthful.</p>
You can chain multiple [ expr ] && [ expr ]</code> expressions together, they are
commands after all.</p>
Bash also has [[</code>, which is
different</a> from [</code>.</p>
You can wrap multiple commands with { expr; }</code> to run it as single expression in
your command chain. For example:</p>
[ </span>$</span>EUID </span>-ne</span> 0 </span>] </span>&& </span>{ </span>echo</span> You must be root</span>; </span>exit</span> 1</span>; </span>}
</span></code></pre>
The true</code> and false</code> commands do nothing more than returning 0</code> or 1</code>.</p>
Bash features parameter expression</a>.
You can use ${EDITOR:=nvim}</code> to set the EDITOR</code> variable to nvim</code> only if
it is empty, so you won't even need conditionals.</p>
Most other shells support similar operators. fish</a> uses ; and</code> and ; or</code>, but now supports</a> &&</code> and ||</code> as well in modern versions.</p>
$_</code> (or Alt+.</code>) is your last used argument (noted by @Diti</a>).
For example:</p>
test</span> -f </span>"</span>FILE</span>" </span>&& </span>source </span>"$</span>_</span>" </span>|| </span>echo </span>"$</span>_</span> does not exist</span>" </span>>&</span>2
</span></code></pre>
A function or script returns the exit code of the last expression. If your last
expression is a command chain as described in this article, you might have an
unexpected exit code. See
this</a>
comments.</p>
Closing thoughts
    </a>

</h2>
These command sequences with control operators are an elegant alternative for
simple if-statements. I think they look much better and are more expressive
looking at conditional logic.</p>
But, don't overuse them. For bigger statements or advanced branching, you should
fall back to if-statements.</p>
I hope this article motivates you to make your shell scripts a little more
elegant in the future by using these operators.</p>


List & export your subreddits
Mon, 01 Mar 2021 00:00:00 +0000

    
        
        
        
        
    </a>
</p>
The last few years I've been wanting to export the list of subreddits I joined.
It's fun to share with friends having a similar interest,
as I've collected many gems throughout the years.</p>
To achieve this I've set-up a simple script.
It exports your subreddits to a plain text list.</p>
</span>
How to export
    </a>

</h2>

Visit old.reddit.com/subreddits/mine</a> in a desktop browser,
make sure you're logged in.</li>
On that page, open</a> your browser developer tools (Keybind: Ctrl+Shift+I</em>).</li>
In the developer tools panel, open the Console</strong> tab.</li>
Copy-and-paste the following snippet into the console, press Enter</em> to run it:$</span>(</span>'</span>body</span>'</span>).</span>replaceWith</span>(</span>'</span><body></span>'</span>+</span>$</span>(</span>'</span>.subscription-box</span>'</span>).</span>find</span>(</span>'</span>li</span>'</span>).</span>find</span>(</span>'</span>a.title</span>'</span>).</span>map</span>(</span>(</span>_</span>, </span>d</span>) </span>=> </span>$</span>(</span>d</span>).</span>text</span>()).</span>get</span>().</span>join</span>(</span>"</span><br></span>"</span>)</span>+</span>'</span></body></span>'</span>);</span>javascript</span>.</span>void</span>()
</span></code></pre>
</li>
Your full list of subreddits will appear on the webpage.</li>
</ol>
Here</a> is mine.</p>



Tap here if you're a nerd.</summary>
For nerds
    </a>

</h2>
Here is the above snippet, expanded:</p>
// Pluck list of subreddits from page, build plain text list
</span>var </span>subs </span>= </span>$</span>(</span>'</span>.subscription-box</span>'</span>)
</span>    .</span>find</span>(</span>'</span>li</span>'</span>)
</span>    .</span>find</span>(</span>'</span>a.title</span>'</span>)
</span>    .</span>map</span>(</span>(</span>_</span>, </span>d</span>) </span>=> </span>$</span>(</span>d</span>).</span>text</span>())
</span>    .</span>get</span>()
</span>    .</span>join</span>(</span>"</span><br></span>"</span>);
</span>
</span>// Put list of subreddits on page
</span>$</span>(</span>'</span>body</span>'</span>).</span>replaceWith</span>(</span>'</span><body></span>' </span>+ </span>subs </span>+</span>'</span></body></span>'</span>);
</span>
</span>javascript</span>.</span>void</span>()
</span></code></pre>
Your complete list of subreddits is located in the sidebar on that</a> page.
The script plucks your list of reddits from this sidebar and puts it in an array.
Then the array is imploded in a string to show on the page.
Super simple.</p>
</details>


Reconnect to broken tmux session
Sun, 28 Feb 2021 00:00:00 +0000
Ever tried to attach to a running tmux session, only to find that that fails?</p>
tmux</span> attach
</span># no sessions
</span>tmux</span> ls
</span># error connecting to /tmp/tmux-1000/default (No such file or directory)
</span></code></pre>
Even though you're sure tmux is running fine, it shows up as running in your
task manager after all.</p>
So, where are your precious tmux sessions?</em></p>
</span>Socket file
    </a>

</h2>
All your tmux sessions are hosted by a single tmux process. This is persistent
and keeps running until you quit all sessions again.</p>
The process creates a socket file, other processes use this to talk to it. When
you invoke tmux attach</code>, the program finds this socket and attaches to it
through the socket.</p>
Now, what happens when you delete this file? Exactly, your tmux</code> command doesn't
know how to connect to the running server. That's what we're seeing here.</p>
Recreate socket
    </a>

</h2>
Because others had the same issue, tmux provides a feature to fix this. When you
send the SIGUSR1</code> signal to the host process, it creates a fresh socket file
for you.</p>
For this, you need to find the PID of the running tmux server. Find it through
your task manager, or invoke the following command to find the PID of the oldest
running tmux process:</p>
pgrep</span> --oldest</span> tmux
</span># 5612
</span></code></pre>
For me it was 5612</code>, so I invoke the following and attach it again (be sure to
use your own PID):</p>
sudo</span> kill</span> -SIGUSR1</span> 5612
</span>tmux</span> attach
</span></code></pre>
Happy hacking!</p>


Solving Advent of Code 2020 in under a second
Sat, 27 Feb 2021 00:00:00 +0000
       ,--.-----.--.
</span>       |--|-----|--|
</span>       |--|     |--|
</span>       |  |-----|  |
</span>     __|--|     |--|__
</span>    /  |  |-----|  |  \              mm    mmmm    mmm
</span>   /   \__|-----|__/   \             ##   m"  "m m"   "
</span>  /   ______---______   \/\         #  #  #    # #
</span> /   /               \   \/         #mm#  #    # #
</span>{   /    _     _   _  \   }        #    #  #mm#   "mmm"
</span>|  { /  | | . | | /|   }  |-,   
</span>|  | \  |_| . |_| _|_  |  | |    mmmm   mmmm   mmmm   mmmm
</span>|  {                   }  |-'   "   "# m"  "m "   "# m"  "m
</span>{   \                 /   }         m" #  m #     m" #  m #
</span> \   `------___------'   /\       m"   #    #   m"   #    #
</span>  \     __|-----|__     /\/     m#mmmm  #mm#  m#mmmm  #mm#
</span>   \   /  |-----|  \   /
</span>    \  |--|     |--|  /
</span>     --|  |-----|  |--
</span>       |--|     |--|
</span>       |--|-----|--|
</span>       `--'-----`--'
</span></code></pre>
Advent of Code</a> is a popular yearly programming competition. It's an
Advent calendar of small programming puzzles for a variety of skill sets and
levels that can be solved in any programming language you like.</p>
Puzzles are released daily throughout December. More</a> than 150k
people take part in this event. The toughest battle to solve each puzzle as soon
as possible to become the best on the global leaderboard</a>.</p>
In my timezone, puzzles are released at 6 o'clock in the morning. Since I'm a
night owl, the biggest challenge for me here is to get up so early. I,
therefore, set a different goal instead.</p>
</span>
Subsecond
    </a>

</h2>
I want to develop a standalone, short, compact, fast and, elegant solution for
each problem this year. In past competitions, I took part using the Rust</a>
language. I've been using it a lot for other projects lately, and believe it is
a fantastic language to build performant, secure, and robust software. This has
always sparked my interest so Rust is a good fit.</p>
Last year I came across this</a> article, solving all puzzles in
under a second. Yes, in less than one second total. This inspired me to
challenge myself to the same this year:</p>
Solving Advent of Code 2020 in under a second on a single CPU core.</em></p>
Spoiler alert: I succeeded!</p>
What's in this for you?
    </a>

</h2>
In this article, I'd like to show you some optimizations I found appealing which
I used to keep the solutions blazingly fast. I'll only talk about the most
significant optimizations and the interesting bits. Most are algorithmic and are
consequently language agnostic.</p>
I'm just using basic time measurements on my machine. I won't be theoretically
proving the efficiency of an approach. I optimized the runtime of my solutions
based on my personal input. I did not make assumptions other than what is clear
from the puzzle description though, so each solution should work for all inputs
with comparable runtime. All user input is similar after all.</p>
I hope this article will present you with some out-of-the-box approaches you can
take away to make your future code more performant. Hence this piece is intended
for programmers that value performance.</p>
                     )
</span>       CHOO CHOO     ' ))'
</span>                      {//  '"
</span>                           "'' )
</span> ___   ___  ____ ____ ____ __||_
</span>____ -- __ {___{{___{{___{(___(o)
</span> ---- ----  0 0  0 0  0 0  0 0'U'
</span>
</span>        code zooming past
</span></code></pre>
Source code
    </a>

</h2>
Source code and measurements? See my solutions on GitHub:</p>
https://github.com/timvisee/advent-of-code-2020</a></p>
If you'd like to give these puzzles</a> a try and haven't done so yet, I highly
recommend doing so before you continue reading. It contains
spoilers.</p>
Now, let's get started with the interesting stuff.</p>

Day 1: Report Repair
    </a>

</h2>
On the first day part 2</a>, we're given a list of numbers. We must find 3 numbers
that have a sum of 2020. All numbers are around 1000, so we're likely trying to
find a pair of 3 small numbers.</p>
I sort</a> the list of numbers from small to large before trying to
find the correct pair, which decreases the runtime from 1.38ms</code> to 7μs</code>.</p>
Yup, starting simple.</p>
Day 6: Custom Customs
    </a>

</h2>
On day 6 part 1</a> we're trying to find the number of unique questions.
There are 26 in total, represented as letters. I take a 32-bit integer and
set</a> the corresponding bit for each answer. I then count the number
of ones. No expensive data structures are required.</p>
cady:    00000010110000000000000000000010
</span>ipldcyf: 00000000110100100100010000000010
</span>xybgcd:  00000000110010000000000000000110
</span>gcdy:    00000000110010000000000000000010
</span>dygbc:   00000001110010000000000000000010
</span>         =OR=============================
</span>         00000011110110100100010000000110 -> 11
</span></code></pre>
Part 2</a> is simple now: I take the same approach but use</a>
the AND operation instead of OR when setting bits.</p>
Day 9: Encoding Error
    </a>

</h2>
On day 9 part 2</a> we must find a sequence of numbers in a list of
numbers that sums up to a specific value.</p>
The common approach seems to be to use a for</code> in a for</code> loop. This walks
over each position with the outer loop and tries to find a sequence with the
correct sum with the inner loop.</p>
I'm using</a> a dynamic sliding window</em> approach instead (I better
give it a fancy name you know). I start by sliding the head</em> forward, making
the window and the sum larger. When the sum becomes larger than the target value
I stop. Then I start sliding the tail</em> forward, making the window and the
sequence sum smaller. When the sum becomes smaller than the target value I stop.</p>
   >> tail >>     >> head >>
</span>         |           |
</span>         +-----------+
</span>... 35 20|15 25 47 40|62 55 65 95 102 ...
</span>         +-----------+
</span>         | tot: 127  |
</span></code></pre>
I keep alternating between sliding the head</em> and tail</em>. Once the sum equals
the target value, we've found the sequence and can solve the puzzle. This
minimizes the number of required loops, making it more efficient.</p>
Day 10: Adapter Array
    </a>

</h2>
On day 10 part 2</a> we get a list of adapter voltages. Adapters may be
plugged into each other if the adapter is 1 to 3 volts higher than the adapter
you're plugging into. The puzzle is to figure out how many distinct adapter
arrangements are possible.</p>
I started with a sorted list because you can only plug higher-rated adapters
into lower-rated ones. The maximum difference is 3, so I soon discovered that
you can chunk the sequence of adapters. Each chunk of adapters has a difference
of 3, which only gives one way to connect between them. You can now process each
chunk separately to find distinct arrangements, multiplying their calculations.</p>
Chunks with adapters:
</span>
</span>C1 >> C2 >> C3 >> C4 >> C5
</span>--    --    --    --    --
</span>1     4     10    15    19
</span>      5     11    16
</span>      6     12
</span>      7
</span>--    --    --    --    --
</span>1x    7x    4x    2x    1x
</span>
</span>Ways to connect:
</span>
</span>1  +  7  +  4  +  2  +  1  =  15
</span></code></pre>
This resulted in chunks that always consisted of 2, 3, or 4 adapters. This makes
it easy to find distinctions between them. I finally figured that I could
optimize</a> it to a fixed number of distinctions per chunk size</em>
greatly reducing complexity.</p>
I found 74049191673856 distinct ways to connect all adapters in just 5μs</code>. I
can't even count to 1 within that time.</p>
Day 11: Seating System
    </a>

</h2>
On day 11 part 1</a> we're given a variation of Conway's Game of
Life</a> represented as a 2D arrangement of seats on a plane. Each iteration
seat occupation changes based on a set of rules considering their neighbors, but
seats don't move.</p>
L.LL.LL.LL    L = empty seat
</span>LLLLLLL.LL    . = nothing
</span>L.L.L..L..
</span>LLLL.LL.LL
</span>L.LL.LL.LL
</span>L.LLLLL.LL
</span>..L.L.....
</span>LLLLLLLLLL
</span>L.LLLLLL.L
</span>L.LLLLL.LL
</span></code></pre>
With regular Game of Life</em> you'd have to loop through all positions each
iteration and evaluate all rules to determine their new state. Because this
puzzle does not have a seat at every position (nor do seats always have 4
neighbors) our plane is more like a sparse array</a>. A lot of
cycles would be wasted if we'd keep looping over all plane positions.</p>
I decided to make a list of all seat positions and their respective neighbors.
This</a> way I only had to go through this list of seats for each
iteration. Determining what neighbors a seat has just needs to be performed
once.</p>
This is especially great for part 2</a> which makes things worse. It
doesn't just consider direct neighbors anymore, but neighbors in line of sight
making searching much more expensive. Luckily it doesn't affect my approach from
the first part too much, as I only search once</a>. This is much more
efficient than looping through all positions and finding neighbors every time.</p>
Day 12: Rain Risk
    </a>

</h2>
On day 12 part 1</a> we're given a sequence of navigation instructions for
a ship. It includes cardinal directions, rotation, and forward instructions. We
must figure out the distance between the start and destination position.</p>
What makes this tricky is the rotation and forward instructions. The forward
movement is dependent on your current rotation.</p>
I use a single byte of which the first 4 bits define the current rotation. The
first bit means north, the second bit means east, et cetera. Because the ship
starts looking east, I start with the 0b01000100</code> pattern. For each rotation
instruction, I simply rotate</a> the bits left or right. Rotating
right would update the direction to 0b00100010</code>.</p>
Direction bits, shift to rotate 90 degrees left or right:
</span>
</span>    << rotate left <<               >> rotate right >>
</span>
</span>... <> 01000100 <> 00100010 <> 00010001 <> 10001000 <> ...
</span>
</span>
</span>                Bit meaning:
</span>
</span>              [ y-1 ] [ y+1 ]
</span>              [north] [south]
</span>                    | |
</span>Direction bits  00100010  would move ship south (y+1)
</span>                     | |
</span>                [east] [west]
</span>                [ x+1] [x-1 ]
</span></code></pre>
To move forward I take</a> this direction byte and use bitwise
arithmetic to update the ship position. This removes branching (if</code> statements
and such) you'd normally expect for logic like this. Quite elegant.</p>
Day 13: Shuttle Search
    </a>

</h2>
On day 13 part 2</a> you're given a series of bus lines, each having a
fixed schedule. You must find the time where each bus leaves one after
the other, in order.</p>
time     bus 7   bus 13  X  X  bus 59  X  bus 31  bus 19
</span>  ...      .       .     .  .    .     .    .       .
</span>1068780    .       .     .  .    .     .    .       .
</span>1068781    D       .     .  .    .     .    .       .
</span>1068782    .       D     .  .    .     .    .       .
</span>1068783    .       .     D  .    .     .    .       .
</span>1068784    .       .     .  D    .     .    .       .
</span>1068785    .       .     .  .    D     .    .       .
</span>1068786    .       .     .  .    .     D    .       .
</span>1068787    .       .     .  .    .     .    D       .
</span>1068788    D       .     .  .    .     .    .       D
</span>1068789    .       .     .  .    .     .    .       .
</span>  ...
</span></code></pre>
My initial thought was just to brute force through all times. The correct answer
turns out to be very large (more than 640 trillion), making this impossible
within a short time. I was unable to optimize this myself with basic mathematics
due to the weird constraints.</p>
Searching for the problem semantics and related keywords online revealed the Chinese Remainder
Theorem</a>. It is very similar to the given problem and shows an efficient
way to solve it with sample code. With minimal changes, I solved this seemingly
impossible puzzle and the solution finds the answer in just 4μs</code>.</p>
The important lesson here is that many Advent of Code problems resemble some
well-defined algorithm or at least part of it. If you can't solve it yourself,
try to find a suitable algorithm. Finding such an algorithm makes solving the
problem child's play. This is super interesting for learning about new
algorithms and approaches as well.</p>

Day 15: Rambunctious Recitation
    </a>

</h2>
Day 15</a> requires you to continue a number sequence to find the number at
a given position. The puzzle description explains the rules quite well. The
second part gets tricky: it asks you the 30 millionth position. The problem is
that for each number you have to traverse all previous numbers based on the
given rules. This becomes super expensive for higher positions. For 30 million
numbers this means traversing 450 trillion (!) numbers.</p>
Given: 6, 4, 12, 1, 20, 0, 16
</span>
</span>                        2back 2back 1back new   new   6back 3back
</span>                        |     |     |     |     |     |     |
</span>6, 4, 12, 1, 20, 0, 16, 0, 2, 0, 2, 2, 1, 9, 0, 5, 0, 2, 6, 0, 3, ...
</span>                    |      |     |     |     |     |     |     |
</span>                    new    new   2back 9back 5back 2back new   new
</span></code></pre>
The sequence appears to be the Van Eck sequence</a> (see
this</a> fantastic Numberpfile video on it). To my surprise,
there doesn't seem to be an efficient algorithm for generating the sequence. The
sequence does not repeat, nor does it have a known pattern that would help with
generating. Many people (a lot smarter than I am) have taken up the challenge to
find a more efficient method, but without result. This means I don't have to
give it a try. Instead, I have to be careful to use the correct logic and data
structures to keep my sequence generator as fast as possible.</p>
I opted to use</a> a lookup table approach with an array and hash map
combination. Because the last position of a number is important, the table is
used for this with the number as a key and the last position as a value. This
way generating the next number only requires a single lookup instead of
traversing all previous numbers.</p>
Instead of just using a fixed array or hash map for the lookup table as a whole,
I split it in a low and high side at the 3 million mark. The low side is a fixed
array, the high side utilizes a hash map. This turns out to be much faster than
using just either of the two, improving runtime by 30%. This is super
interesting to me, and I didn't expect it to be so much faster. It likely has to
do with more efficient CPU cache usage on my system, where the low side with the
array is dense, and the high side with the hash map is sparse, though I haven't
looked into the details. This shows that using a single data structure isn't
always the best approach, even though that might be against your expectations.</p>
Sequence example:
</span>6, 4, 12, 1, 20, 0, 16, 0, 2, 0, 2, 2, 1, 9, 0, 5, 0, 2, 6, 0, 3, ...
</span>
</span>Last position lookup tables:
</span>
</span>LOW SIDE ARRAY 0..3M    HIGH SIDE MAP 3M..30M
</span>+-------+----------+    +------+------------+
</span>| index | last pos |    | num  | last pos   |
</span>+-------+----------+    +------+------------+
</span>| 0     | 20       |    | 3M   | 3.2M       |
</span>| 1     | 13       |    | 3.2M | 8.3M       |
</span>| 2     | 18       |    | 3.5M | 9.1M       |
</span>| 3     | 21       |    | 3.6M | 4.9M       |
</span>| 4     | 2        |    | 3.7M | 11.2M      |
</span>| 5     | 16       |    | ..   | ..         |
</span>| ..    | ..       |    |      |            |
</span>| 3M    | 0        |    |      |            |
</span>+-------+----------+    +------+------------+
</span></code></pre>
My final solution completes in 511ms</code>. Quite the achievement, as it seems
rather fast compared to others</a>. This is the most costly puzzle
when looking at runtime. It alone takes up 73% of my total runtime and consumes
more than half of my 1-second target. Ouch...</em></p>
Day 17: Conway Cubes
    </a>

</h2>
For day 17</a> Conway's Game of Life</a> returns (who'd have thought
looking at its title), though it has a special twist. You have to figure out how
many 'cubes' are active after a number of cycles, but this time we're doing it
in 3D space. The puzzle input is a 2D slice that serves as starting state.</p>
The first optimization I implemented was to limit the search space each cycle.
This space starts with the input size and grows by one in each direction for
each iteration. This limits the number of cubes to check, as distant cubes can't
be active yet. Easy.</p>
Because the initial state is a 2D slice, I noticed another interesting property.
As the 2D slice is effectively the same on the two sides</em> of the third axis, it
expands with the same pattern in both directions. This means that the third axis
is mirrored from the center (the slice). I only have to simulate one of these
two sides and multiply the cube count to get the answer we need. This halves
the number of operations reducing runtime.</p>
2D example with 1D (column) input which mirrors:
</span>
</span>       single input column
</span>       |
</span>---------------
</span>#---##---##---#
</span>#--#--#-#--#--#
</span>---#-#---#-#---
</span>----#-----#----
</span>---------------        what the field
</span>-----#---#-----    <-- looks like after
</span>----##---##----        some cycles
</span>---##-----##---
</span>---------------
</span>-----#####-----
</span>------###------
</span>------###------
</span>       |
</span>   <<< | >>>
</span>       |
</span>       mirrors left and right
</span></code></pre>
Part 2</a> gets even better. The puzzle is similar but simulates in 4D
space. To accommodate for this the rules have changed slightly, but the input is
still the same 2D slice. This is fantastic because this means not just one but
two axis are mirrored now. With the same optimization, I now need to simulate
only ¼th of the space, making the solution 4 times quicker!</p>

Day 20: Jurassic Jigsaw
    </a>

</h2>
Day 20</a> involves a jigsaw puzzle. Each piece is a 10×10 matrix of bits.
All pieces form a larger square. The bits on the edges between two pieces must
align. Every piece can be placed anywhere and may need to be rotated or flipped
in any direction. That's a lot of combinations.</p>
Placed tiles for small example puzzle:
</span>
</span>T3:    T9:    T2:
</span>..##.  ...##  #.##.
</span>##..#  #...#  #.###
</span>#...#  #..#.  .....
</span>####.  ....#  #...#
</span>##.##  #####  ###.#
</span>
</span>T1:    T6:    T5:
</span>##.##  #####  ###.#
</span>.#.##  #..##  ###.#
</span>..#..  ..#..  .###.
</span>###..  .#.#.  ..#.#
</span>..##.  ..###  #...#
</span>
</span>T7:    T4:    T8:
</span>..##.  ..###  #...#
</span>#..#.  .#..#  #..##
</span>##.#.  .#.#.  .#.#.
</span>.####  ####.  .###.
</span>..##.  .####  #.###
</span></code></pre>
To solve the first part you must figure out what pieces are placed in the 4
corners. @gkhill</a> gave me the insight (thanks for that!)
that corner pieces have two edges that don't connect to anything and likely
won't match any other edge. Now I only had to find 4 pieces with edges that
didn't match any other edge. In the example above the tiles, T3, T2, T7, and T8
all have 2 edges that don't match any other. Rather simple. That worked.</p>
In part 2</a> I use tricks like just rotating/flipping tile edges
instead of the full tile body while positioning them. I won't go into further
detail because it doesn't seem to affect the total runtime too much. But you
might find the implementation</a> interesting.</p>
Day 23: Crab Cups
    </a>

</h2>
Day 23</a> involves a game of moving cups. The cups are arranged in a
circle. Each is labeled with a unique number. To solve the puzzle you have to
move chunks of them around based on a set of rules for a specific number of
turns, to get a final sequence.</p>
Part 2</a> gives you one million cups, for which you've to do ten million
moves. That's a lot! Representing the cups as a list of numbers in an array
turns out to be very inefficiënt. For each iteration, you'd have to move a chunk
of cups through the list. This requires shifting a lot of items in memory,
resulting in many reallocations. That's slow, no good!</p>
Instead, I choose to utilize</a> a structure that essentially
functions like a linked list</a>. I allocated an array with one item
for each cup. The array is indexed by cup number. For each cup, it holds the
number of the next cup. It effectively points to the following cup in the
arrangement, looping the sequence.</p>
This is great because it makes moving a chunk of cups around super cheap.
Instead of having to shift a lot of items through memory, you just have to
update</a> 3 pointers. To move a chunk of cups, I:</p>

update the cup before the old chunk position, to point to the cup after the old chunk position,</li>
update the cup before the new chunk position, to point to the first cup of the chunk,</li>
update the last cup of the chunk, to point to the cup after the new chunk position.</li>
</ol>
Cup sequence: 3  8  9  1  2  5  4  6  7
</span>
</span>Linked list, storing our sequence:
</span>+---+---+---+---+---+---+---+---+---+
</span>| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- cup label
</span>+---+---+---+---+---+---+---+---+---+
</span>| 2 | 5 | 8 | 6 | 4 | 7 | 3 | 9 | 1 | <- points to (next cup)
</span>+---+---+---+---+---+---+---+---+---+
</span>
</span>
</span>To move chunk [8, 9, 1] after 5:
</span>
</span>Cup sequence: 3 |8  9  1| 2  5  4  6  7
</span>                +-------+
</span>                       v
</span>                      +-------+
</span>Cup sequence: 3  2  5 |8  9  1| 4  6  7
</span>
</span>          +---------- 1. change 3 to point to 2
</span>          |       +-- 2. change 5 to point to 8
</span>  +-------|-------|-- 3. change 1 to point to 4
</span>  |       |       |
</span>  |       |       |
</span>  v       v       v
</span>+---+---+---+---+---+---+---+---+---+
</span>| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | <- cup label
</span>+---+---+---+---+---+---+---+---+---+
</span>| 4 | 5 | 2 | 6 | 8 | 7 | 3 | 9 | 1 | <- points to (next cup)
</span>+---+---+---+---+---+---+---+---+---+
</span></code></pre>
As a bonus; you can instantly find a cup with a specified number by its index.
And because the last cup can point to the first an edge case is removed for
handling the sequence as a loop. Brilliant!</p>
The final implementation runs 192ms</code>, making it the second slowest solution.
The optimizations are useful here to keep everything under one second.</p>
Day 24: Lobby Layout
    </a>

</h2>
Day 24</a> involves a floor of hexagonal tiles. You're given a list of
directions to move on it, the target tile must be flipped between black and
white.</p>
A hexagonal grid can be tricky to comprehend. I just work</a> with it
as if it's a square (but askew)</em> grid. Seeing a problem like this differently
can greatly reduce its complexity.</p>
         _____         _____         _____
</span>        /     \       /     \       /     \
</span>  _____/ -2,-1 \_____/  0,-1 \_____/  2,-1 \_____
</span> /     \       /     \       /     \       /     \
</span>/ -3,-1 \_____/ -1,-1 \_____/  1,-1 \_____/  3,-1 \
</span>\       /     \       /     \       /     \       /
</span> \_____/ -2,0  \_____/  0,0  \_____/  2,0  \_____/
</span> /     \       /     \       /     \       /     \
</span>/ -3,0  \_____/ -1,0  \_____/  1,0  \_____/  3,0  \
</span>\       /     \       /     \       /     \       /
</span> \_____/ -2,1  \_____/  0,1  \_____/  2,1  \_____/
</span> /     \       /     \       /     \       /     \
</span>/ -3,1  \_____/ -1,1  \_____/  1,1  \_____/  3,1  \
</span>\       /     \       /     \       /     \       /
</span> \_____/       \_____/       \_____/       \_____/
</span></code></pre>
Part 2</a> challenges us to a Game of Life</em> one last time. This time we're
using the hexagonal grid, however, ouch. The floor from part 1 is our starting
state. A set of rules is provided to flip tiles between black and white based on
their neighboring tiles.</p>
I kept the square grid from part 1. Though each square tile has 6 neighbors
(including 2 diagonal) instead of just 4 to match what a real hexagonal grid
would be like. Based on the rules we only have to consider tiles that have at
least one neighboring black tile. This makes processing the infinitely sized
floor cheaper.</p>
I compile</a> a list of all neighbor tiles for each black tile and
count their occurrence number. After collecting this list I loop over all these
neighbors with their occurrence count to process the rules accordingly. Using
this method I skip looping over a huge amount of useless tiles and asserting the
rules becomes simple, similar to what I've done on day
13</a>. Doing just 100 iterations as the puzzle specifies
takes 43.2ms</code>, pretty expensive I think. With 656ms</code> total runtime so far I'm
still well under my 1-second target though.</p>
Day 25: Combo Breaker
    </a>

</h2>
On day 25</a> you're challenged to obtain the encryption key to break a
card-based door locking system. A set of cryptography rules is given, along with
the public key of the card and the door lock, and some additional parameters.</p>
You have to brute force your way to the final encryption key which you must
obtain. After understanding the cryptography rules it becomes clear that you've
to run some multiplication & modulo calculations for an unknown number of cycles
to obtain the final key. The number of cycles will likely be very large, so
cracking this lock will take some time.</p>
As part of the puzzle two public keys are given each having its own (unknown)
number of cycles and parameters. This means that there are two paths to brute
force the key, one of which being shorter. I want to be as quick as possible to
keep runtime low, but it is unknown which path is faster.</p>
I, therefore, choose to crack</a> both keys at the same time. The
process will be complete as soon as the key is found for either of the two,
using the shortest possible number of cycles. As the calculations on both keys
are so similar the compiler vectorized</a> it in a single
operation, basically making it as quick as cracking a single key. It
took 8419518 cycles to crack this lock, running 27.9ms</code>. Awesome.</p>

Results
    </a>

</h2>
That's it. I solved all puzzles!</p>
Now it was time to measure the total runtime.
I've set up a simple runner</a> for this to run and measure all</a> my
solutions in sequence.</p>
My final solutions complete in just 699ms</code>! That's from day 1 to day 25, 49
solutions in total, one after the other (!). Well under my 1-second
target. A fantastic achievement! Time to buy a cake.</p>
             ___________
</span>            '._==_==_=_.'
</span>            .-\:      /-.
</span>           | (|:.     |) |
</span>            '-|:.     |-'
</span>              \::.    /
</span>               '::. .'
</span>                 ) (
</span>               _.' '._
</span>              `"""""""`
</span></code></pre>
Here's a chart with all results plotted (details</a>):</p>

    
        
        
        
        
    </a>
</p>
Out of interest I also ran all solutions in parallel</a> on my
somewhat old 4-core Intel i5 CPU, which completes everything in a whopping
511ms</code>.</p>
Additional tricks
    </a>

</h2>
I did use other cool things to improve performance with which I didn't mention
anywhere else. Here are some of them, most are Rust specific:</p>

include_bytes!</code></a> & include_str!</code></a>: instead of
reading puzzle input from a file at runtime, I embedded the file statically in
the solution binary itself using these Rust macros. This removes file read
operations, while still having a puzzle input file, shaving off some time.</em></li>
#[inline]</code></a>: I suggested the compiler to inline some functions, to
limit time spent by calling functions a billion times, shaving off some time.</em></li>
nom</code></a>: an awesome Rust crate for building efficient binary parsers,
used</a> this in various</a> places to parse tricky
formats faster and more robustly than regexes or manual splitting.</em></li>
Custom</a> build flags and native optimization: for some
solutions, I tweaked link-time optimization, disabled compile-time
concurrency, and compiled with optimizations for my specific CPU model to
shave of some time.</em></li>
Increased stack size limit: for day 15 part 2</a> I
increased the maximum stack size with ulimit -s unlimited</code> to fit more
than 8192 kilobytes on the stack frame to make the overall solution more
efficient.</em></li>
</ul>
See the source code</a> for more interesting stuff.</p>
Closing words
    </a>

</h2>
Some have probably come up with some faster solutions than me. When I compare my
solutions with others in the Advent of Code megathread</a> on
Reddit, I seem to have done very well though.</p>
Setting this goal made this year's Advent of Code very interesting to me. It
constantly required me to think about what the most efficient approach could be.
This makes you creative, making your code quite elegant in many cases. If you're
looking for a challenge, I recommend you to do the same. Please consider to
share your cool implementations as well.</p>
Thanks for reading folks. I hope you've gained new insight on programming
challenges and have learned a thing or two. I'll see you on the 1st of December
for the next Advent of Code</a>!</p>


prs
Thu, 22 Oct 2020 00:00:00 +0000

A secure, fast & convenient password manager CLI using GPG and git to sync.</p>
</blockquote>

Visit project page on GitHub</a></li>
</ul>
prs</code> is a secure, fast and convenient password manager for the terminal. It
features GPG</a> to securely store your secrets and integrates git</code></a>
for automatic synchronization between multiple machines. It also features a
built-in password generator, recipient management, history tracking, rollbacks,
housekeeping utilities and more.</p>
Tim Visée

lazymc

Merge Mania

Firefox tricks: efficient QuantumBar usage

Bookmark: jump to subreddit </a> </h4> Quickly jump to your favorite subreddit:</p> r/ linuxmasterrace </span></code></pre> </a> </p> Tap to see bookmark config</summary> Keyword: r/</code> Url: https://reddit.com/r/%s</code></p> </blockquote> </details>

Send

Elegant bash conditionals

List & export your subreddits

Reconnect to broken tmux session

Solving Advent of Code 2020 in under a second

prs
