Mount Solitary Loop

Overnight. Starts and ends at Katoomba.

Day 1: Descend into the valley, follow Federal Pass west, then Ruined Castle Walking Track. Camp at Chinaman's Gully or elsewhere on the plateau.

Day 2: Follow the Mount Solitary ridge line down to Sublime Point Trail, and walk back to Federal Pass. Depending on where you camp this last day can be quite long, so leave early.

The only reliable source of water is at Kedumba River on the second day, so bring plenty of water.

Splendour Rock via Narrow Neck

Overnight. Starts and ends at Katoomba.

Day 1: Cycle down Narrow Neck, dump bikes at the lookout. Take Taros Ladder or Duncans Pass down and follow the track to the walk's best water source, at Mobbs Soak.

Take the path left of the toilet and continue until you see a cairn marking a left turn onto the trail up to Mount Dingo. Camp anywhere before Splendour Rock.

Day 2: The reverse.

There is apparently a place upstream at Mobbs to get water, but we couldn't find it, so we got water here from a small drip below the boardwalks before the campsite.

The trail near Mobbs Soak was very leechy in late March.

There's an alternate route that goes up over the ridge line, instead of alongside it, starting from the end of the fire trail, but we were advised against it by some other trampers. Apparently it's quite overgrown. On the second day we checked out the trail at the Mount Dingo side, and it seemed ok there.

import sys
from bidict import bidict

gates = {}
nodes = set()

for line in sys.stdin.read().split('\n\n')[1].splitlines():
    a, op, b, _, c = line.split()
    gates[c] = (op, a, b)
    nodes.update((a, b, c))

nodes = sorted(nodes)
x = [p for p in nodes if p[0] == 'x']
y = [p for p in nodes if p[0] == 'y']
z = [p for p in nodes if p[0] == 'z']

def generate_exprs(gates):
    exprs = bidict()
    def go(p):
        if p in exprs:
            return
        if p in x or p in y:
            exprs[p] = (p,)
        else:
            op, a, b = gates[p]
            go(a)
            go(b)
            exprs[p] = (op, *sorted((exprs[a], exprs[b])))
    for p in nodes:
        go(p)
    return exprs

def objective(n):
    if n == 0:
        return ('XOR', ('x00',), ('y00',))
    else:
        return ('XOR', carry(n - 1), ('XOR', (x[n],), (y[n],)))

def carry(n):
    if n == 0:
        return ('AND', ('x00',), ('y00',))
    else:
        return ('OR', ('AND', carry(n - 1), ('XOR', (x[n],), (y[n],))), ('AND', (x[n],), (y[n],)))

def repair(gates, exprs, p, obj):
    def go(p, obj):
        if exprs[p] == obj:
            return
        if (res := exprs.inv.get(obj)):
            return (p, res)
        else:
            op, a, b = gates[p]
            obj_op, obj_a, obj_b = obj
            if op != obj_op:
                raise Exception
            if go(a, obj_a) is None:
                return go(b, obj_b)
            if go(b, obj_b) is None:
                return go(a, obj_a)
            if go(a, obj_b) is None:
                return go(b, obj_a)
            if go(b, obj_a) is None:
                return go(a, obj_b)
            raise Exception
    return go(p, obj)

swaps = []

for i in range(45):
    exprs = generate_exprs(gates)
    match repair(gates, exprs, z[i], objective(i)):
        case (p, q):
            swaps.extend((p, q))
            gates[p], gates[q] = gates[q], gates[p]

print(','.join(sorted(swaps)))

Repo.all from p in Post, preload: [:comments]

or by restructuring the result of an explicitly written join tree:

Repo.all from p in Post,
  join: c in assoc(p, :comments),
  where: c.published_at > p.updated_at,
  preload: [comments: c]

This works when the nested structs are already associations in the schema, but what if we want to load ad-hoc fields, or if we don't want to use a schema at all?

Manually rearranging the result in Elixir

For example, suppose users can react to comments, so each Comment has a number of Reaction children. How would we return a list of all posts, as well as the most recent comment for each post, as well as all the reactions for each comment? I.e. we want to somehow return:

[
  %{
    post: %Post{},
    last_comment: %Comment{
      reactions: [
        %Reaction{},
        ...
      ]
    }
  },
  ...
]

The SQL is straightforward:

select ...
from posts p
left lateral join (
  select ...
  from comments c
  where c.post_id = p.id
  order by c.inserted_at desc
  limit 1
) lc on true
left join reactions r on r.comment_id = lc.id

One option is to translate the SQL directly into Ecto query syntax:

Repo.all from p in Posts,
  as: :post,
  left_lateral_join: lc in subquery(
    from c in Comment,
    where: c.post_id == parent_as(:post).id,
    order_by: [:desc, c.inserted_at],
    limit: 1),
  on: true,
  left_join: reaction in assoc(lc, :reactions),
  select: %{post: p, last_comment: lc, reaction: r}
)

This returns a flat list of rows, so we need to manually restructure the result into a list of nested structs:

# Input:
# [
#   %{post: %Post{}, last_comment: %Comment{}, reaction: %Reaction{}},
#   ...
# ]
#
# Output:
# [
#   %{post: %Post{}, last_comment: %Comment{reactions: [%Reaction{}, ...]}}
# ]

def restructure(rows) do
  # Elixir code goes here
end

This is a fair bit of work, but workable and very flexible.

Using JSON

We can save some work by returning a tree-like object from the database with json_agg:

Add association and preload

Cannot be done dynamically. Why?

Return json and cast

The area corresponding to \(\sin \theta \cos \theta\) is easy to see—it's the lower right-angle triangle. The area corresponding to \(\sin 2 \theta\) is slightly harder to see. Since the height of the the \(2\theta\) point is \(\sin 2 \theta\) the triangle with base length \(1\) will also have area \(\frac{1}{2} \sin 2 \theta\). Thus the diagram becomes:

The area of the big triangle is \(\frac{1}{2} \sin 2 \theta\) and the area of the small triangle is \(\frac{1}{2} \sin \theta \cos \theta\). We want to show that the area of the big triangle is twice the area of the small triangle. The symmetry of the diagram begs for another small triangle to be placed:

The areas of the kite and the triangle are equal, and hence \(\sin 2 \theta = 2 \sin \theta \cos \theta\). This is seen by symmetry along the dotted lines below: