advent | Advent of Code solutions

Java 8 does not support High DPI, the UI gets scaled up by Windows. You should use Java 11 or a later version which support per-monitor High DPI settings.

If your goal is to make the icons look crisp, prepare a set of icons for different resolutions using BaseMultiResolutionImage (the basic implementation of MultiResolutionImage) to provide higher resolution alternatives. (These are not available in Java 8.)

You say that you scaled down the original image (240×240) to 18×18px. If the UI needs a higher resolution according to the system setting, all it has now is your small icon (18×18) which will be scaled up, which results in poor quality. You should use a MultiResolutionImage or paint the original image into the required size, letting Graphics to scale it down for you.

This is the simplest way I came up with to make the icon 18×18 without downscaling the original image:

FWIW, your sample works fine in AH Formatter. So does wrapping the word in an fo:inline-container with an fo:block that has the hyphenate="false", but FOP 2.6 then puts the word on a separate line (because, I think, the width isn't specified).

The only thing that I've found that works with FOP 2.6 is to turn every character in the fo:inline into an fo:character; i.e., , etc.

Alternatively, you can drop the fo:inline and repeat the hyphenate on every fo:character: , etc.

You can drop the keep-together="always". I haven't seen it have any effect.

Making your own fo:character shouldn't be necessary. Section 1.1.2, Formatting, of the XSL 1.1 Recommendation includes (just after the graphic):

As part of the step of objectifying, the characters that occur in the result tree are replaced by fo:character nodes.

I don't know that any formatter would do that in practice because it would explode the number of objects with (usually) no good effect, but the formatter should behave as if the inherited properties that apply to fo:character apply to every character in a run of text.

This is because readToNumberList is returning a pointer to stack memory that goes out of scope, which is undefined behaviour and not yet caught in debug builds.

Use copied or cloned to convert an Option<&T> to Option. The first is available if T: Copy, the second if T: Clone.

u8 implements both so you can use either method.

Your type is an aggregate

At the implementation level, yes, rebuilding the hash table has a cost that is linear in the number of entries; after all, each entry has to be placed in a new bucket of the enlarged hash table array. However, the entries themselves do not need to be reallocated; the only memory management changes are for the hash table arrays themselves (allocate new, dispose old) so the cost isn't crazy high. The rebuild triggers whenever the number of entries in the hash table exceeds a fixed multiplier of the size of the hash table; that loading factor is a compile time constant. (Dicts are wrappers around hash tables with Tcl_Obj keys, mostly to add value semantics and ensure that the iteration order is consistent; those aren't things that matter for the rebuild semantics.) There's no notion of pre-sizing a hash table; the implementation doesn't expose that in a useful way. It also doesn't shrink the array; once it has grown, it stays grown (and most of the time that's not a problem at all).

The complexities of rebuild semantics are part of why Tcl's associative arrays are said to have a random order of enumeration: it's not actually random, but the deterministic algorithm is sensitive to a lot of factors that people normally ignore. You don't need to care about that when working with dicts, where the order of iteration is exactly knowable from the way that the value was built, irrespective of the details of how the hashing is done.

If you're doing lookups using compact integer keys from 0 up, a list will be substantially faster, as hashing is currently always performed on string representations. Compound integer keys may become nested lists.

The thing is that you need ot apply the logic (count zeros and ones) for each bit position (or each column), not just once as your code does

The easiest is to iterate on the columns, use zip to transpose from the rows, then for each find the most and lest common (one is the opposite of the other)

It's because in the second for loop it says diagArray.length, and it should be diagArray[i].length so that you are getting the length of the second array.

What you want here is a type that you can dereference as &str.

This is usually done with a > generic constraint: