# 2020 Problem Solving Competition – Phase II highlights

With Dyalog’s APL Problem Solving Competition 2021 in full swing, it’s time to highlight some of the excellent solutions that were submitted to last year’s edition.

Stefan Kruger works for IBM making databases. While he tries to learn at least one new programming language a year, he got hooked on APL and participated in the competition. This is his perspective on some solutions that the judges picked out – call it the “Judges’ Pick”, if you like; smart, novel, or otherwise noteworthy solutions that can serve as an inspiration.

This blog post is also available as an interactive Jupyter Notebook document.

By Stefan Kruger

I’ll show a cool solution or two to each Phase II problem and dive into the details of a couple. If you need to refresh your memory with what the problems looked like, there’s a PDF of the Phase II problems.

Oh, and note that at the time of writing there is still plenty time to take part in the current edition of the competition (and really, who knew bowling was so complicated?) – there are some juicy cash prices to be won.

## Problem 1: Take a Dive (1 task)

Level of Difficulty: Low

So let’s kick off with problem 1. The task was to calculate the score of an Olympic dive, consisting of a technical difficulty rating and a vector containing either 3, 5 or 7 judges’ scores. Only the central three ordered judges’ scores should be considered, which should be summed and multiplied by the technical difficulty rating.

Here is a cunning trick that wasn’t at all obvious:

``````∇ score←dd DiveScore scores;sorted;cenzored;rotator
⍝ 2020 APL Problem Solving Competition Phase II
⍝ Problem 1, Task 1 - DiveScore

sorted←{⍵[⍋⍵]}scores

⍝  0 1 2 rotates score indexes to 123, 23451 or 3456712
⍝  So three center values always goes first
⍝  51 = (0 1 2∧.= 3 5 7 ∘.|⍳100) ⍳ 1
rotator←51

cenzored←3↑rotator⌽sorted
score←⍎2⍕dd+.×cenzored
∇
``````
````      2.9 2.6 2.7 DiveScore¨(7 7.5 6.5 8 8 7.5 7)(9.5 8 8.5)(7.5 7 7 8.5 8)````
63.8 67.6 60.75
``````

This contestant figured out that if a vector of length 3, 5 or 7 is rotated 51 steps, then the original central three items will always end up at the beginning. No, really. It turns out that 51 is the first number `X` such that `0 1 2≡3 5 7|X`. They tabulated the options and picked the first solution, guessing that it’d be less than 100:

``````      ⍸0 1 2∧.=3 5 7∘.|⍳100
51
``````

But there is another way – this is one of those situations where the Chinese Remainder Theorem comes in handy, especially since it’s available on APLcart:

````      3 5 7 {m|⍵+.×⍺(⊣×⊢|∘⊃{0=⍵:1 0 ⋄ (⍵∇⍵|⍺)+.×0 1,⍪1,-⌊⍺÷⍵})¨⍨⍺÷⍨m←×/⍺} 0 1 2 ⍝ https://aplcart.info?q=chinese````
51
``````

If you figured that out, award yourself a well-deserved pat on the back. For us mortals, we probably all did something rather more pedestrian:

``````DiveScore ← {
d ← 2-2÷⍨7-≢⍵       ⍝ How many items should we drop each side?
⍺+.×(-d)↓d↓⍵[⍋⍵]
}
``````

## Problem 2 – Another Step in the Proper Direction (1 task)

Level of Difficulty: Medium

Problem 2 builds upon Problem 5 from Phase I. In short, we are asked to write a function `Steps` that takes a two-element vector to the right, defining a start and end value, and an optional left integer argument that tweaks how we generate values from `start` to `end`. The complexity here comes from the many combinations of behaviours from what exactly is given as the left argument: integer or float? positive or negative? Also, the range must be inclusive, even if a floating-point step size means that the end point is overshot. I took this on thinking it would be trivial – it wasn’t.

Here’s a great solution that manages to combine this functionality with a call to a single dfn:

``````∇ steps←{p}Steps fromTo;segments;width
width ← |-/fromTo
:If 0=⎕NC'p' ⍝ No left argument: same as Problem 5 of Phase I
segments ← 0,⍳width
:ElseIf p0 ⍝ p is the step size
segments ← p {⍵⌊⍺×0,⍳⌈⍵÷⍺} width
:ElseIf p=0 ⍝ As if we took zero step
segments ← 0
:EndIf
⍝ Take into account the start point and the direction.
steps ← fromTo {(⊃⍺)+(-×-/⍺)×⍵} segments
∇
``````

I ended up with something more convoluted, with a few ugly special cases, and shamelessly borrowing from dfns.iotag:

``````Steps ← {
range ← {
r ← ⍺-s×⎕IO-⍳⌊1-(⍺-⊃⍵)÷s←×/1↓⍵,(⍺>⊃⍵)/¯1 ⍝ "inspired" by dfns.iotag
(⊃⍵)≠⊃⊖r: r,⊃⍵ ⋄ r   ⍝ Ensure endpoint is included – yeuch :(
}
⍺ ← ⍬
(b e) ← ⍵
⍺≡⍬: b range e        ⍝ No ⍺
⍺=0: b                ⍝ Zero step; return start point
⍺>0: b range e ⍺      ⍝ Positive ⍺
len ← (e-b)÷count←⌊-⍺ ⍝ Negative ⍺
len=0: b/⍨1+count
b range e len
}
``````

Level of Difficulty: Medium

The task here was to scrape the Dyalog APL Problem Solving Competition webpage to extract all links to PDF files. We get the suggestion to use either Dyalog’s `HttpCommand` or shell out to a system mechanism for fetching a web page.

To use `HttpCommand`, we first need to load it:

````      ]load HttpCommand````
#.HttpCommand
``````

Here’s a slightly tweaked competition submission, showing great flair in how to process XML:

``````PastTasks ← {
url ← ⍵
r ← (HttpCommand.Get url).Data  ⍝ get page contents
(d n c a t) ← ↓⍉⎕XML r          ⍝ depth; name; content; attributes; type
(k v) ← ↓⍉ ⊃⍪/ ((,'a')∘≡¨n)/a   ⍝ extract key-value pairs of <a> elements
urls ← ('href'∘≡¨k)/v           ⍝ get URLs
pdfs ← ('.pdf'∘≡¨¯4↑¨urls)/urls ⍝ filter .pdfs
base ← ⊃⌽⊃('base'∘≡¨n)/a        ⍝ base URL
base∘,¨pdfs
}
``````

The problem statement suggests that a regex-based solution might be tolerable. Here’s a stab at that approach:

``````PastTasks ← {
body ← (HttpCommand.Get ⍵).Data
pdfs ← '<a href="(.+?\.pdf)"'⎕S'\1'⊢body
base ← '<base href="(.+?)"'⎕S'\1'⊢body
base,¨pdfs
}
``````

So which is the “better” solution? Well, the first approach has a number of advantages: firstly, is much more robust (provided that the web page is valid XHTML, which we are told is a given), meaning that we can abdicate responsibility for dealing with markup quirks (single vs double quotes, whitespace etc) to the built-in `⎕XML` system function, and secondly, there is that (in)famous quote from Jamie Zawinski:

Some people, when confronted with a problem, think “I know, I’ll use regular expressions.” Now they have two problems. – jwz

Mixing in a liberal helping of regular expressions in with APL is perhaps not helping APL’s unfair reputation for being write-only.

However, when dealing with patterns in textual data, as we unquestionably are here, regular expressions – even in a powerful language like APL – are sharp tools that are hard to beat, and any programmer worth their salt owes it to themselves to master them. In the case above, had the data not neatly been parseable as XML, it would have been more awkward to solve a problem like this relying only on APL primitives.

## Problem 4 – Bioinformatics (2 tasks)

Level of Difficulty: Medium

The two tasks making up Problem 4 are borrowed from Project Rosalind, which is a Bioinformatics problem collection that often has great APL affinity:

and a hint that one benefits from understanding modular multiplication, as this isn’t built into Dyalog APL.

Here is a great example:

``````revp ← {                    ⍝ r ← revp dna
dnaNum ← 'ACGT'⍳⍵        ⍝ Convert to 1..4 so that A+T = C+G = 5
FindRevp ← {             ⍝ Given chunk size, extract positions and build the output format
chunks ← ⍵,/dnaNum
isRevp ← (⊢≡5-⌽)¨chunks
⍵,⍨⍪⍸isRevp
}
⊃⍪/FindRevp¨4 6 8 10 12  ⍝ Test against all chunk sizes and collect results
}
``````
``````sset ← {          ⍝ r←sset n
bin ← 2⊥⍣¯1⊢⍵  ⍝ Binary digits
arr ← ⌽2*bin   ⍝ Repeated squaring: Starting from MSB and 1, square ⍵, multiply ⍺, modulo m
mod ← 1000000
{mod|⍺×⍵*2}/arr,1
}
``````

This contestant also saw fit to include their test suite; a nice touch! Roger Hui’s version of assert has become the de facto standard, and the contestant puts it to good use:

``````Assert ← {⍺←'assertion failure' ⋄ 0∊⍵:⍺ ⎕SIGNAL 8 ⋄ shy←0} ⍝ Roger Hui's Assert
``````
``````RevpTest ← {
s ← 'TCAATGCATGCGGGTCTATATGCAT'
ans ← revp s
Assert 8 2≡⍴ans:
Assert 5 4 7 4 17 4 18 4 21 4 4 6 6 6 20 6≡∊ans:

header ← 'Contest2020/Data/'  ⍝ Change as needed
Assert ans1 ≡ revp data1:
Assert ans2 ≡ revp data2:
'Test passed'
}
``````
``````SsetTest ← {
Assert 8 = sset 3:
Assert 551872 = sset 857:
Assert 935424 = sset 870:
'Test passed'
}
``````

## Problem 5 – Future and Present Value (2 tasks)

Level of Difficulty: Medium

Problem 5 is some hedge fund maths, or something where my eyes glazed over before I fully understood the ask. What is this, K‽

This solution is impressively compact – I removed the comments to highlight the APL artistry on display: no less than three scans, count ’em!

``````rr ← {AR×+\⍺÷AR←×\1+⍵}
pv ← {+/⍺÷×\1+⍵}
``````

Here’s how the competitor outlined how their solution works:

This can be calculated elegantly with the following operations:

1. Find the accumulated interest rate (`AR`) for each term (`AR←×\1+⍵`).
2. Deprecate the cashflow amounts by dividing them by `AR`. This finds the present value of all the amounts.
3. Accumulate all the present values of the amounts to find the total present value at each term.
4. Multiply by `AR` to find future values at each term.

This way the money that was invested or withdrawn in a term is not changed for that term, but the money that came from the previous terms is multiplied by the current interest rate for each term arriving to the correct recurrent relation:

 Step 2) `amounts[i]/AR[i] ⍝ ≡ PV[i]` Step 3) `amounts[i]/AR[i] + APV[i-1]` Step 4) `amounts[i] + APV[i-1]×AR[i]` `amounts[i] + APV[i-1]×AR[i-1]×(1+rate[i])` `amounts[i] + r[i-1]×(1+rate[i]) ⍝ ≡ r[i]`

## Problem 6 – Merge (1 task)

Level of Difficulty: Medium

Mail merge – gotta love it. Your spam folder is full of bad examples of this: “Dear \$FIRSTNAME, do you want to purchase a bridge?” We’re given a template file with patterns such as `@firstname@` which are to be replaced with values stored in a JSON file. Here’s a smart approach from a competitor who knows their way around the `@` operator:

``````Merge ← {
templateFile ← ⍺
jsonFile ← ⍵
template ← ⊃⎕NGET templateFile
ns ← ⎕JSON⊃⎕NGET jsonFile

getValue ← {
0=⍴⍵:,'@'   ⍝ '@@'         → ,'@'
6::'???'    ⍝ ~⍵∊ns.⎕NL ¯2 → '???'
⍕ns⍎⍵       ⍝  ⍵∊ns.⎕NL ¯2 → ⍕ns.⍵
}
∊getValue¨@(⍴⍴1 0⍨)'@'(1↓¨=⊂⊢)template
}
``````

The key insight here is that since each template starts and ends with the same marker, we can partition the data on sections beginning with `@` and then we’ll have a vector where every other element is a template to be substituted. Here’s an example of this:

````      ↑('@'(1↓¨=⊂⊢) '@title@ @firstname@ @lastname@, would you be interested in the Brooklyn Bridge?') (1 0 1 0 1 0)````
┌─────┬─┬─────────┬─┬────────┬─────────────────────────────────────────────────┐
│title│ │firstname│ │lastname│, would you be interested in the Brooklyn Bridge?│
├─────┼─┼─────────┼─┼────────┼─────────────────────────────────────────────────┤
│1    │0│1        │0│1       │0                                                │
└─────┴─┴─────────┴─┴────────┴─────────────────────────────────────────────────┘
``````

I added the second row for clarity to show the alternating templates. Cool, huh? However, this only works correctly if the data leads with a template. Consider:

````      '@'(1↓¨=⊂⊢) 'Dear @firstname@ @lastname@, or maybe the Golden Gate?'````
┌─────────┬─┬────────┬───────────────────────────┐
│firstname│ │lastname│, or maybe the Golden Gate?│
└─────────┴─┴────────┴───────────────────────────┘
``````

We still have the alternating templates, but the prefix (`Dear `) is lost. We can tweak the `Merge` function a bit to cater for this if we need to:

``````Merge ← {
templateFile ← ⍺
jsonFile ← ⍵
template ← ⊃⎕NGET templateFile
ns ← ⎕JSON⊃⎕NGET jsonFile
first ← templ⍳'@'
first>≢templ: templ    ⍝ No templates at all
prefix ← first↑templ   ⍝ Anything preceding the first '@'?

getValue ← {
0=⍴⍵:,'@'   ⍝ '@@'         → ,'@'
6::'???'    ⍝ ~⍵∊ns.⎕NL ¯2 → '???'
⍕ns⍎⍵       ⍝  ⍵∊ns.⎕NL ¯2 → ⍕ns.⍵
}
∊prefix,getValue¨@(⍴⍴1 0⍨)'@'(1↓¨=⊂⊢)template
}
``````

Now, the competition is pitched such that “proper array solutions” are preferred – and for good reasons, most of the time. However, it’s hard to overlook some industrial regex action in this case. Strictly for Perl-fans:

``````Merge ← {
mrg ← ⎕JSON⊃⎕NGET ⍵
keys ← mrg.⎕NL¯2
vals ← mrg.⍎¨keys

('@',¨(keys,'' '[^@]+'),¨'@')⎕R((⍕¨vals),'@' '???')⊃⎕NGET ⍺
}
``````

## Problem 7 – UPC (3 tasks)

Level of Difficulty: Medium

Problem 7 had us learning more about bar codes than we ever thought necessary. Read them, write them, verify them, scan them – forwards and backwards no less. Good scope for stretching your array muscles on this one. The eagle-eyed amongst you may have spotted that the verification aspect is a simplified version of Luhn’s algorithm, which a certain Morten Kromberg used to illustrate APL’s array capabilities at JIO a while back.

Here’s a good solution:

``````CheckDigit ← (10|∘-+.×∘(11⍴3 1))          ⍝ Computes the check digit for a UPC-A barcode.

UPCRD ← 114 102 108 66 92 78 80 68 72 116 ⍝ Right digits of a UPC-A barcode, base 10.
bUPCRD ← ⍉2∘⊥⍣¯1⊢UPCRD                    ⍝ Bit matrix with one right digit per row.
``````
``````WriteUPC ← {
⍝ Writes the bits of a UPC-A barcode.
~((11∘=≢)∧(∧/0∘≤∧≤∘9))⍵: ¯1            ⍝ Check for simple errors
b ← bUPCRD[⍵,CheckDigit ⍵;]
1 0 1, (,~6↑b), 0 1 0 1 0, (,6↓b), 1 0 1
}
``````
``````ReadUPC ← {
⍝ Reads a UPC-A barcode into its digits.
~(∧/0∘≤∧≤∘1)⍵: ¯1                 ⍝ Input isn't a bit vector
95≠≢⍵: ¯1                         ⍝ Number of bits must be 95
(b l m r e) ← ⍵ ⊂⍨ (∊¯1∘↓,⌽) (3↑1)(42↑1)(5↑1)

b ∨⍥(≢∘1 0 1) e: ¯1               ⍝ Wrong patterns for the guards
m≢0 1 0 1 0: ¯1
bits ← ↓12 7⍴ l,r
C ← (↓bUPCRD)∘⍳ ~@(⍳6)            ⍝ Convert bits to digits
tf ← ~∧/10 > nums ← C bits        ⍝ Should we try flipping the bits?
nums ← (nums×1-tf) + tf×C⌽↓⌽↑bits
∨/10=nums: ¯1                     ⍝ Bits simply aren't right
(¯1↑nums)≠CheckDigit 11↑nums: ¯1  ⍝ Bad check digit
nums
}
``````

## Problem 8 – Balancing the Scales (1 task)

Level of Difficulty: Hard

Our task is to partition a set of numbers into two groups of equal sum if this is possible, or return `⍬` if not. This is a well-known NP-complete problem called The Partition Problem and, as such, has no polynomial time exact solutions. The problem statement indicates that we only need to consider a set of 20 numbers or fewer, which is a bit of a hint on what kind of solution is expected.

This problem, in common with many other NP problems, also has a plethora of interesting heuristic solutions: polynomial algorithms that whilst not guaranteed to always find the optimal solution will either get close, or be correct for a significant subset of the problem domain in a fraction of the time the exact algorithms would take.

However, it’s clear that Dyalog expects us to give an exact solution, and has given us an upper bound on the input data length. Finally, we’re offered the cryptic advice that

Understanding the nuances of the problem is the key to developing a good algorithm.

Yes, thank you, master Yoda.

Here’s a great, efficient solution:

``````Balance←{
sum←1⊥⍵
2|sum: ⍬   ⍝ Lists with an odd sum cannot be split into equal parts.
halfsum←sum÷2

⍝ A partitioning method based on the algorithm by Horowitz and Sahni.
⍝ The basic idea of the algorithm is to split the input into two parts,
⍝ and then generate all subset sums for these parts. Then the problem
⍝ becomes finding a sum of two subset sums from different parts
⍝ equal to the desired value. Instead of sorting the sums and comparing
⍝ them like in the original algorithm, standard APL searching primitives
⍝ ∊ and ⍳ are used. Another key idea is to generate the subset sums
⍝ in a specific order, so that the nth subset sum in the vectors a and b
⍝ is the sum of the elements chosen by the binary representation of n.
⍝ This means that we can get the elements of the solution sum
⍝ without having to generate anything but the sums.
horowitzsahni←{
s←⍵(↑{⍺⍵}↓)⍨⌊2÷⍨≢⍵                          ⍝ Split the input.
a b←⊃¨(⊢,+)/¨s,¨0                           ⍝ Generate the subset sums.
indexes←a {(⊢,⍵⍳⍺⌷⍨(≢⍺)⌊⊢)1⍳⍨⍺∊⍵} halfsum-b ⍝ Search for solution indexes.
indexes>≢b: ⍬
⍵ {(⍺/⍨~⍵)(⍵/⍺)} ∊(2⍴¨⍨≢¨s)⊤¨indexes-1      ⍝ Get the solution from the indexes.
}

⍝ A simple exhaustive search. It uses the same binary representation
⍝ idea as the horowitzsahni function.
exhaustive←{
i←halfsum⍳⍨⊃(⊢,+)/⍵,0
i>2*≢⍵: ⍬
⍵ {(⍺/⍨~⍵)(⍵/⍺)} (2⍴⍨≢⍵)⊤i-1
}

⍝ The exhaustive method performs better than the Horowitz-Sahni method
⍝ for small input sizes. 14 seems to be a reasonable cutoff point.
14>≢⍵: exhaustive ⍵
horowitzsahni ⍵
}
``````

There are a number of clever touches here – there are actually two different solutions, an exhaustive search and an implementation of the algorithm due to Horowitz and Sahni, which, although still exponential, is known to be one of the fastest for certain subsets and input sizes. A switch based on input size checks for the crossover point and chooses the fastest option. And this is fast – five times faster than that of the Grand Prize winner, and four orders of magnitude faster than the slowest solution.

Such a performance spread is intriguing, so there are clearly lessons to be learned here. When I tried this problem, I ended up with a pretty straight-forward (a.k.a. naive) brute force search:

``````Balance ← {⎕IO←0
total ← +/⍵
2|total: ⍬             ⍝ Sum must be divisible by 2
psum ← total÷2         ⍝ Our target partition sum
bitp ← ⍉2∘⊥⍣¯1⍳2*≢⍵    ⍝ All possible bit patterns up to ≢⍵
idx ← ⍸<\psum=bitp+.×⍵ ⍝ First index of partition sum = target
⍬≡idx: ⍬               ⍝ If we have no 1s, there is no solution
part ← idx⌷bitp        ⍝ Partition corresponding to solution index
(part/⍵)(⍵/⍨~part)     ⍝ Compress input by solution pattern and inverse
}
``````

If you come to APL from a scalar language, that approach must seem incredibly wasteful: make all bit patterns. Try all sums. Search for the right one, if it exists. But as it turns out, this is APL home turf advantage. Let’s try to demonstrate this point. If you did this “loop and branch”, you’d iterate over the bit patterns and stop once you find the first solution – in fact, for the test data in the problem specification, the first solution appears at around the 1500th bit pattern if you generate them as I do above. The vector version would need to consider the whole space of around

````      ¯1+2*20````
1048575
``````

a million or so, so quite a difference. Surely, in this case the scalar approach should be way faster? Only one way to find out. We can make a scalar version in several ways – here’s the “Scheme” version:

``````BalanceScalar ← {⎕IO←0     ⍝ Warning: this is not the APL Way, as we shall see.
total ← +/⍵
2|total: ⍬             ⍝ Sum must be divisible by 2
psum ← total÷2         ⍝ Our target partition sum
data ← ⍵
bitp ← ↓⍉2∘⊥⍣¯1⍳2*≢⍵   ⍝ Pre-compute the bit patterns
{                      ⍝ Try one sum after the other, halt on first solution
0=⍵: ⍬
patt ← ⍵⊃bitp
psum=patt+.×data: (patt/data)(data/⍨~patt) ⍝ Exit on first solution found
∇¯1+⍵
} ¯1+≢bitp
}
``````

Dyalog’s got game when it comes to tail call optimisation, right? OK, let’s race:

``````      'cmpx'⎕CY'dfns'
d ← 10 81 98 27 28 5 1 46 63 99 25 39 84 87 76 85 78 64 41 93
cmpx 'Balance d' 'BalanceScalar d'``````
Balance d       → 2.7E¯2 |   0% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
* BalanceScalar d → 3.9E¯2 | +43% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
``````

Vectorisation, Boolean vectors and primitive functions wins the day. We didn’t go completely scalar, to be fair, as we still pre-computed all the binary patterns.

But back to the task at hand – let’s pit ourselves against the intellectual might of Horowitz and Sahni:

``````horowitzsahni←{
sum←1⊥⍵
2|sum: ⍬   ⍝ Lists with an odd sum cannot be split into equal parts.
halfsum←sum÷2
s←⍵(↑{⍺⍵}↓)⍨⌊2÷⍨≢⍵                          ⍝ Split the input.
a b←⊃¨(⊢,+)/¨s,¨0                           ⍝ Generate the subset sums.
indexes←a {(⊢,⍵⍳⍺⌷⍨(≢⍺)⌊⊢)1⍳⍨⍺∊⍵} halfsum-b ⍝ Search for solution indexes.
indexes>≢b: ⍬
⍵ {(⍺/⍨~⍵)(⍵/⍺)} ∊(2⍴¨⍨≢¨s)⊤¨indexes-1      ⍝ Get the solution from the indexes.
}
``````
````      cmpx 'horowitzsahni d' 'Balance d' 'BalanceScalar d'````
horowitzsahni d → 4.7E¯5 |      0%
* Balance d       → 2.8E¯2 | +59266% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
BalanceScalar d → 4.0E¯2 | +84466% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕
``````

Ouch! Well, told you my exhaustive search was naive. An impressive performance from the competitor – but also an impressive performance from Dyalog APL – even my knocked up exhaustive search runs in a pretty decent 25–30ms or so, about half the time of my shoddy Python attempt (although out-speeding Python is a low bar). I’m keeping the above implementation of Horowitz/Sahni handy for next edition of Advent of Code, where this problem always seems to crop up in some shape or form.

## Problem 9 – Upwardly Mobile (1 task)

Level of Difficulty: Hard

And so for the final question. We were offered strong hints that a neat array-oriented solution might not be possible, but that the judges were prepared to be proven wrong.

Here’s a nicely compact, recursive solution:

``````∇ weights ← Weights filename;diag;FindWeights;start
diag ← ↑(≠∘(⎕UCS 10)⊆⊢)⊃⎕NGET filename
FindWeights ← {
'┌┐│'∊⍨⊃⍵: ∇1↓⍵                    ⍝ if on any of these, go down
⎕A∊⍨⊃⍵: ⎕A=⊃⍵                      ⍝ if on a letter, give weights
r_disp ← '┐'⍳⍨0⌷⍵                  ⍝ otherwise, (i.e. on '┴'), find the displacement of right branch,
l_disp ← -1+'┌'⍳⍨⌽0⌷⍵              ⍝ ...and the left branch
wts ← ↑(∇r_disp⌽⍵)(∇l_disp⌽⍵)      ⍝ recurse,
+⌿wts×⌽(+/wts)×r_disp (-l_disp) ⍝ ...and calculate new weights
}
start ← diag⌽⍨⍸'┴│'∊⍨0⌷diag            ⍝ starting position attained by ⌽'ing to '┴' or '│'
weights ← (~∘0÷∨/)FindWeights start    ⍝ remove 0s and get lowest weights
∇
``````

Finally, someone took the suggestion that an array-based solution might not be possible as a personal challenge and produced the following:

``````Weights ← {
m  ← ↑(⎕UCS 10)(≠⊆⊢)⊃⎕NGET ⍵ ⍝ no empty lines midway through so this is fine
fm ← m='┴'               ⍝ fulcrum mask
ER ← {+\1-⍵\¯2-⌿0⍪⍸⍵}    ⍝ distance to closest 1 to the left

wa ← +/,m∊⎕A             ⍝ weight amount
wi ← (⍳wa)@{⍵} m∊⎕A      ⍝ weight indexes
fa ← +/,fm               ⍝ fulcrum amount
fir← wa + ⍳fa            ⍝ fulcrum indexes (reduced)
fi ← fir@{⍵} fm          ⍝ fulcrum indexes
ai ← fi+wi               ⍝ all indexes
ai+← ⍉(m∊'┌┐') {⍺\⍵/⍨⍵≠0}⍤1⍥⍉ 0@1⊢ai ⍝ extend indexes upwards to the ┌┐s that need them (exclude top ┴ as it isn't matched)

ld ←  ER⍤1⊢ m='┌'        ⍝ distance to left
rd ← ⌽ER⍤1⌽ m='┐'        ⍝ distance to right
xp ← (⍴m)⍴⍳2⊃⍴m          ⍝ x position
fml← ↓fm                 ⍝ fulcrum mask & its lines
ail← ↓ai                 ⍝ all index lines
GET← {⊃,/ail⌷⍨∘⊂¨fml/¨⍵} ⍝ get an item of ai for each fulcrum at x position ⍵
lir← GET ↓xp-ld          ⍝ left indexes (reduced)
rir← GET ↓xp+rd          ⍝ right indexes (reduced)
ldr← fm /⍥, ld           ⍝ left distance (reduced)
rdr← fm /⍥, rd           ⍝ right distance (reduced)

in ← ↑⊃{(+/⍵[⍺])@(⊃⍺)⊢ ⍵}/ (↓⍉↑fir lir rir) , ⊂↓(⍳fa+wa)∘.=⍳wa ⍝ included weights for each index
cf ← (ldr ×⍤¯1⊢ in[lir;]) - rdr ×⍤¯1⊢ in[rir;] ⍝ coefficients
ws ← (1,(≢cf)⍴0) ⌹ ((2⊃⍴cf)↑1)⍪cf              ⍝ unscaled weights
(⊢÷∨/) ws                                      ⍝ scale weights to integers
}
``````

I take my hat off in admiration of the audacity: “An array solution might not be possible, eh? Hold my beer.”

So there we have it, a smörgåsbord of clever solutions to serve as an inspiration for us all. The 2020 edition of the competition sported a slightly simplified format where you were expected to tackle every problem instead of the approach in previous years where you had to make a subset selection from themed groups – this new approach remains for the current (2021) edition.

You are taking part, aren’t you?