Bubbler

@mousetail'he-him' ngn/k, 8 bytes: <!/=\_:\

SpaceChem, Opus Magnum

because if you looksay 2222 then you'd get 42, not 2222

Is 2222 -> 2222 a valid looksay inverse?

so 2 is funny, TIL

construct a matrix with GF(2) as its element type, and invert it using ^(-1)

@Simd Sage

\f a b c d. f a b c == B(B(B K))

lambda calculus with combinators, 1: nBK

no, for example 1101000 & 1100111 = 1100000, 1100000 & 1011111 = 1000000

I guess we can make one up based on x = x & (x-1) which deletes the least significant 1 bit from x. So do it twice, and check if it is still nonzero

fwiw all of these count the number of ones; there's none that specifically checks if 3+ bits are ones

also codegolf.stackexchange.com/q/101703/78410

all of c (with gcc), c++ (with gcc or standard c++20), python, rust have one

depending on the language, it is simplest to use the built-in that counts the number of 1 bits for you

first is 4 and second is 13

J, 4+13 bytes: 2#., and 8 8$(64$2)#:]

@Bbrk24 Does this answer your question?

@Bbrk24 In that case you may be able to use Pixi (see its pypi-dependencies setting)

for those using poetry/rye/whatever for python package management, it's about time to move to uv (blog post from the creator of rye, uv)

@Bubbler actually this is wrong. It gives a list of length 14 for 2x3 but OEIS says the answer is 13

@Simd 0000, 0001 (all of those having 1 one), 0011 (two ones in one row), 0101 (two ones in one column), 0110 (two ones diagonally), 0111 (all having 3 ones), 1111

@Simd Yes, that's right

@Simd Handling both looks hard. I'd first generate inequivalent matrices with respect to row permutations only (which is easy: iterate over "combinations with replacement" of size n out of 0000... through 1111...), sort their columns, and remove duplicates out of them

@Simd I think the answer is (2^(n^2) + 2^(ceil(n^2/2)) + 2^(ceil(n^2/4))/3, if I applied Burnside's lemma correctly

damn

@lyxal Do I get full credit for leaving it blank?

@Themoonisacheese I had to experiment with it anyway because Google or-tools uses different sets of heuristics based on the number of threads

like 64 threads on 16-core cpu

TIL too many computational threads can almost lock out the computer

SO does have doing something close in css

define "sparkles"

it does wait 1 second before quitting

it isn't

not particularly bad but a bit funny: Apache Pig is a big data platform and the programming language for it is called Pig Latin

I recognize it by dQ.*cQ

pretty sure it's sorted by number of total posts with that tag

@Neil Then it's my solution (or its mirror image)

@Neil The former works. For the latter, IIUC the 2 on the left side will be split apart, so it doesn't work.

the bonus part of the puzzle yesterday is now a separate puzzle, enjoy

(using killer mode)

simply click a cell to remove a cage containing it

yeah penpa is awesome

IME isolating the 1s is the main part of the challenge

nice, almost

1 cannot be adjacent to another 1 by Fillomino rule

my new puzzle just dropped

lol then that does matter a lot

also I think I'll use iced for graphics/UI and shuttle for deployment this time

The Next Big Thing(TM): a visual playground for multiple ascii-based 2D langs, which will be similar in functionality to my Piet interpreter