The LCD I bought is a Waveshare 2.0″ LCD using an ST7789V driver chip, a variant of a popular (the popular?) LCD driver.

Wiring

The first puzzle was how to wire the LCD to the ESP32.

Different ESP32 module manufacturers provide different module pin counts and I suspect (though haven’t verified) different pinouts for the same pin counts; so I’m specifically referencing the pinouts for the module I’m using.

I found a couple of forum posts — unfortunately didn’t save the links — indicating that the LCD can run on 5V or 3.3V power and that it gets grumpy if the data lines are at a different voltage than its power. This is easily handled — power the LCD from the ESP32′s 3.3V regulator. So first wire the power connections:

Next, the LCD uses SPI, so wire the data and clock lines. The ESP32 has labeled pins for these so I used them; though I saw a forum post that the ESP32′s hardware SPI can be matrixed to any digital I/O pin, so it’s possible that these could be reassigned elsewhere.

Then three LCD pins can be wired to any available I/O, so I picked pins near the others I was already using:

And finally the backlight enable pin, which the schematic shows is pulled high / active so is superfluous unless you want to blank or PWM the backlight:

Arduino Libraries

Waveshare provides their own ST7789 and LCD graphics libraries but I overlooked those, so for what seemed like expedience I loaded the Adafruit ST77* library and Adafruit GFX library.

I could not find, in the documentation or tutorials, the syntax for some fundamentals — to wit, I didn’t find documentation stating the syntax to instantiate a display object, nor documentation of (the correct) syntax to initialize the display object. (I ran across what in retrospect incidentally sort of demonstrated these; but I would like documentation to expressly tell me how to use what I’m trying to use.)

The libraries come with example code and by examining Examples from Custom Libraries / Adafruit ST7735 and ST7789 Library / graphicstest_st7789, and with the help of a forum post, I was able first to get the graphics demo to run on my display and second to write my own code.

The library needs to know where things got wired up:

#define TFT_CS (1) // yellow wire
#define TFT_RST (21) // brown wire
#define TFT_DC (3) // blue wire


Then to be initialized with the right dimensions for this LCD:

// OR use this initializer (uncomment) if using a 2.0" 320x240 TFT:
tft.init(240, 320); // Init ST7789 320x240


And then the demo works.

My Demo

Putting it all together into my own test:

#include <Adafruit_GFX.h>
#include <Adafruit_ST7789.h>

void loop() {
}


This should be regarded as irritating rather than intractable. I present here two workarounds and leave the discovery of more as an exercise for the reader.

Option 1, remove one power-strip row from a modular breadboard and dovetail-pin that breadboard onto another. Install the ESP module over the new “power gutter” and revel in the luxury of plenty of rows for connecting jumpers.

Option 2, SAW THROUGH THAT and revel in the luxury of plenty of rows for connecting jumpers.

Footnote: Use a hacksaw. Its finer teeth cut without snagging like a wood-cutting saw’s teeth would do; I don’t want to contemplate the kind of workholding it would take for me to feel safe using a tablesaw or circular saw on this; and you would be so startled the moment a wood-cutting bandsaw’s teeth first engage in the edge of the plastic and the blade leaps toward you.

My refresher on the basics came from https://samueladesola.medium.com/how-to-set-up-esp32-wroom-32-b2100060470c, although he had to go through some steps I didn’t and vice-versa.

First, go to File / Preferences / Additional boards manager URLs and add
https://dl.espressif.com/dl/package_esp32_index.json to indicate another repository to search for board definitions.

Then Tools / Board / Boards Manager... to pick an available board bundle, start typing esp32, and click to install esp32 by Espressif Systems .

I’m installing this on my Linux workstation so I had to give myself permission to access the USB port, which was:

sudo usermod -aG dialout neufeld

To make that group change take effect, I was only supposed to need to logout; but doing so added me to the entry in /etc/group but didn’t activate the group membership when I ran id or tried to access the device file. I had an OS update to apply anyway so I rebooted and all was well.

Back in the Arduino IDE, Select Other Board and Port, start typing esp32 dev into the board search, and pick ESP32 Dev Module when it popped up.

Weirdly, even with the USB serial port selected (and accessible), it complains that no boards were found — but it works.

Finally, File / Examples / 01.Basics / Blink to make sure I can compile and upload code to the correct board.

Blink relies on an LED_BUILTIN macro that’s not defined in this Espressif board spec. This forum post suggested pin 2 for the built-in LED on this board and adding

#define LED_BUILTIN (2)

did the trick. Compile, upload, and I have a blinking blue LED next to the red power LED.

RL

AAA = (BBB, CCC)
BBB = (DDD, EEE)
CCC = (ZZZ, GGG)
DDD = (DDD, DDD)
EEE = (EEE, EEE)
GGG = (GGG, GGG)
ZZZ = (ZZZ, ZZZ)


All one need do is make a hash of the nodes with their branches, then dance through it.

my %index = ( L => 0, R => 1 );

The dance moves are specified as L or R and for no particular reason I decided to save the branches as arrays instead of hashes, so I prepare to translate dance moves into array indices. Why on earth did I call this %index instead of %dirindex or %dir? Because I had just woken up and it was time to do AoC? Probably.

$_ = <>; chomp;
my @instr = map { $index{$_} } split(//);

<>;


I grab the dance moves, translate them from directions to indices, and toss the following blank line.

my %map;
while (<>) {
my ($node, $l, $r) = /(\w{3})/g;
$map{$node} = [ $l, $r ];
}


Then read in and save all the nodes.

my $count = 0;
my $pos = "AAA";

until ($count % @instr == 0 && $pos eq "ZZZ") {
$pos = $map{$pos}[$instr[$count++ % @instr]];
}


Finally, start at AAA; take steps, counting as I go (and using the modulus of the number of dance moves in the pattern); and stop at ZZZ only if it's the end of this dance pattern.

Full Program

#!/usr/bin/perl

print "$count steps\n";


my $cardlist = "AKQT98765432J";

Change the card sort order;

my $jokers = grep { $_ eq "J" } @cards;

count the jokers;

++ $tally{$_} foreach grep { $_ ne "J" } @cards;

omit the jokers when counting cards for type of hand;

$ofakind[0] += $jokers;

and in this poker variant, simply add the count of jokers to the count of the most-frequent card when determining type of hand.

Full Program

#!/usr/bin/perl

sub cardval {
my $c = shift;
my $cardlist = "AKQT98765432J";
return length($cardlist) - index($cardlist, $c);
}


32T3K 765
T55J5 684
KK677 28
KTJJT 220
QQQJA 483


This sort is going to require a fair number of comparisons, each involving rank of types of hands and each potentially involving rank of cards. These comparisons are computationally-intensive enough that I’m leery about executing them during each comparison of the sort, so I calculated and cached them up front.

sub cardval {
my $c = shift;
my $cardlist = "AKQJT98765432";
return length($cardlist) - index($cardlist, $c);
}


The card’s rank can be represented as its (here 0-based) ordinal position in an ascending-order list of ranks. I had a descending-order list and subtracted the position in the string from the length of the string; but doing this again, I’d use Perl’s reverse operator to reverse the string.

$cardlist is constant and it would be more efficient to declare it once outside the subroutine than each time the subroutine is called. I’d love to define it immediately before the subroutine definition, but that code won’t have been executed yet when the subroutine is called. I could have defined it at the top of the program but I don’t like separating it so far from its sole use in the code. I don’t know whether Perl has developed a better way to handle this situation.

while (<>) {
my ($cards, $bid) = /(\w+)/g;
my @cards = split(//, $cards);
my @values = map { cardval($_) } @cards;


Reading in the hands, I grab the two chunks of “word” characters, split the card string into a list, and use Perl’s map operator to translate the list of cards into a list of their values/ranks.

my %tally;
++ $tally{$_} foreach @cards;
my @ofakind = sort { $b <=> $a } values %tally;
my $type = $ofakind[0] == 5 ? 6 # 5 of kind -- 6
: $ofakind[0] == 4 ? 5 # 4 of kind -- 5
: $ofakind[0] == 3 && $ofakind[1] == 2 ? 4 # full house -- 4
: $ofakind[0] == 3 ? 3 # 3 of kind -- 3
: $ofakind[0] == 2 && $ofakind[1] == 2 ? 2 # 2 pair -- 2
: $ofakind[0] == 2 ? 1 # 1 pair -- 1
: 0; # nothing -- 0


Then I count how many of each rank of card I have in this hand and sort that list of counts into descending order. From the number of cards that I have the most of, and sometimes the second-most of, I can determine the type of the hand; and I assign a numerical score to each type.

When we have three or two of the most-frequent card, there are two possible types of hands depending on whether the remaining cards contain a pair. I could have written those four cases as two outer ternaries each with an inner ternary; but for ease of reading (and I assure you my code is nicely tabbed and aligned when you’re not looking at it in WordPress), I didn’t mind the expense of rechecking the count of the most-frequent card in order to write the code for every type of hand the same way.

push(@hands, { CARDS => [ @cards ], BID => $bid, VALUES => [ @values ],
TYPE => $type });
}


I’ve now precalculated everything that I wanted to cache before the sort and I hang onto it in a list of references to anonymous hashes, which function like a C struct, with the hash key being the struct member.

I don’t actually need the cards any more, but cached them in case I wanted them later for debugging.

my @sortedhands = sort { ${$a}{TYPE} <=> ${$b}{TYPE}
|| ${$a}{VALUES}[0] <=> ${$b}{VALUES}[0]
|| ${$a}{VALUES}[1] <=> ${$b}{VALUES}[1]
|| ${$a}{VALUES}[2] <=> ${$b}{VALUES}[2]
|| ${$a}{VALUES}[3] <=> ${$b}{VALUES}[3]
|| ${$a}{VALUES}[4] <=> ${$b}{VALUES}[4]
} @hands;


With all that cached, the sort itself is easy. Note that Perl uses the special variables $a and $b for the comparands in each sort comparison; and since we’re sorting a list of hash references, $a and $b do need to be dereferenced.

my $sum;
$sum += ($_ + 1) * $sortedhands[$_]{BID} foreach (0 .. scalar @sortedhands - 1);
print "sum is $sum\n";


With the hands sorted, calculating the requested sum is easy.

Full Program

#!/usr/bin/perl

sub cardval {
my $c = shift;
my $cardlist = "AKQJT98765432";
return length($cardlist) - index($cardlist, $c);
}


The distance traveled is (ignoring units) t_charge ( t_total – t_charge); so the answer to the problem can be found directly by using your favorite quadratic solver on t_charge² – t_total t_charge + d_record = 0, which will have zero, one, or two real solutions. If it has zero solutions, one solution that’s non-integer, or two non-integer solutions between two consecutive integers, then there are zero integer charge times that beat the record. Otherwise count the number of integers from the floor of the lower solution plus one to the ceiling of the upper minus one. (That sounds weird but math it out — it ensures not merely tying the record but beating it.)

Anyone who remembers algebra and has dignity and self-respect would use this trivial approach.

I wrote a program to count winning charge times by iteration.

my $count = grep { $_ * ($t - $_) > $d } (1 .. $t - 1);

All of the Perl syntax in this program, I’ve already used this year, so there’s nothing new to explain. The only thing that seems worth calling out is that finding “qualifying” members of a list, or even of a small range of numbers, is very conveniently done with grep.

Part 2 says that the columns of numbers in the input don’t represent separate races; the spaces between them were unintentional and the digits should be run together into larger numbers. Having already written this in part 1:

@time = /(\d+)/g if /Time/;
@dist = /(\d+)/g if /Dist/;


it was the pinnacle of laziness efficiency to reuse that digit extraction and join the results together:

$t = join("", /(\d+)/g) if /Time/;
$d = join("", /(\d+)/g) if /Dist/;


But one could also use s/[^\d]+//g to delete everything that’s not a digit, if that’s what floats your boat.

Full Part 1 Program

#!/usr/bin/perl

print "product $prod\n";


Full Part 2 Program

#!/usr/bin/perl

print "count $count\n";


After the way I wrote the first program, this made me feel like Obi-Wan just told me to go home and rethink my life. I could enumerate each range of seeds and run them all through the translations … for certain values of “could” that include more processing power, electricity, and time than I have remaining in my years on this planet.

It was obvious that I was going to have to treat ranges as data structures, intersect them with ranges in translation rules, translate them accordingly, and be prepared to split seed ranges that overlapped translation ranges to apply the translation to only a portion of the input range. Afflicted with a serious case of I don’t wanna, I pretended to be too busy with other things to get around to writing this yesterday.

But early this morning I cured my case of I don’t wanna in the way I’ve learned to cure any case related to programming: Write the utilitarian loops that do the boring work of the program; and once they’re done, there’s so little of the program left to write that I’m ready to go ahead and do it.

20231207 edit: I omitted handling one way that intervals can intersect and it was accidental that my program handles that case correctly. More below.

Read the Seed Ranges

In part 1, I iterated through seeds, applying consecutive translations to each. For part 2, I iterate through mapping tables, applying each to all seed ranges / translated seed ranges.

$_ = <>;
chomp;
my @ranges = /(\d+)/g if /^seeds/;


So start by grabbing all of the seed ranges. Don’t bother parsing them into (start, length) pairs yet.

Read a Translation Map

# Loop through mapping rules, applying each to our list of seed ranges.
while (<>) {
# Parse the map, saving destination, start, length, end, and offset.
my @map;
foreach (grep { ! /map/ } split /\n/) {
my @n = split /\s+/;
push @map, { D => $n[0], S => $n[1], L => $n[2],
E => $n[1] + $n[2] - 1, O => $n[0] - $n[1] };
}


Each remaining input record is a translation map. I totes forgot to chomp here and I suspect that split on whitespace (A) matches newlines as whitespace and (B) discards empty trailing fields, but don’t quote me on that without you test it yourself first.

So … split the paragraph into individual lines. Discard the line that has map in it. For the remaining lines, split into whitespace-delimited fields. Create an anonymous hash and push its reference onto the array of this map. I went all out here and precomputed every value I thought I might want later, stuffing them all into the hash: Dest, Source, and Length were provided; and I also calculated End and Offset here because I was going to use them multiple times later and because I was more likely to write an off-by-one error later than when I was paying attention here.

Checking Current Range for Translation Intersection

# Apply this transformation to our list of number ranges,
# building a list of resulting number ranges.
my @newranges;
range: while (@ranges) {
my $s = shift @ranges; my $l = shift @ranges; my $e = $s + $l - 1;


For this set of map rules, loop through all of our current set of ranges of interest. Within each, break out the (start, length) pair and for convenience, also calculate the end of the range.

# Check whether the current range intersects any map range.
maprule: foreach my $href (@map) {
# If this range doesn't intersect this map rule, try the next.
next maprule if $e < $$href{S} || $$href{E} < $s;


Loop through the mapping rules. For each, first check whether the current range of interest doesn't even intersect with the range of this map rule -- the end of the range of interest is less than the start of the map range, or the end of the map range is less than the start of the range of interest. If no intersection with this map rule, go on and try the next.

# If this range is completely enclosed in this map rule, apply.
if ($$href{S} <= $s && $e <= $$href{E}) {
$s += $$href{O};
push(@newranges, $s, $l);
next range;
}


Maybe this range of interest is a subset of the range of the map rule? If so, apply the map rule's translation (offset) to the start of the range, then push the translated (start, length) pair onto the list of new ranges to be used in the next mapping, and move on to the next range of interest.

# This range intersects but is not fully enclosed in
# this map rule. Split, apply the transformation to the
# intersection, and push the leftover back onto this pass.
if ($s < $$href{S}) { # overlaps start of map rule
my $s1 = $s;
my $e1 = $$href{S} - 1;
my $l1 = $e1 - $s1 + 1;
unshift(@ranges, $s1, $l1);

next range;


If we've fallen through the logic to this point, then the range of interest does overlaps this mapping rule's range (and is not simply a subset). Does the range of interest overlap the beginning of the map rule (or the end)?

Either way, break this range of interest into two ranges of interest. In the case of overlapping the beginning of the map range, the first new range of interest is passed back into the list of ranges for the current round (because another map rule might apply to it) with no translation and the second is passed forward for the next round with this translation rule's offset applied. Clearly all of this could have been written in a single line; but breaking it out into variables makes it very clear what I'm doing, is easier for me to avoid more off-by-one errors, costs me next to nothing, and is probably even optimized away.

unshift pushes values onto the beginning of a list (array); push pushes values onto the end. I'm putting the unprocessed leftovers from this cut back onto the beginning of the current list and the translated range from this cut onto the end of next time's list.

And then move on to the next range of interest.

The code for a range of interest that overlaps the end of this mapping rule's range is very similar.

20231207 edit: As I was drafting notes about intervals in preparation for programming, I included the case where a map rule range was completely enclosed within a range of interest, splitting the range of interest into three intervals; but I forgot about that when coding.

Very lucky and very sloppy.

# No intersection, so current range is untouched.
push(@newranges, $s, $l);
}

# Save the resulting list of ranges for next time.
@ranges = @newranges;


If we fall through the loop of testing all of the mapping rules without having matched one and nexted on to the next range of interest, then this range of interest has no translation in this map and is preserved intact for the next round.

Find the Minimum Translated Value

# Find the minimum range start after all processing.
my $min;
while (@ranges) {
my $s = shift @ranges; shift @ranges;
$min = $s if !defined $min || $s < $min;
}


In my approach to part 1, the minimum was captured as a running value along the way; but in part 2, I need to go back and find it myself.

@ranges is (still) an unstructured list of (start, length) pairs and I don't remember if there's a cool-kid way to select alternating values from a list; so I iterate through the list, looking for the minimum range start (which will be the lowest value in any range).

Full Program

#!/usr/bin/perl

print "\nminimum location $min\n";


seeds: 79 14 55 13

...


I went over the top on this problem, loading all of the translations into memory as though they were important, then iterated through seeds in my outer loop and translations looping inside that on each seed.

Parsing the File

sub getinput {
$/ = "\n\n";

while (<>) {
chomp;


$/ is Perl’s input record separator, newline by default. If you set it to something else, each read of a record (line) of input will be separated/ terminated by this record separator. I set it to two newlines to grab a paragraph of input at a time. Then chomp is aware and discards the trailing input record separator (the trailing pair of newlines, not just the last trailing newline).

@seed = /(\d+)/g, next if /^seeds/;

Perl’s regular expression operators work fine on multi-line strings (and have some special modifiers available that I don’t need here). So this line watches for the input paragraph that begins with seeds, grabs ( ) strings of digits \d+ out of it, all of them /g, returns that list, and stores it in the array @seed.

s/(\S+)\s+map:\n//; my $which = $1;
foreach (split /\n/) {
my @n = split /\s+/;
push @{$map{$which}}, { D => $n[0], S => $n[1], L => $n[2] };
}


If a paragraph starts with some kind of map, delete that line of the paragraph, grabbing the map name out of it along the way. Then split the rest of the paragraph into lines; split each line on whitespace (also could have done my @n = /(\d+)/g again but I’m fickle); and treat the %map hash element keyed by $which as an array, pushing an anonymous hash { } onto it keyed mnemonically by Dest, Source, and Length, allowing rapid retrieval of these values later by symbol rather than merely by ordinal position as they were given to us in the puzzle input.

Mapping Values by Range Translations

sub mapval {
my ($src, $lref) = @_;


I want to call this subroutine with parameters: a source (seed) value and an array (list) reference to a set of range translations. Subroutine parameters arrive in the special array @_, so break them out to variables with (vaguely) meaningful names.

my $mapped;
foreach my $href (@$lref) {
$mapped = $$href{D} - $$href{S} + $src
if $src >= $$href{S} && $src <= $$href{S} + $$href{L} - 1;
}


Go through the list @$lref of range translations pointed at by the array reference, each of which is a hash reference. If our seed value is within the range (between $$href{S} and $$href{S} + $$href{L} - 1), then map it by applying the offset between the translation's destination and source.

One could do a last here to avoid testing further translations; but there aren't many per map and each seed will only match one translation per map; so I didn't bother and let it cycle through testing the remaining ranges.

return $mapped || $src;

If we applied a translation, return that, otherwise return the seed value.

Clumsily Calling It All

my $min;
foreach my $seed (@seed) {
my $soil = mapval($seed, $map{"seed-to-soil"});
my $fert = mapval($soil, $map{"soil-to-fertilizer"});
my $water = mapval($fert, $map{"fertilizer-to-water"});
my $light = mapval($water, $map{"water-to-light"});
my $temp = mapval($light, $map{"light-to-temperature"});
my $humid = mapval($temp, $map{"temperature-to-humidity"});
my $loc = mapval($humid, $map{"humidity-to-location"});


Since I'm never going to need these maps again, this was an oddly careful way of setting them up and using them.

I could of course have written this as a deeply-nested series of subroutine calls instead of sequentially capturing all of the intermediate values; but I was expecting to have to debug this (didn't) and wanted the intermediate values at hand for inspection.

Full Program

#!/usr/bin/perl

#print "$src:\t", $mapped ? $mapped : "unmapped", "\n";
return $mapped || $src;
}


It would be vaguely entertaining to implement this using a queue of the coefficients of upcoming lines, or using recursion; but I chose simply to build an array of the multipliers that I prepopulate for lines I haven’t seen yet.

my $wins = grep { my $num = $_; grep { $_ == $num } @winning }
split(/\s+/, $mine);


The program begins the same as part 1; but instead of advancing the value of the wins by a particular algorithm, simply capture the count of winning numbers.

# Add the physical instance of this card to however many we've earned.
my $instances = ++ $cards[$. - 1];
$total += $instances;


However many duplicates of this row/card have been earned by previous results, increment it by one for this actual row; set that as the number of instances of this row; and add that to the total instances for the puzzle answer.

# If this was a winner, clone future cards.
if ($wins) {
$cards[$_] += $instances foreach ($. .. $. + $wins - 1);
}


If we had any winners, then add the number of instances of the current card to the instance count of the appropriate next few cards.

( num .. num ) is a Perl range operator that generates a list of values counting from the lower to the upper. (Use with caution on potentially-large lists, though this may have been optimized.) $. is the current line number of the input but it’s 1-based and Perl’s array is 0-based. So the current line of input $. is in array element $. - 1; therefore array element $. holds the number of (extra) instances of the next line of input and element $. + $wins - 1 holds the number of (extra) instances of $wins rows after the current.

Full Program

#!/usr/bin/perl

print "total: $total\n";