cmpx 'eur makeChangeA 200' 'eur makeChangeB 200'
  eur makeChangeA 200 → 2.3E¯1 |      0%
  eur makeChangeB 200 → 9.0E1  | +39128% ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

I wonder which one I'll submit!

there is no easier way to spell scan inverse, right?

@RubenVerg Nice. You beat me by about a factor of 8.

@B.Wilson thought about it for a while, can't think of any other way to write the function... just a couple days left till we can freely discuss the challenges

curious how yours works

actually, thinking about it some more got me an additional ~50% speedup :) thanks i guess

I managed to get 0.5 sec and proved from complexity wise I cannot get further improvements. Just discover some redundancy but does not improve the running time much.

Well, by some hand optimization it is 469m sec now

@LdBeth for which?

Having the same euro makeChange 200 tested on friend's Core i9, get 210ms.

maybe it is time to retire my intel macbook

i don't know how cpu specs work

but mine does 120ms on a crappy chromebook through two layers of virtual machines

i'm genuinely confused by the fact that others solution to the problem exist, I can only come up with one plus slight variations

intuition tells me .12 on bad hardware and .21 on good hardware aren't the same sol but they might be

@RubenVerg does the output preserves the order? the problem does not require that but I did as I derived my answer from brutal force search

@LdBeth never checked, let me see

i also do bruteforce

dfs iirc

lol then I'm certain it is different because my definition to brute force is "linear search"

for 1 2 5 and 5 mine does

5 0 0
3 1 0
1 2 0
0 0 1

so no it's a different order

@LdBeth that's- that's not an approach I considered even remotely viable

unless we mean different things by linear search

i'd describe my code as dfs, but I'm no data scientist

@RubenVerg it is just the order reversed from my perspective. But if it is dfs the order should not be much different from linear search

I'd say my approach is linear search improved by a sieve

my approach is, uh, try everything and see what fits

also gotta say that one problem about pair flipping was made so much more annoying by the flips being on the last axis

unless i have a completely suboptimal solution it just makes it ugly, would have worked as tacit with first axis flip, but like this it becomes atop after atop after atop and it's just ugly

Yes I figured using ¨ is probably easier than ⌷

@LdBeth my first solution has Each, the one I have now has indexing just because I like it more

my each solution was really ugly

not sure how much more i can say

oh I just realized the competition ends tomorrow night and not tonight

one more day to stress over unnecessary optimizations!