Misc on CuriousCoding

List of interesting blogs

Tue, 05 May 2026 00:00:00 +0200

Table of Contents

April 2026: The fall of the theorem economy - David Bessis

These are some links to interesting posts around the web, with some quick quotes/notes.

April 2026: The fall of the theorem economy - David Bessis Link to heading

from the moment I conceived of Theorem 0.5, I knew it was true and that proving it would be straightforward.

Too long but wow:

NordVPN refund dark patterns

Tue, 03 Mar 2026 00:00:00 +0100

Tl;dr: if you want to refund your NordVPN payment, go to my.nordaccount.com/billing/billing-history?intent_rf=true. The last part, ?intent_rf=true, is the important bit. (If that doesn’t work, you’ll probably have to go through the full chat-bot flow first, see below. Or maybe they changed the magic bit.)

I have a NordVPN subscription since many years.

Recently I have been getting mails that my card is expired and that I should update it to keep the service:

HPRC v2 stats

Fri, 26 Dec 2025 00:00:00 +0100

The Movi 2 paper (Zakeri et al. 2025) builds a fast index on HPRCv2 (Human Pangenome Reference Consortium 2025), a collection of 466 human genomes. This posts collects some statistics on the number of BWT runs ($r$) of this dataset, and makes an estimate on the number of unique mutations based on that.

Table 1: Number of BWT runs and average run length for a random 3.2Gbp string, a human genome, and HPRCv1 and v2. The average run-length in HPRC is taken from Zakeri et al. (2025).

dataset	copies	rc?	length (Gbp)	avg run-len	runs (G)	est total mut’s	unique mut rate
random		no	3.2	1.33	2.40
CHM13v2.0	1	no	3.2	1.85	1.72
HPRCv1	94	yes	2x 301	134	2.25	33M	1/8900
HPRCv2	466	yes	2x 1500	535	2.80	68M	1/22000

TODO: Update for the fact that HPRC run-lengths are for the version with rc! (Include single human genome with rc)

Asymptotic elevators

Mon, 22 Dec 2025 00:00:00 +0100

I was listening to an episode of the well there’s your problem podcast about pencil towers (youtube), and it had a section on how elevators are a problem because they require a lot of space. So here’s a mathematical version of that.

Problem statement Link to heading

Given are $n$ people that need to go to floors $1, 2, \dots, n$.
Elevators have constant acceleration, and must be standing still to enter/exit.¹
Possible elevator configurations:
1. single elevator over entire height
2. partition the height in disjoint intervals, and then one elevator per interval
3. double-deck: a single elevator that is $h$ floors high
Not allowed: two free-moving elevators above each other that make sure to never bump into each other.
Elevators have infinite capacity.
There are $k$ elevator shafts.
Question: How much total travel time do you need to get everyone home, if everybody arrives at the same time.
Harder(?): What if the people arrive in a random permutation (1 per time step), and their clock starts ticking as soon as they arrive?

Observations Link to heading

Going $n$ floors up takes at least $O(\sqrt n)$ time.
Total travel time is at least $\sum_{i=0}^n O(\sqrt i) = O(n \sqrt n)$
$1$ elevator carrying everyone going 1 step at a time: $O(n^2)$ total time
$2$-elevator sqrt-decomposition: one elevator stops every $\sqrt n$ floors, and then a (set of) second elevators for the final up to $\sqrt n$ floors.
- first elevator: $n$ people times $n/(\sqrt n)/2$ ‘big steps’ on average times $\sqrt{\sqrt n}$ time per big step is $O(n^{7/4})$
- second elevator: $n$ people times $(\sqrt n)$ ‘small steps’ on average times $1$ per small step is $O(n^{3.2})$
- so overall the big steps dominate
$2$-elevator, one that stops every $B$ floors and then $B$ that stop every one floor:
- the first one: $n \cdot (n/B) \cdot \sqrt B = n^2/\sqrt B$
- the second one: $n \cdot B = nB$.
- solve for equality: $B = n/\sqrt B$ => $B = n^{2/3}$
- so $n^{1+2/3}$ solution
$\lg n$ elevator binary tree:
- $2^k \leq n \leq 2^{k+1}$
- Take first elevator to $2^k$ if needed: time $\sqrt{2^k} = O(\sqrt n)$
- There take second elevator that goes up $2^{k-1}$ floors if needed.
- Then $2^{k-2}$ levels up
- and so on until the last floor.
- Total time per person averages $\sqrt{2^k}/2 + \sqrt{2^{k-1}}/2 + \dots + \sqrt{2}/2 + \sqrt{1}/2 = O(\sqrt{2^k}) = O(\sqrt n)$, so up-to-a-constant optimal total travel time $O(n \sqrt n)$.

Open questions:

[WIP] Feynman problems

Mon, 12 Aug 2024 00:00:00 +0200

Table of Contents

1 Space dust

1 Space dust Link to heading

What is the total mass of space dust hitting the earth during the Perseids meteor shower?

References Link to heading

Links for talks & posters

Mon, 01 Jul 2024 00:00:00 +0200

Table of Contents

A*PA
PA-Bench
Mod-minimizers

There are links for my talks and posters.

A*PA Link to heading

A*PA (bioinformatic): Groot Koerkamp, Ragnar, and Pesho Ivanov. 2024. “Exact Global Alignment Using A* with Chaining Seed Heuristic and Match Pruning.” Edited by Tobias Marschall. Bioinformatics 40 (3). https://doi.org/10.1093/bioinformatics/btae032.
A*PA2 (WABI24): Groot Koerkamp, Ragnar. 2024. “A*PA2: Up to 19 Faster Exact Global Alignment.” In Wabi 2024, 312:17:1–17:25. Lipics. https://doi.org/10.4230/LIPIcs.WABI.2024.17.
Code: github.com/RagnarGrootKoerkamp/astar-pairwise-aligner
Slides: slides.google.com/…
Poster: curiouscoding.nl/upload/astarpa-poster.pdf

PA-Bench Link to heading

Poster: curiouscoding.nl/upload/pabench-poster.pdf
Code: github.com/pairwise-alignment/pa-bench

Mod-minimizers Link to heading

Mod-minimizer (WABI24): Groot Koerkamp, Ragnar, and Giulio Ermanno Pibiri. 2024. “The Mod-Minimizer: A Simple and Efficient Sampling Algorithm for Long $k$-Mers.” In Wabi 2024, 312:11:1–11:23. Lipics. https://doi.org/10.4230/LIPIcs.WABI.2024.11.
Code (C++): github.com/jermp/minimizers
Code (Rust): github.com/RagnarGrootKoerkamp/minimizers

References Link to heading

Daily, Jeff. 2016. “Parasail: SIMD C Library for Global, Semi-Global, and Local Pairwise Sequence Alignments.” Bmc Bioinformatics 17 (1). https://doi.org/10.1186/s12859-016-0930-z.

Dijkstra, Edsger W. 1959. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1 (1): 269–71. https://doi.org/10.1007/bf01386390.

Groot Koerkamp, Ragnar. 2024. “A*PA2: Up to 19 Faster Exact Global Alignment.” In Wabi 2024, 312:17:1–17:25. Lipics. https://doi.org/10.4230/LIPIcs.WABI.2024.17.

Groot Koerkamp, Ragnar, and Pesho Ivanov. 2024. “Exact Global Alignment Using A* with Chaining Seed Heuristic and Match Pruning.” Edited by Tobias Marschall. Bioinformatics 40 (3). https://doi.org/10.1093/bioinformatics/btae032.

Groot Koerkamp, Ragnar, and Giulio Ermanno Pibiri. 2024. “The Mod-Minimizer: A Simple and Efficient Sampling Algorithm for Long $k$-Mers.” In Wabi 2024, 312:11:1–11:23. Lipics. https://doi.org/10.4230/LIPIcs.WABI.2024.11.

Hirschberg, Daniel S. 1975. “A Linear Space Algorithm for Computing Maximal Common Subsequences.” Communications of the Acm 18 (6): 341–43. https://doi.org/10.1145/360825.360861.

Ivanov, Pesho, Benjamin Bichsel, and Martin Vechev. 2022. “Fast and Optimal Sequence-to-Graph Alignment Guided by Seeds.” In Recomb, 306–25. Springer International Publishing. https://doi.org/10.1007/978-3-031-04749-7_22.

Li, Heng. 2018. “Minimap2: Pairwise Alignment for Nucleotide Sequences.” Edited by Inanc Birol. Bioinformatics 34 (18): 3094–3100. https://doi.org/10.1093/bioinformatics/bty191.

Liu, Daniel, and Martin Steinegger. 2023. “Block Aligner: an adaptive SIMD-accelerated aligner for sequences and position-specific scoring matrices.” Bioinformatics. https://doi.org/10.1093/bioinformatics/btad487.

Marco-Sola, Santiago, Jordan M Eizenga, Andrea Guarracino, Benedict Paten, Erik Garrison, and Miquel Moreto. 2023. “Optimal Gap-Affine Alignment in $O(s)$ Space.” Edited by Pier Luigi Martelli. Bioinformatics 39 (2). https://doi.org/10.1093/bioinformatics/btad074.

Marco-Sola, Santiago, Juan Carlos Moure, Miquel Moreto, and Antonio Espinosa. 2021. “Fast Gap-Affine Pairwise Alignment Using the Wavefront Algorithm.” Bioinformatics 37 (4): 456–63. https://doi.org/10.1093/bioinformatics/btaa777.

Myers, Gene. 1986. “An $O(ND)$ Difference Algorithm and Its Variations.” Algorithmica 1 (1–4): 251–66. https://doi.org/10.1007/bf01840446.

———. 1999. “A Fast Bit-Vector Algorithm for Approximate String Matching Based on Dynamic Programming.” Journal of the Acm 46 (3): 395–415. https://doi.org/10.1145/316542.316550.

Suzuki, Hajime, and Masahiro Kasahara. 2018. “Introducing Difference Recurrence Relations for Faster Semi-Global Alignment of Long Sequences.” BMC Bioinformatics 19 (S1). https://doi.org/10.1186/s12859-018-2014-8.

Ukkonen, Esko. 1985. “Algorithms for Approximate String Matching.” Information and Control 64 (1–3): 100–118. https://doi.org/10.1016/s0019-9958(85)80046-2.

Šošić, Martin, and Mile Šikić. 2017. “Edlib: a C/C++ library for fast, exact sequence alignment using edit distance.” Edited by John Hancock. Bioinformatics 33 (9): 1394–95. https://doi.org/10.1093/bioinformatics/btw753.

A*PA talk @ CWI

Wed, 27 Dec 2023 00:00:00 +0100

I recently gave a talk about A*PA at CWI. Sadly the recording doesn’t show the blackboard, but either way, find it here.

ALPACA/PANGAIA winter workshop notes

Mon, 20 Nov 2023 00:00:00 +0100

Table of Contents

Monday
Tuesday
- Variant types
Wednesday

These are notes of discussions at the ALPACA/PANGAIA conference in November 2023.

Monday Link to heading

I had interesting discussions with Giulio, Paul, and Lucas Robidou.

Notes on writing course

Tue, 14 Nov 2023 00:00:00 +0100

Some notes from the writing course I’m taking.

BAPCtools instruction

Tue, 17 Oct 2023 00:00:00 +0200

Steps:

Clone https://github.com/RagnarGrootKoerkamp/BAPCtools

Make an alias to the executable:

1

ln -s ~/git/BAPCtools/bin/tools.py ~/bin/bt

Create a new problem:

1
2
3


cd ~/problems
bt new_problem my_problem_name
cd ~/problems/my_problem_name

You now have the following:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


.
├── data
│   ├── sample
│   │   └── 1.in # Sample testcase input
│   │   └── 1.ans # Sample testcase output
│   └── secret
├── generators # for later
│   └── ...
├── input_validators # for later
│   └── ...
├── output_validators # for later
│   └── ...
├── problem_statement
│   ├── figure.tex.template
│   ├── problem.en.tex # The problem statement
├── problem.yaml
└── submissions
 ├── accepted
 │   └── name.cpp # A submission
 ├── run_time_error
 ├── time_limit_exceeded
 └── wrong_answer

Edit the statement problem.en.tex
Make some samples by hand in data/samples/*.{in,ans}
Write a solution in submissions/accepted/<yourname>.{py,cpp,java}.
Use bt run or bt run submissions/accepted/<submission> to test your submission.

DSB 2023

Mon, 20 Mar 2023 00:00:00 +0100

These are notes for DSB 2023. They’re not very structured though. I usually find methods more interesting than results.

Day 1, Tuesday Link to heading

Practical data structures for longest common extensions, Alexander Herlez Link to heading

LCE: longest common extension: given $i$, $j$, the max $k$ s.t. $A[i, i+k) = A[j, j+k)$.
alg:
- compare first k
- if same: sample a subset and use black-box datastructure.
- similar idea to minhash/mash kmer selection methods, same(?) as syncmers
string synchronizing sets (SSS):
- rolling hash. sample a position when it has minimal hash in it’s window
https://github.com/herlaz/alx
useful for constant time LCE when extensions are length 1000 or longer. Not faster for shorter LCEs.
note: WFA uses this a lot and it’s actually the bottleneck, but really only for short extensions.

Pan-genome de Bruijn graph using the bidirectional FM-index, Lore Depuydt Link to heading

Goal: graph of pangenome with correspondences to reads
Implicit graph by Beller and Ohlebusch: build on top of FM-index of concatenation
New in Nexus:
- Bidirectional FM-index for bidirectional traversal
  - down/upstream neighbourhoods can be visualized efficiently using traversal
- Search schemes for lossless approximate pattern matching (separate talk)
  - query -> candidate matches -> graph paths -> read paths
  - Lossless aligner; reports many more occurrences than PuffAligner, although this does make it slower for >0 edit distance
- checkpoints k-mers inside long nodes
  - this way, to find the start of a long (compressed) node goes down significantly.
Memory usage: Bidirectional FM-index is >80%.
- Bidir FM is linear in total size of pangenome.
Future: r index, which uses less memory.

Indexing large metagenomics projects with abundances, Pierre Peterlongo Link to heading

Indexing read sets with abundance in <100GB with fast querying with low ram.
Uses counting bloom filters
fimpera decreases the overestimation, allowing less memory usage.
Once k-mers are sorted, all processes are sequential! 1000x speedup
instead of querying k-mers, store all slightly smaller s-mers and query all of them for much better false positive rates

µ-PBWT: Enabling the Storage and Use of UK Biobank Data on a Commodity Laptop, Davide Cozzi Link to heading

r-index equivalent of PBWT, using run-length encoding
10-100x less memory than PBWT.
https://github.com/dlcgold/muPBWT

Genome-on-Diet: Taming Large-Scale Genomic Analyses via Sparsified Genomics, Mohammed Alser Link to heading

Building an index on spaced kmers/patterns
Only some positions are sampled. i.e.: sample every other basepair and build kmers on those.
Index is built on the fly; not preprocessed
to 2x faster and 2x less memory than minimap2.
to 50x faster and 700x less memory than other tools.
summary: subsample 1 in m bits and run minimap on top of that.
similar to spaced seeds, but additionally subsamples the number of kmers.
Faster and better accuracy than spaced seeds.

Spectrum preserving tilings enable sparse and modular reference indexing, Giulio Ermanno Pibiri Link to heading

Spectrum preserving tiling: Given a set of reads and their DBG, we can for each read store location information per unitig in this larger graph
Use SSHash to store all unitigs.
Sample a subset of unitigs to store location information for. Non-sampled unitigs can still be recovered by querying adjacent unitig locations instead.
Main contribution: reducing space usage of the reverse index: mapping kmers to locations.
https://github.com/COMBINE-lab/pufferfish2

Towards a lower-memory chunked graph data structure inspired by Minecraft, Fawaz Dabbaghie Link to heading

Chunk big graphs as in minecraft chunks.
First approach: split human genome graph in 1000 parts using BFS’s from random positions
Already big speedup!
TODO: simple idea and super effective. Maybe play around with this at some point

Optimal Worst-Case Design of Gapped k-mer Masks, Sven Rahmann Link to heading

Gapped kmers are better in the worst case than normal kmers:
- If you can make $x$ substitutions in a length $n$ strings, gapped kmers need a higher $x$ to mutate (break) all of them.
Second optimization goal: count number of recovered positions, instead of number of kmers.
#########_#########_######### (27,29)-mer: in a $n=100$ window, lack of such matches implies at least 4 errors. Normal 27-mers imply at least 3 errors.
boundary effects (changing $n$) are not super strong.
TODO: read old papers and see if this could be used for A*PA
- How about inexact spaced matches?

Locality-Preserving Hashing of k-mers, Yoshihiro Shibuya Link to heading

Mapping of kmers to $[0, 4^n)$ such that kmers with same minimizer are close.
Split mapping based on whether the minimizer is left-maximal and/or right-maximal inside its super-k-mer.
https://github.com/jermp/lphash
Less than 1.44 bits/element for large k (which is the generic lower bound).

Space-efficient k-mer counting using an implicit sequence representation, Miika Leinonen Link to heading

Map kmers into a hashtable storing at each index:
- count of kmers mapping here
- the last character of the kmer
- the index of the preceding kmer
Memory usage: 25%-50% of normal hash table
saves more memory for larger k.

VeChat: correcting errors in long reads using variation graphs, Alexander Schönhuth Link to heading

Error correction using graph cleaning
Clean using repeated steps of:
- remove edges with low coverage
- clean edges with low confidence: the relative weight this edge has with respect to total weight of edges going out of predecessor or going into successor
- clean isolated nodes and leaf edges
Up to 10x less remaining errors than other tools.

Fixing homopolymer errors in HiFi reads using dictionary compression, Diego Diaz-Dominguez Link to heading

Encode sequence recursively using grammer based
Grammar compression is good on its own
TODO: read paper

Orthanq: orthogonal evidence based haplotype quantification, Hamdiye Uzuner Link to heading

Variant calling pipeline
https://github.com/orthanq

Day 2, Wednesday Link to heading

Random Wheeler graphs, Riccardo Maso Link to heading

missed it :(

A Combinatorial Identity

Sun, 16 Oct 2022 00:00:00 +0200

Some notes regarding the identity

\begin{equation} \sum_{k=0}^n \binom{2k}k \binom{2n-2k}{n-k} = 4^n \end{equation}

Gould has two derivations:
- The first, from Jensens equality, (18) in (Jensen 1902; Shijie 1303).
- A second via the Chu-Vandermonde convolution:
  
  \begin{equation} \sum_{k=0}^n \binom{x}k \binom{y}{n-k} = \binom{x+y}n \end{equation}
  
  using $x=y=-\frac 12$ and using the $-\frac 12$-transform:
  
  \begin{equation} \binom{-1/2}{n} = (-1)^n\binom{2n}{n}\frac 1 {2^{2n}} \end{equation}
Duarte and de Oliveira (2012) has a combinatorial proof.

References Link to heading

Duarte, Rui, and António Guedes de Oliveira. 2012. “New Developments of an Old Identity.” https://doi.org/10.48550/ARXIV.1203.5424.

Jensen, J. L. W. V. 1902. “Sur Une Identité D’abel et Sur D’autres Formules Analogues.” Acta Mathematica 26 (0): 307–18. https://doi.org/10.1007/bf02415499.

Shijie, Zhu. 1303. Jade Mirror of the Four Unknowns.

Competitive Programming Lecture

Wed, 28 Sep 2022 00:00:00 +0200

Table of Contents

Contest strategies
Pairwise Alignment using A*
Exercises

Contest strategies Link to heading

Preparation

Thinking costs energy!
Sleep enough; early to bed the 2 nights before.
No practising on contest day (and the day before); it just takes energy.

During the contest

Eat! At the very least take a break halfway with the entire team and eat some snacks.
Make sure to read all the problems before the end of the contest. In the beginning, split the problems to find the simple ones, but towards the end, find a problem you think you can solve (because of the scoreboard or because you like it), and work on it as a team.

Coding

Ideally, use C++. Otherwise, Python can be used too.
- For big-integer problems, prefer Python.
Use a TCR (e.g. https://github.com/TimonKnigge/TCR): a 25 page document containing algorithms. Ideally, implement all of them yourself so you know how they work. Otherwise download one.
Make a template, and add it to your TCR. One person should type this in the first minutes of the contest and copy it to A.cpp, B.cpp, … .
When you think you solved a problem:
- Decide exactly how the code will look. Maybe write pseudocode on paper.
- For hard problems: verify your solution with a teammate.
- Once the keyboard is free, start typing it out. If needed, ask one teammate to look while you code.
- Typical distribution:
  - 1 person typing
  - 1 person solving a new problem
  - 1 person helping the other 2: spotting typos or working on problems.

Pairwise Alignment using A* Link to heading

Some resources you can use:

Paper styleguide

Sat, 06 Aug 2022 00:00:00 +0200

Table of Contents

Notation
Naming and style

This is a growing list of notation and style decisions Pesho and I made during the writing of our paper, written down so that we don’t have to spend time on it again next time.

Notation Link to heading

Math

Modulo: $a\bmod m$ for remainder, $a\equiv b\pmod m$ for equivalence.

Alphabet

$\Sigma$, $|\Sigma| = 4$

Sequences

$A = \overline{a_0\dots a_{n-1}} \in \Sigma^*$, $|A| = n$
$B = \overline{b_0\dots b_{m-1}} \in \Sigma^*$, $|B| = m$
Edit distance $\mathrm{ed}(A, B)$
$A_{<i} = \overline{a_0\dots a_{i-1}}$
$A_{\geq i} = \overline{a_i\dots a_{n-1}}$
$A_{i\dots i’} = \overline{a_i\dots a_{i’-1}}$

Edit graph

State $\langle i, j\rangle$
Graph $G(V, E)$ where $V = \{\langle i,j\rangle | 0\leq i\leq n, 0\leq j\leq m\}$
Root state $v_s = \langle 0,0\rangle$
Target state $v_t = \langle n,m\rangle$
Distance $d(u, v)$
Path $\pi$
Shortest path $\pi^*$
Cost of path $cost(\pi)$, $cost(\pi^*) = d(v_s, v_t) = \mathrm{ed}(A, B)$.

Naming and style Link to heading

Vertex, not node

IGGSY 22 Slides

Sun, 12 Jun 2022 12:04:00 +0200

These are the slides Pesho Ivanov and I presented at IGGSY 2022 on Astarix and A*PA.

Drive: here

Pdf: here

Glossary

Thu, 14 Apr 2022 00:00:00 +0200

This is a growing list of ambiguous terms and their definitions. More of a place to store random remarks than a complete reference for now.

diagonal transition

name introduced by Navarro (2001)

approximate

approximate algorithm: an algorithms that does not always give the correct answer.
$k$-approximate string matching: variant semi-global alignment where we find all matches of a pattern in a reference with at most $k$ mistakes.

Also approximate string matching: alternative name for global pairwise alignment.

Hello, World!

Wed, 13 Oct 2021 00:00:00 +0200

1

print("Hello, World!")

1

std::cout << "Hello, World!" << std::endl;

SE Endurance: Early game

Mon, 26 Apr 2021 00:00:00 +0200

Backlinks: Reddit

This is the start of a series of posts on our (philae, winston) play through Factorio with the Space Exploration mod.

After lots of struggling, we recently finished our first SE world after 624 in-game hours. Since this was also our first/second Factorio world, the start was very inefficient and we learned a lot of things along the way. In this new map, which we call Endurance (after the interplanetary spaceship in Interstellar), we will apply what we learned, and share it with the world :)

Hashcode 2021 Finals

Sat, 24 Apr 2021 00:00:00 +0200

Links: Problem | Scoreboard
Team: cat /dev/random | grep "to be or not to be"
Who: Jan-Willem Buurlage, Ragnar Groot Koerkamp, Timon Knigge, Abe Wits
Score: 274253375
Rank: 19 of 38

Not good.
Not bad.
Definitely ugly.

Linkerrijtje (aka top half).

I would have liked to write that I’m happy with the result, but to be fair–I’m not. Just the fact that I can’t sleep and feel the need to write this in the middle of the night surely is indication of this. Plenty of things could have gone better, and there are so many things we (I) could have done differently to actually break that elusive 300M barrier (and potentially get that top 10 place we were hoping for), that I’ll definitely be sad for a little while.

Hashcode 2021: A lucky ride

Mon, 01 Mar 2021 00:00:00 +0100

Links: Problem | Scoreboard | Codeforces announcement, this blog | Hacker News
Team: cat /dev/random | grep "to be or not to be"
Who: Jan-Willem Buurlage, Ragnar Groot Koerkamp, Timon Knigge, Abe Wits
Score: 10282641
Rank: 16

Since we did quite well, here is a write-up of our participation in Hashcode 2021.

Prep Link to heading

All four of us had previously participated in Hashcode, but this was the first time in the current composition. Since we estimated our chances of getting through to the finals to be more than nothing, we decided to practice some previous Hashcode problems. Not all test sessions were equally successful, but we did manage to get a good division of work: while I start by immediately writing the IO Input and Output classes, and the Output::score() function, the others always start with reading the statement, analysing the testcases, and writing at least one greedy solution. This already is a big step up from previous years/teams, where usually everybody would write the IO themselves.