Clojurians Log v2

Feature request: Hoplon support 😉 (kidding, this is not really necessary) A more serious feature request: could the eval keybind be customized? My window manager captures Windows key + Enter and opens a new terminal so the key never gets to the browser 😞

We could totally customize it. Any ideas about how, via a query param or something in localstorage or so?

maybe it's better not to do it via query param since when you share the example, someone else will get the different keybinding as well

Local storage seems better.

Is there a keybind for the "Compile button"?

alt + enter compiles the whole editor

Ok, that helps a lot thanks2

here is the relevant code: https://github.com/squint-cljs/squint/blob/0093bb0c143a05182c923b73c9127b29215004c7/index.html#L91-L100

I guess we could change "modifier" as an option

https://github.com/squint-cljs/squint/blob/0093bb0c143a05182c923b73c9127b29215004c7/index.html#L184

@mynomoto I pushed a change which lets you do: localStorage.setItem("editor.modifier", "Ctrl") in the console, after a refresh you will have Ctrl + enter as the form evaluating key

we can make more configurations (since now Alt + enter overlaps I think), let me know if that is useful to you

Ok, I will. Just tried, doesn't seem live yet.

you need to execute that snipped in the playground, not in any other website

weird, it doesn't seem to work on github pages, but it did locally ;)

seems the page wasn't deployed somehow: https://github.com/squint-cljs/squint/deployments

ah now it's queued with another edit

now it works

This is very useful, works for me now too thanks3

I had a look at your day-1 solution and it is really super sweet. It looks like you didn’t run into the overlapping problem at all with that approach?

From the look of it it also seems like your workflow is to run the program from start every time you have a change? If you like I can show you a more interactive workflow.

You mean the "twone" as 2 and 1 overlapping issue? At first I did code the wrong overlapping solution 🙂

I see. I did too, and I was stuck there for quite a while. Got a bit angry with AOC even. 😃

@pez Sorry, I don't understand the remark on the workflow.

About workflow. I could be wrong, but the way the program is structured indicates that you are not working “in the REPL”, as Clojure allows you to do. Hard to explain, but just a few minutes ago there was a video published on Youtube, demonstrating interactive programming with Clojure. https://www.youtube.com/watch?v=4igO7Qbyj9o I haven’t watched it yet, but I’ve seen other presentations by @pavel.klavik so think I can recommend it unseen.

My offer stands. We can jump in to a huddle quickly and I can show you what I mean.

@pez. 0K. Thanks. You're right there. I've got a REPL working in VSCode. But the way I do it now forces me to code as good as possible right from the start. And the more mistakes I make, the more frustrated I get BUT also the more I get focussed on the code and coding.

Gotcha. I know other Clojure coders who choose to work less interactively.

I do like the REPL (using Calva & deps.edn) in combination with my VSCode. I use it to play around and test all kind of functions. Thanks voor the YT video, and I'll watch that later. (At the moment I'm not creating production Clojure code.)

If you ever need help with Calva, welcome to the #calva channel. 😃

Done now too! Part 2 was actually easy given the datastructure I parsed in part 1. Phew, lucky me 😄

Since we both reported that we felt we over-engineered part 1, @alpox, I had a feeling you would too find part 2 pretty comfortable. 😃

No, I was running it with day 2 input. It takes 1 second to calculate the wrong answer. 😃

But now you don't have a blank canvas anymore 💪 Mine is still blank.

If you've somehow avoided all the talk about it, Day 3 is rough

It’s far from blank. A pretty huge program, actually. I think maybe I coded the first thing I thought of, instead of following @mauricio.szabo’s example, coding the simplest thing I could think of.

I have somehow missed the part of it being rough. Feels a bit better knowing that. Thanks, @elken! 🙏

Especially given it's so early too, a lot of people have said the same 😄

I’m again where my solution works for the test data. I’ll have a look at the input data and see if I can see something. 😃

Day 1 must be the roughest day 1 ever, so maybe only the toughest are still at it day 3? 😃

I somehow managed part 1 and literally felt like throwing my laptop when I read part 2.

Oh, no!

I had initially painted myself in a corner by parsing to a map with the numbers as key, which obviously wouldn’t deal appropriately with the possibility that the same number may appear multiple times… (could it be that I’m not the only one making that unnecessary mistake?)

I bet a lot of people make that mistake. That’s not my mistake, but I thank you for suggesting it, @jurjanpaul502! ❤️

I took three rows of input data and find a $327 at the end of one of the rows that is missing from my answer. So I guess now I’m set for finding my issue. 😃

Happy for the Calva debugger in situations like this.

Part 1 done. So let’s see if my laptop will be in danger now…

I just finished part 1. I feel like I made it too complex though... I wont read part two before sleep to keep my good dreams 😅

Done with part 2. 🎉 Maybe it payed off making part-1 rigorously. 😃

I am absolutely having that experience though so far I have only found the time for day one.

Good summary for me so far

Day 3 felt like a day 8 or 10 to me in terms of difficulty

Yeah, 1 and 3 where more like we usually get for 7 and 8. Most years 1 is a one-liner.

My solution in https://squint-cljs.github.io/squint/?repl=true&boilerplate=https%3A%2F%2Fgist.githubusercontent.com%2Fborkdude%2Fcf94b492d948f7f418aa81ba54f428ff%2Fraw%2Fa6e9992b079e20e21d753e8c75a7353c5908b225%2Faoc_ui.cljs&src=OzsgSGVscGVyIGZ1bmN0aW9uczoKOzsgKGZldGNoLWlucHV0IHllYXIgZGF5KSAtIGdldCBBT0MgaW5wdXQKOzsgKGFwcGVuZCBzdHIpIC0gYXBwZW5kIHN0ciB0byBET00KOzsgKHNweSB4KSAtIGxvZyB4IHRvIGNvbnNvbGUgYW5kIHJldHVybiB4CgooZGVmbiBpbnRlcnNlY3Rpb24gWyYgeHNdCiAgKHJlZHVjZSAoZm4gW2FjYyBzXQogICAgICAgICAgICAoc2V0IChmaWx0ZXIgIyhjb250YWlucz8gYWNjICUpIHMpKSkgeHMpKQoKKGNvbW1lbnQKICAoaW50ZXJzZWN0aW9uIChzZXQgWzEgMiAzXSkgKHNldCBbMSAyXSkpCiAgKQoKOzsgUmVtZW1iZXIgdG8gdXBkYXRlIHRoZSB5ZWFyIGFuZCBkYXkgaW4gdGhlIGZldGNoLWlucHV0IGNhbGwuCihkZWYgbXktaW5wdXQgKC0%2BPiAoanMtYXdhaXQgKGZldGNoLWlucHV0IDIwMjMgNCkpCiAgICAgICAgICAgICBzdHIvc3BsaXQtbGluZXMpKQoKKGRlZiBleGFtcGxlLWlucHV0LTEKICBbIkNhcmQgMTogNDEgNDggODMgODYgMTcgfCA4MyA4NiAgNiAzMSAxNyAgOSA0OCA1MyIKICAgIkNhcmQgMjogMTMgMzIgMjAgMTYgNjEgfCA2MSAzMCA2OCA4MiAxNyAzMiAyNCAxOSIKICAgIkNhcmQgMzogIDEgMjEgNTMgNTkgNDQgfCA2OSA4MiA2MyA3MiAxNiAyMSAxNCAgMSIKICAgIkNhcmQgNDogNDEgOTIgNzMgODQgNjkgfCA1OSA4NCA3NiA1MSA1OCAgNSA1NCA4MyIKICAgIkNhcmQgNTogODcgODMgMjYgMjggMzIgfCA4OCAzMCA3MCAxMiA5MyAyMiA4MiAzNiIKICAgIkNhcmQgNjogMzEgMTggMTMgNTYgNzIgfCA3NCA3NyAxMCAyMyAzNSA2NyAzNiAxMSJdKQoKKGRlZm4gcGFyc2UtY2FyZCBbbGVuZ3RoIGNhcmRdCiAgKGxldCBbYy1pZCAocGFyc2UtbG9uZyAoc2Vjb25kIChyZS1maW5kICMiXkNhcmQgKyhcZCspOiIgY2FyZCkpKQogICAgICAgIFtfIHdpbm5pbmctcyBtaW5lLXNdIChzdHIvc3BsaXQgY2FyZCAjIjogK3wgK1x8ICsiKQogICAgICAgIFt3aW5uaW5nIG1pbmVdIChtYXAgIyhzZXQgKHN0ci9zcGxpdCAlICMiICsiKSkgW3dpbm5pbmctcyBtaW5lLXNdKQogICAgICAgIG1hdGNoZXMgKGNvdW50IChpbnRlcnNlY3Rpb24gd2lubmluZyBtaW5lKSldCiAgICB7OmNhcmQgYy1pZAogICAgIDpjb3VudCBtYXRjaGVzCiAgICAgOmNvbGxlY3RzIChmaWx0ZXJ2ICMoPj0gbGVuZ3RoICUpIChyYW5nZSAoaW5jIGMtaWQpICgrIChpbmMgYy1pZCkgbWF0Y2hlcykpKX0pKQoKKGNvbW1lbnQKICAocGFyc2UtY2FyZCA0ICJDYXJkIDE6IDQxIDQ4IDgzIDg2IDE3IHwgODMgODYgIDYgMzEgMTcgIDkgNDggNTMiKQogIDo9CiAgezpjYXJkIDEsOmNvdW50IDQsOmNvbGxlY3RzIFsyIDMgNF19CiAgKHBhcnNlLWNhcmQgMSAiQ2FyZCA1OiA4NyA4MyAyNiAyOCAzMiB8IDg4IDMwIDcwIDEyIDkzIDIyIDgyIDM2IikKICA6PQogIHs6Y2FyZCA1LDpjb3VudCAwLDpjb2xsZWN0cyBbXX0KICA6cmNmKQoKKGRlZm4gcGFyc2UtY2FyZHMgW2lucHV0XQogIChtYXAgKHBhcnRpYWwgcGFyc2UtY2FyZCAoY291bnQgaW5wdXQpKSBpbnB1dCkpCgooZGVmbiBiaXQtc2hpZnQtbGVmdCBbeCB5XQogIChqcy9ldmFsIChzdHIgeCAiIDw8ICIgeSkpKQoKKGNvbW1lbnQKICAoYml0LXNoaWZ0LWxlZnQgOCAyKSkKCihkZWZuIHBhcnQtMSBbaW5wdXRdCiAgKC0%2BPiBpbnB1dAogICAgcGFyc2UtY2FyZHMKICAgIChtYXAgOmNvdW50KQogICAgKGtlZXAgIyh3aGVuIChwb3M%2FICUpIChkZWMgJSkpKQogICAgKG1hcCAjKGJpdC1zaGlmdC1sZWZ0IDEgJSkpCiAgICAocmVkdWNlICspKSkKCihjb21tZW50CiAgKHBhcnQtMSBleGFtcGxlLWlucHV0LTEpIDo9IDEzCiAgKGNvbW1lbnQKICAgIChkZWYgbXktaW5wdXQgKHV0aWwvbGluZXMgNCkpCiAgICAodGltZQogICAgICAocGFydC0xIG15LWlucHV0KSkKICAgIDpyY2YpKQoKKGRlZm4gZ2V0LWNvdW50IFtjYXJkLT5jb2xsZWN0cyBjYXJkXQogIChpbmMgKHJlZHVjZSArIDAgKG1hcCAocGFydGlhbCBnZXQtY291bnQgY2FyZC0%2BY29sbGVjdHMpIChnZXQgY2FyZC0%2BY29sbGVjdHMgY2FyZCkpKSkpCgooZGVmbiBjb3VudC1jYXJkcyBbY2FyZC0%2BY29sbGVjdHNdCiAgKHJlZHVjZSArIDAgKG1hcCAocGFydGlhbCBnZXQtY291bnQgY2FyZC0%2BY29sbGVjdHMpIChrZXlzIGNhcmQtPmNvbGxlY3RzKSkpKQoKKGNvbW1lbnQKICAoZGVmIGV4YW1wbGUtaW5wdXQtMiBleGFtcGxlLWlucHV0LTEpCiAgKGRlZiBjb2xsZWN0aW9uICgtPj4gZXhhbXBsZS1pbnB1dC0yCiAgICAgICAgICAgICAgICAgICAgcGFyc2UtY2FyZHMKICAgICAgICAgICAgICAgICAgICAoaW50byB7fSAobWFwIChqdXh0IDpjYXJkIDpjb2xsZWN0cykpKSkpCiAgY29sbGVjdGlvbiA6PSB7MSBbMiAzIDQgNV0sMiBbMyA0XSwzIFs0IDVdLDQgWzVdLDUgW10sNiBbXX0KICAoc3B5IChnZXQtY291bnQgY29sbGVjdGlvbiAxKSkKICAoY291bnQtY2FyZHMgY29sbGVjdGlvbikgOj0gMzAKICAocmVkdWNlICsgMCBbXSkKICA6cmNmKQoKCihkZWZuIHBhcnQtMiBbaW5wdXRdCiAgKC0%2BPiBpbnB1dAogICAgcGFyc2UtY2FyZHMKICAgIChpbnRvIHt9IChtYXAgKGp1eHQgOmNhcmQgOmNvbGxlY3RzKSkpCiAgICBjb3VudC1jYXJkcykpCgooY29tbWVudAogIChwYXJ0LTIgZXhhbXBsZS1pbnB1dC0yKSA6PSAzMAogIChjb21tZW50CiAgICAodGltZQogICAgICAocGFydC0yIG15LWlucHV0KSkKICAgIDpyY2YpKQ%3D%3D. Thanks @borkdude for helping with the slight adaptations needed!

Also for https://squint-cljs.github.io/cherry/?repl=true&boilerplate=https%3A%2F%2Fgist.githubusercontent.com%2Fborkdude%2Fcf94b492d948f7f418aa81ba54f428ff%2Fraw%2Fa6e9992b079e20e21d753e8c75a7353c5908b225%2Faoc_ui.cljs&src=OzsgSGVscGVyIGZ1bmN0aW9uczoKOzsgKGZldGNoLWlucHV0IHllYXIgZGF5KSAtIGdldCBBT0MgaW5wdXQKOzsgKGFwcGVuZCBzdHIpIC0gYXBwZW5kIHN0ciB0byBET00KOzsgKHNweSB4KSAtIGxvZyB4IHRvIGNvbnNvbGUgYW5kIHJldHVybiB4CgooZGVmbiBpbnRlcnNlY3Rpb24gWyYgeHNdCiAgKHJlZHVjZSAoZm4gW2FjYyBzXQogICAgICAgICAgICAoc2V0IChmaWx0ZXIgIyhjb250YWlucz8gYWNjICUpIHMpKSkgeHMpKQoKKGNvbW1lbnQKICAoaW50ZXJzZWN0aW9uIChzZXQgWzEgMiAzXSkgKHNldCBbMSAyXSkpCiAgKQoKOzsgUmVtZW1iZXIgdG8gdXBkYXRlIHRoZSB5ZWFyIGFuZCBkYXkgaW4gdGhlIGZldGNoLWlucHV0IGNhbGwuCihkZWYgbXktaW5wdXQgKC0%2BPiAoanMtYXdhaXQgKGZldGNoLWlucHV0IDIwMjMgNCkpCiAgICAgICAgICAgICAgICAjX3NweQogICAgICAgICAgICAgICAgc3RyL3NwbGl0LWxpbmVzKSkKCihkZWYgZXhhbXBsZS1pbnB1dC0xCiAgWyJDYXJkIDE6IDQxIDQ4IDgzIDg2IDE3IHwgODMgODYgIDYgMzEgMTcgIDkgNDggNTMiCiAgICJDYXJkIDI6IDEzIDMyIDIwIDE2IDYxIHwgNjEgMzAgNjggODIgMTcgMzIgMjQgMTkiCiAgICJDYXJkIDM6ICAxIDIxIDUzIDU5IDQ0IHwgNjkgODIgNjMgNzIgMTYgMjEgMTQgIDEiCiAgICJDYXJkIDQ6IDQxIDkyIDczIDg0IDY5IHwgNTkgODQgNzYgNTEgNTggIDUgNTQgODMiCiAgICJDYXJkIDU6IDg3IDgzIDI2IDI4IDMyIHwgODggMzAgNzAgMTIgOTMgMjIgODIgMzYiCiAgICJDYXJkIDY6IDMxIDE4IDEzIDU2IDcyIHwgNzQgNzcgMTAgMjMgMzUgNjcgMzYgMTEiXSkKCihkZWZuIHBhcnNlLWNhcmQgW2xlbmd0aCBjYXJkXQogIChsZXQgW2MtaWQgKHBhcnNlLWxvbmcgKHNlY29uZCAocmUtZmluZCAjIl5DYXJkICsoXGQrKToiIGNhcmQpKSkKICAgICAgICBbXyB3aW5uaW5nLXMgbWluZS1zXSAoc3RyL3NwbGl0IGNhcmQgIyI6ICt8ICtcfCArIikKICAgICAgICBbd2lubmluZyBtaW5lXSAobWFwICMoc2V0IChzdHIvc3BsaXQgJSAjIiArIikpIFt3aW5uaW5nLXMgbWluZS1zXSkKICAgICAgICBtYXRjaGVzIChjb3VudCAoaW50ZXJzZWN0aW9uIHdpbm5pbmcgbWluZSkpXQogICAgezpjYXJkIGMtaWQKICAgICA6Y291bnQgbWF0Y2hlcwogICAgIDpjb2xsZWN0cyAoZmlsdGVyICMoPj0gbGVuZ3RoICUpIChyYW5nZSAoaW5jIGMtaWQpICgrIChpbmMgYy1pZCkgbWF0Y2hlcykpKX0pKQoKKGNvbW1lbnQKICAocGFyc2UtY2FyZCA0ICJDYXJkIDE6IDQxIDQ4IDgzIDg2IDE3IHwgODMgODYgIDYgMzEgMTcgIDkgNDggNTMiKQogIDo9CiAgezpjYXJkIDEsOmNvdW50IDQsOmNvbGxlY3RzIFsyIDMgNF19CiAgKHBhcnNlLWNhcmQgMSAiQ2FyZCA1OiA4NyA4MyAyNiAyOCAzMiB8IDg4IDMwIDcwIDEyIDkzIDIyIDgyIDM2IikKICA6PQogIHs6Y2FyZCA1LDpjb3VudCAwLDpjb2xsZWN0cyBbXX0KICA6cmNmKQoKKGRlZm4gcGFyc2UtY2FyZHMgW2lucHV0XQogIChtYXAgKHBhcnRpYWwgcGFyc2UtY2FyZCAoY291bnQgaW5wdXQpKSBpbnB1dCkpCgooZGVmbiBwYXJ0LTEgW2lucHV0XQogICgtPj4gaW5wdXQKICAgIHBhcnNlLWNhcmRzCiAgICAobWFwIDpjb3VudCkKICAgIChrZWVwICMod2hlbiAocG9zPyAlKSAoZGVjICUpKSkKICAgIChtYXAgIyhiaXQtc2hpZnQtbGVmdCAxICUpKQogICAgKHJlZHVjZSArKSkpCgooY29tbWVudAogIChwYXJ0LTEgZXhhbXBsZS1pbnB1dC0xKSA6PSAxMwogIChjb21tZW50CiAgICh0aW1lCiAgICAgKHBhcnQtMSBteS1pbnB1dCkpCiAgIDpyY2YpKQoKKGRlZm4gZ2V0LWNvdW50IFtjYXJkLT5jb2xsZWN0cyBjYXJkXQogIChpbmMgKHJlZHVjZSArIChtYXAgKHBhcnRpYWwgZ2V0LWNvdW50IGNhcmQtPmNvbGxlY3RzKSAoY2FyZC0%2BY29sbGVjdHMgY2FyZCkpKSkpCgooZGVmbiBjb3VudC1jYXJkcyBbY2FyZC0%2BY29sbGVjdHNdCiAgKHJlZHVjZSArIChtYXAgKHBhcnRpYWwgZ2V0LWNvdW50IGNhcmQtPmNvbGxlY3RzKSAoa2V5cyBjYXJkLT5jb2xsZWN0cykpKSkKCihjb21tZW50CiAgKGRlZiBleGFtcGxlLWlucHV0LTIgZXhhbXBsZS1pbnB1dC0xKQogIChkZWYgY29sbGVjdGlvbiAoLT4%2BIGV4YW1wbGUtaW5wdXQtMgogICAgICAgICAgICAgICAgICAgIHBhcnNlLWNhcmRzCiAgICAgICAgICAgICAgICAgICAgKGludG8ge30gKG1hcCAoanV4dCA6Y2FyZCA6Y29sbGVjdHMpKSkpKQogIGNvbGxlY3Rpb24gOj0gezEgWzIgMyA0IDVdLDIgWzMgNF0sMyBbNCA1XSw0IFs1XSw1IFtdLDYgW119CiAgKGNvdW50LWNhcmRzIGNvbGxlY3Rpb24pIDo9IDMwCiAgOnJjZikKCgooZGVmbiBwYXJ0LTIgW2lucHV0XQogICgtPj4gaW5wdXQKICAgIHBhcnNlLWNhcmRzCiAgICAoaW50byB7fSAobWFwIChqdXh0IDpjYXJkIDpjb2xsZWN0cykpKQogICAgY291bnQtY2FyZHMpKQoKKGNvbW1lbnQKICAocGFydC0yIGV4YW1wbGUtaW5wdXQtMikgOj0gMzAKICAoY29tbWVudAogICAodGltZQogICAgIChwYXJ0LTIgbXktaW5wdXQpKQogICA6cmNmKSk%3D. Part 2 runs much faster there, @borkdude. 2.5 secs on my machine, vs 8 secs with squint. What gives?

I'll check, probably some cloning going on which can be replaced with in-place mutation 😈

@pez it's not so clear to me. https://squint-cljs.github.io/squint/?repl=true&boilerplate=https%3A%2F%2Fgist.githubusercontent.com%2Fborkdude%2Fcf94b492d948f7f418aa81ba54f428ff%2Fraw%2Fa6e9992b079e20e21d753e8c75a7353c5908b225%2Faoc_ui.cljs&src=OzsgSGVscGVyIGZ1bmN0aW9uczoKOzsgKGZldGNoLWlucHV0IHllYXIgZGF5KSAtIGdldCBBT0MgaW5wdXQKOzsgKGFwcGVuZCBzdHIpIC0gYXBwZW5kIHN0ciB0byBET00KOzsgKHNweSB4KSAtIGxvZyB4IHRvIGNvbnNvbGUgYW5kIHJldHVybiB4CgooZGVmbiBpbnRlcnNlY3Rpb24gWyYgeHNdCiAgKHJlZHVjZSAoZm4gW2FjYyBzXQogICAgICAgICAgICAoc2V0IChmaWx0ZXIgIyhjb250YWlucz8gYWNjICUpIHMpKSkgeHMpKQoKKGNvbW1lbnQKICAoaW50ZXJzZWN0aW9uIChzZXQgWzEgMiAzXSkgKHNldCBbMSAyXSkpCiAgKQoKOzsgUmVtZW1iZXIgdG8gdXBkYXRlIHRoZSB5ZWFyIGFuZCBkYXkgaW4gdGhlIGZldGNoLWlucHV0IGNhbGwuCihkZWYgbXktaW5wdXQgKC0%2BPiAoanMtYXdhaXQgKGZldGNoLWlucHV0IDIwMjMgNCkpCiAgICAgICAgICAgICAgICBzdHIvc3BsaXQtbGluZXMpKQoKKGRlZiBleGFtcGxlLWlucHV0LTEKICBbIkNhcmQgMTogNDEgNDggODMgODYgMTcgfCA4MyA4NiAgNiAzMSAxNyAgOSA0OCA1MyIKICAgIkNhcmQgMjogMTMgMzIgMjAgMTYgNjEgfCA2MSAzMCA2OCA4MiAxNyAzMiAyNCAxOSIKICAgIkNhcmQgMzogIDEgMjEgNTMgNTkgNDQgfCA2OSA4MiA2MyA3MiAxNiAyMSAxNCAgMSIKICAgIkNhcmQgNDogNDEgOTIgNzMgODQgNjkgfCA1OSA4NCA3NiA1MSA1OCAgNSA1NCA4MyIKICAgIkNhcmQgNTogODcgODMgMjYgMjggMzIgfCA4OCAzMCA3MCAxMiA5MyAyMiA4MiAzNiIKICAgIkNhcmQgNjogMzEgMTggMTMgNTYgNzIgfCA3NCA3NyAxMCAyMyAzNSA2NyAzNiAxMSJdKQoKKGRlZm4gcGFyc2UtY2FyZCBbbGVuZ3RoIGNhcmRdCiAgKGxldCBbYy1pZCAocGFyc2UtbG9uZyAoc2Vjb25kIChyZS1maW5kICMiXkNhcmQgKyhcZCspOiIgY2FyZCkpKQogICAgICAgIFtfIHdpbm5pbmctcyBtaW5lLXNdIChzdHIvc3BsaXQgY2FyZCAjIjogK3wgK1x8ICsiKQogICAgICAgIFt3aW5uaW5nIG1pbmVdIChtYXB2ICMoc2V0IChzdHIvc3BsaXQgJSAjIiArIikpIFt3aW5uaW5nLXMgbWluZS1zXSkKICAgICAgICBtYXRjaGVzIChjb3VudCAoaW50ZXJzZWN0aW9uIHdpbm5pbmcgbWluZSkpXQogICAgezpjYXJkIGMtaWQKICAgICA6Y291bnQgbWF0Y2hlcwogICAgIDpjb2xsZWN0cyAoZmlsdGVydiAjKD49IGxlbmd0aCAlKSAocmFuZ2UgKGluYyBjLWlkKSAoKyAoaW5jIGMtaWQpIG1hdGNoZXMpKSl9KSkKCihjb21tZW50CiAgKHBhcnNlLWNhcmQgNCAiQ2FyZCAxOiA0MSA0OCA4MyA4NiAxNyB8IDgzIDg2ICA2IDMxIDE3ICA5IDQ4IDUzIikKICA6PQogIHs6Y2FyZCAxLDpjb3VudCA0LDpjb2xsZWN0cyBbMiAzIDRdfQogIChwYXJzZS1jYXJkIDEgIkNhcmQgNTogODcgODMgMjYgMjggMzIgfCA4OCAzMCA3MCAxMiA5MyAyMiA4MiAzNiIpCiAgOj0KICB7OmNhcmQgNSw6Y291bnQgMCw6Y29sbGVjdHMgW119CiAgOnJjZikKCihkZWZuIHBhcnNlLWNhcmRzIFtpbnB1dF0KICAobWFwdiAocGFydGlhbCBwYXJzZS1jYXJkIChjb3VudCBpbnB1dCkpIGlucHV0KSkKCihkZWZuIGJpdC1zaGlmdC1sZWZ0IFt4IHldCiAgKGpzL2V2YWwgKHN0ciB4ICIgPDwgIiB5KSkpCgooY29tbWVudAogIChiaXQtc2hpZnQtbGVmdCA4IDIpKQoKKGRlZm4gcGFydC0xIFtpbnB1dF0KICAoLT4%2BIGlucHV0CiAgICBwYXJzZS1jYXJkcwogICAgKG1hcHYgOmNvdW50KQogICAgKGtlZXAgIyh3aGVuIChwb3M%2FICUpIChkZWMgJSkpKQogICAgKG1hcHYgIyhiaXQtc2hpZnQtbGVmdCAxICUpKQogICAgKHJlZHVjZSArKSkpCgooY29tbWVudAogIChwYXJ0LTEgZXhhbXBsZS1pbnB1dC0xKSA6PSAxMwogIChjb21tZW50CiAgICAoZGVmIG15LWlucHV0ICh1dGlsL2xpbmVzIDQpKQogICAgKHRpbWUKICAgICAgKHBhcnQtMSBteS1pbnB1dCkpCiAgICA6cmNmKSkKCih3YXJuLW9uLWxhenktcmV1c2FnZSEpCgooZGVmbiBnZXQtY291bnQgW2NhcmQtPmNvbGxlY3RzIGNhcmRdCiAgKGluYwogICAgKHJlZHVjZSArIDAKICAgICAgKG1hcHYKICAgICAgICAocGFydGlhbCBnZXQtY291bnQgY2FyZC0%2BY29sbGVjdHMpCiAgICAgICAgKGdldCBjYXJkLT5jb2xsZWN0cyBjYXJkKSkpKSkKCihkZWZuIGNvdW50LWNhcmRzCiAgW2NhcmQtPmNvbGxlY3RzXQogIChyZWR1Y2UgKyAwCiAgICAobWFwdiAocGFydGlhbCBnZXQtY291bnQgY2FyZC0%2BY29sbGVjdHMpCiAgICAgIChrZXlzIGNhcmQtPmNvbGxlY3RzKSkpKQoKKGNvbW1lbnQKICAoZGVmIGV4YW1wbGUtaW5wdXQtMiBleGFtcGxlLWlucHV0LTEpCiAgKGRlZiBjb2xsZWN0aW9uICgtPj4gZXhhbXBsZS1pbnB1dC0yCiAgICAgICAgICAgICAgICAgICAgcGFyc2UtY2FyZHMKICAgICAgICAgICAgICAgICAgICAoaW50byB7fSAobWFwIChqdXh0IDpjYXJkIDpjb2xsZWN0cykpKSkpCiAgY29sbGVjdGlvbiA6PSB7MSBbMiAzIDQgNV0sMiBbMyA0XSwzIFs0IDVdLDQgWzVdLDUgW10sNiBbXX0KICAoc3B5IChnZXQtY291bnQgY29sbGVjdGlvbiAxKSkKICAoY291bnQtY2FyZHMgY29sbGVjdGlvbikgOj0gMzAKICAocmVkdWNlICsgMCBbXSkKICA6cmNmKQoKCihkZWZuIHBhcnQtMiBbaW5wdXRdCiAgKC0%2BPiBpbnB1dAogICAgcGFyc2UtY2FyZHMKICAgIChtYXB2IChqdXh0IDpjYXJkIDpjb2xsZWN0cykpCiAgICAoaW50byB7fSkKICAgIGNvdW50LWNhcmRzKSkKCihjb21tZW50CiAgKHBhcnQtMiBleGFtcGxlLWlucHV0LTIpIDo9IDMwCiAgKGNvbW1lbnQKICAgICh0aW1lCiAgICAgIChwYXJ0LTIgbXktaW5wdXQpKQogICAgOnJjZikp and it runs in 11s whereas in cherry it takes 4.5s, so roughly a 2x difference. it would be interesting to see where this comes from, e.g. lookups in native JS maps vs clojure maps or so, not sure. I could take a closer look in a profiler when I'm at my bigger screen

In order to understand @mail191’s solution I had to make mine use the same idea and inspect the reductions. I’m not sure I fully understand yet, but at least I understand more. I recognize the reductions from my recursive solution. That one ran in 1 sec. This one runs in 2ms. (10ms with https://squint-cljs.github.io/cherry/?repl=true&boilerplate=https%3A%2F%2Fgist.githubusercontent.com%2Fborkdude%2Fcf94b492d948f7f418aa81ba54f428ff%2Fraw%2Fa6e9992b079e20e21d753e8c75a7353c5908b225%2Faoc_ui.cljs&src=OzsgSGVscGVyIGZ1bmN0aW9uczoKOzsgKGZldGNoLWlucHV0IHllYXIgZGF5KSAtIGdldCBBT0MgaW5wdXQKOzsgKGFwcGVuZCBzdHIpIC0gYXBwZW5kIHN0ciB0byBET00KOzsgKHNweSB4KSAtIGxvZyB4IHRvIGNvbnNvbGUgYW5kIHJldHVybiB4CgooZGVmbiBpbnRlcnNlY3Rpb24gWyYgeHNdCiAgKHJlZHVjZSAoZm4gW2FjYyBzXQogICAgICAgICAgICAoc2V0IChmaWx0ZXIgIyhjb250YWlucz8gYWNjICUpIHMpKSkgeHMpKQoKKGNvbW1lbnQKICAoaW50ZXJzZWN0aW9uIChzZXQgWzEgMiAzXSkgKHNldCBbMSAyXSkpCiAgKQoKOzsgUmVtZW1iZXIgdG8gdXBkYXRlIHRoZSB5ZWFyIGFuZCBkYXkgaW4gdGhlIGZldGNoLWlucHV0IGNhbGwuCihkZWYgbXktaW5wdXQgKC0%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%2BPiBleGFtcGxlLWlucHV0LTIKICAgICAgICAgICAgICAgICAgcGFyc2UtY2FyZHMKICAgICAgICAgICAgICAgICAgKG1hcCA6Y291bnQpCiAgICAgICAgICAgICAgICAgIHJldmVyc2UpKQogY291bnRzIDo9ICcoMCAwIDEgMiAyIDQpCiAocmVkdWNlIGdldC1jb3VudHMgKCkgY291bnRzKSA6PSAnKDE1IDcgNCAyIDEgMSkKIChyZWR1Y3Rpb25zIGdldC1jb3VudHMgKCkgY291bnRzKSA6PSAnKCgpICgxKSAoMSAxKSAoMiAxIDEpICg0IDIgMSAxKSAoNyA0IDIgMSAxKSAoMTUgNyA0IDIgMSAxKSkKIDpyY2YpCgooZGVmbiBjb3VudC1jYXJkcyBbY291bnRzXQogIChyZWR1Y2UgKyAocmVkdWNlIGdldC1jb3VudHMgKCkgY291bnRzKSkpCgooY29tbWVudAogKGNvdW50LWNhcmRzIGNvdW50cykgOj0gMzAKIDpyY2YpCgoKKGRlZm4gcGFydC0yIFtpbnB1dF0KICAoLT4%2BIGlucHV0CiAgICAgICBwYXJzZS1jYXJkcwogICAgICAgKG1hcCA6Y291bnQpCiAgICAgICByZXZlcnNlCiAgICAgICBjb3VudC1jYXJkcykpCgooY29tbWVudAogKHBhcnQtMiBleGFtcGxlLWlucHV0LTIpIDo9IDMwCiAoY29tbWVudAogICAodGltZQogICAgKHBhcnQtMiBteS1pbnB1dCkpCiAgIDpyY2YpKQ%3D%3D).

And this one is about twice as fast https://squint-cljs.github.io/squint/?repl=true&boilerplate=https%3A%2F%2Fgist.githubusercontent.com%2Fborkdude%2Fcf94b492d948f7f418aa81ba54f428ff%2Fraw%2Fa6e9992b079e20e21d753e8c75a7353c5908b225%2Faoc_ui.cljs&src=OzsgSGVscGVyIGZ1bmN0aW9uczoKOzsgKGZldGNoLWlucHV0IHllYXIgZGF5KSAtIGdldCBBT0MgaW5wdXQKOzsgKGFwcGVuZCBzdHIpIC0gYXBwZW5kIHN0ciB0byBET00KOzsgKHNweSB4KSAtIGxvZyB4IHRvIGNvbnNvbGUgYW5kIHJldHVybiB4CgooZGVmbiBpbnRlcnNlY3Rpb24gWyYgeHNdCiAgKHJlZHVjZSAoZm4gW2FjYyBzXQogICAgICAgICAgICAoc2V0IChmaWx0ZXIgIyhjb250YWlucz8gYWNjICUpIHMpKSkgeHMpKQoKKGNvbW1lbnQKICAoaW50ZXJzZWN0aW9uIChzZXQgWzEgMiAzXSkgKHNldCBbMSAyXSkpCiAgKQoKOzsgUmVtZW1iZXIgdG8gdXBkYXRlIHRoZSB5ZWFyIGFuZCBkYXkgaW4gdGhlIGZldGNoLWlucHV0IGNhbGwuCihkZWYgbXktaW5wdXQgKC0%2BPiAoanMtYXdhaXQgKGZldGNoLWlucHV0IDIwMjMgNCkpCiAgICAgICAgICAgICBzdHIvc3BsaXQtbGluZXMpKQoKKGRlZiBleGFtcGxlLWlucHV0LTEKICBbIkNhcmQgMTogNDEgNDggODMgODYgMTcgfCA4MyA4NiAgNiAzMSAxNyAgOSA0OCA1MyIKICAgIkNhcmQgMjogMTMgMzIgMjAgMTYgNjEgfCA2MSAzMCA2OCA4MiAxNyAzMiAyNCAxOSIKICAgIkNhcmQgMzogIDEgMjEgNTMgNTkgNDQgfCA2OSA4MiA2MyA3MiAxNiAyMSAxNCAgMSIKICAgIkNhcmQgNDogNDEgOTIgNzMgODQgNjkgfCA1OSA4NCA3NiA1MSA1OCAgNSA1NCA4MyIKICAgIkNhcmQgNTogODcgODMgMjYgMjggMzIgfCA4OCAzMCA3MCAxMiA5MyAyMiA4MiAzNiIKICAgIkNhcmQgNjogMzEgMTggMTMgNTYgNzIgfCA3NCA3NyAxMCAyMyAzNSA2NyAzNiAxMSJdKQoKKGRlZm4gcGFyc2UtY2FyZCBbbGVuZ3RoIGNhcmRdCiAgKGxldCBbYy1pZCAocGFyc2UtbG9uZyAoc2Vjb25kIChyZS1maW5kICMiXkNhcmQgKyhcZCspOiIgY2FyZCkpKQogICAgICAgIFtfIHdpbm5pbmctcyBtaW5lLXNdIChzdHIvc3BsaXQgY2FyZCAjIjogK3wgK1x8ICsiKQogICAgICAgIFt3aW5uaW5nIG1pbmVdIChtYXAgIyhzZXQgKHN0ci9zcGxpdCAlICMiICsiKSkgW3dpbm5pbmctcyBtaW5lLXNdKQogICAgICAgIG1hdGNoZXMgKGNvdW50IChpbnRlcnNlY3Rpb24gd2lubmluZyBtaW5lKSldCiAgICB7OmNhcmQgYy1pZAogICAgIDpjb3VudCBtYXRjaGVzCiAgICAgOmNvbGxlY3RzIChmaWx0ZXJ2ICMoPj0gbGVuZ3RoICUpIChyYW5nZSAoaW5jIGMtaWQpICgrIChpbmMgYy1pZCkgbWF0Y2hlcykpKX0pKQoKKGNvbW1lbnQKICAocGFyc2UtY2FyZCA0ICJDYXJkIDE6IDQxIDQ4IDgzIDg2IDE3IHwgODMgODYgIDYgMzEgMTcgIDkgNDggNTMiKQogIDo9CiAgezpjYXJkIDEsOmNvdW50IDQsOmNvbGxlY3RzIFsyIDMgNF19CiAgKHBhcnNlLWNhcmQgMSAiQ2FyZCA1OiA4NyA4MyAyNiAyOCAzMiB8IDg4IDMwIDcwIDEyIDkzIDIyIDgyIDM2IikKICA6PQogIHs6Y2FyZCA1LDpjb3VudCAwLDpjb2xsZWN0cyBbXX0KICA6cmNmKQoKKGRlZm4gcGFyc2UtY2FyZHMgW2lucHV0XQogIChtYXAgKHBhcnRpYWwgcGFyc2UtY2FyZCAoY291bnQgaW5wdXQpKSBpbnB1dCkpCgooZGVmbiBiaXQtc2hpZnQtbGVmdCBbeCB5XQogIChqcy9ldmFsIChzdHIgeCAiIDw8ICIgeSkpKQoKKGNvbW1lbnQKICAoYml0LXNoaWZ0LWxlZnQgOCAyKSkKCihkZWZuIHBhcnQtMSBbaW5wdXRdCiAgKC0%2BPiBpbnB1dAogICAgcGFyc2UtY2FyZHMKICAgIChtYXAgOmNvdW50KQogICAgKGtlZXAgIyh3aGVuIChwb3M%2FICUpIChkZWMgJSkpKQogICAgKG1hcCAjKGJpdC1zaGlmdC1sZWZ0IDEgJSkpCiAgICAocmVkdWNlICspKSkKCihjb21tZW50CiAgKHBhcnQtMSBleGFtcGxlLWlucHV0LTEpIDo9IDEzCiAgKGNvbW1lbnQKICAgIChkZWYgbXktaW5wdXQgKHV0aWwvbGluZXMgNCkpCiAgICAodGltZQogICAgICAocGFydC0xIG15LWlucHV0KSkKICAgIDpyY2YpKQoKKGRlZm4gZ2V0LWNvdW50cwogIChbY291bnRzXSAocmVkdWNlICsgY291bnRzKSkKICAoW2NvdW50cyBjb3VudF0KICAgKGNvbmogY291bnRzIChyZWR1Y2UgKyAxICh0YWtlIGNvdW50IGNvdW50cykpKSkpCgooY29tbWVudAogKGRlZiBleGFtcGxlLWlucHV0LTIgZXhhbXBsZS1pbnB1dC0xKQogKGRlZiBjb3VudHMgKC0%2BPiBleGFtcGxlLWlucHV0LTIKICAgICAgICAgICAgICAgICAgcGFyc2UtY2FyZHMKICAgICAgICAgICAgICAgICAgKG1hcCA6Y291bnQpCiAgICAgICAgICAgICAgICAgIHJldmVyc2UpKQogY291bnRzIDo9ICcoMCAwIDEgMiAyIDQpCiAocmVkdWNlIGdldC1jb3VudHMgKCkgY291bnRzKSA6PSAnKDE1IDcgNCAyIDEgMSkKIDpyY2YpCgooZGVmbiBjb3VudC1jYXJkcyBbY291bnRzXQogIChyZWR1Y2UgKyAocmVkdWNlIGdldC1jb3VudHMgKCkgY291bnRzKSkpCgooY29tbWVudAogKGNvdW50LWNhcmRzIGNvdW50cykgOj0gMzAKIDpyY2YpCgoKKGRlZm4gcGFydC0yIFtpbnB1dF0KICAoLT4%2BIGlucHV0CiAgICAgICBwYXJzZS1jYXJkcwogICAgICAgKG1hcCA6Y291bnQpCiAgICAgICByZXZlcnNlCiAgICAgICBjb3VudC1jYXJkcykpCgooY29tbWVudAogKHBhcnQtMiBleGFtcGxlLWlucHV0LTIpIDo9IDMwCiAoY29tbWVudAogICAodGltZQogICAgKHBhcnQtMiBteS1pbnB1dCkpCiAgIDpyY2YpKQ%3D%3D as in cherry, @borkdude 😃

How I understood Sam's technique is this: 1. record how many cards the last card gives us (1 (itself) + 0 as there are no following cards) 2. record how many cards the second to last card gives us (1 (itself) + the number of cards given by as many following cards as the current one won) 3. repeat 2 for the rest of the cards 4. add them all up it's brilliant!

@pez ^

Look at homoiconicity magic 😊

(->> (str/split input #"\n")
       (keep (fn [s]
               (let [[_ s] (str/split s #"\:" 2)]
                 (->> (str "(-> (set/intersection #{" (str/replace s #"\|" "} #{") "})
                                count
                                (->> (Math/pow 2))
                                int
                                (quot 2))")
                      read-string
                      eval))))
       (apply +))

read-string + eval can be written as load-string

Thanks! More homoiconicity, but works only on demo data, on real input throws too large code length 🙂

(defn foo [a b] (-> (set/intersection a b)
                      count
                      (->> (Math/pow 2))
                      int
                      (quot 2)))

  (let [code (-> input
                 (str "\n")
                 (str/replace #"\|" "} #{")
                 (str/replace #"\n" "})\n")
                 (str/replace #"Card\s+\d+\:" "(foo #{\n"))
        code (str "(+ " code ")")]
    (-> code read-string eval))

I wonder if SCI can handle it ;)

Could you do it with a macro, @andrey.yallowsack.com?

Not sure, cause code literals will be the same length

@andrey.yallowsack.com This works for me in bb:

(ns daywhatever
  (:require [clojure.set :as set]
            [clojure.string :as str]))

(def input (str/trim (slurp (str ""
                                 (System/getenv "AOC_TOKEN")
                                 "&year=2023&day=4"))))


(defn foo [a b] (-> (set/intersection a b)
                    count
                    (->> (Math/pow 2))
                    int
                    (quot 2)))

(prn (let [code (-> input
                    (str "\n")
                    (str/replace #"\|" "} #{")
                    (str/replace #"\n" "})\n")
                    (str/replace #"Card\s+\d+\:" "(foo #{\n"))
           code (str "(+ " code ")")]
       (-> code read-string eval)))

where I've set AOC_TOKEN to the token

takes 10ms to complete

Thanks, I'l try & play with it 🙂

in clojure I indeed get:

Syntax error (IndexOutOfBoundsException) compiling fn* at (/tmp/daywhatever.clj:16:1).
Method code too large!

The same as I got in REPL. Thanks again, I'l try your approach on future tasks!

I managed to get it to work in planck (self-hosted CLJS), just use edn/read-string there + eval:

"Elapsed time: 177.860958 msecs"

now I'll try nbb

in nbb:

"Elapsed time: 52.348458 msecs"

Short but slow recursion 🙂 https://gist.github.com/coadan/cf0fdc0d3c9709dc68ebc8751af496f8

Brute forced part 2. Which math is it that I am missing? 14 card 5 for the example data.. I don’t see it!

I went with a forward-accumulator in part2. Still happy that it all fit into a single transduction! https://github.com/imrekoszo/advent-of-clj/blob/master/src/imrekoszo/advent/y23/day4.clj

Really similar with other results here 🙂 https://gitlab.com/mauricioszabo/advent-of-code-2023-clj/blob/master/src/advent_2023_clj/day04.clj

https://elken.github.io/aoc/src/solutions/2023/day04/ this was a massive whiplash to yesterday

Went with bitsets first, then figured out it's unnecessary here https://gist.github.com/alexander-yakushev/51fd7c47d9b6e18de64ec5a324f9f35c

I also ended up with a nested reduce, but I am quite happy with the readability of my solution. I am still in shock about day 3, though. I only was able to finish that this mornign https://github.com/JDurstberger/aoc-2023-clj/tree/main/src/day_4

My solution: https://github.com/genmeblog/advent-of-code/blob/master/src/advent_of_code_2023/day04.clj

Wow @mail191! It's impressive, I need to digest it.

Yeah, my brain does not compute that solution 🤯

I see! reverse is the key!

and mine: https://github.com/Ramblurr/advent-of-code/blob/main/src/aoc/2023/day04.clj nothing particularly special i think

part1 only https://github.com/mkrcah/advent-of-code/blob/main/src/day_04.clj skipping part2 and instead going to invest time to try to understand transducers and @mail191 today's approach Update: added part 1, now with transducers https://github.com/mkrcah/advent-of-code/blob/main/src/day_04_xf.clj

@mail191 got exactly the same strategy for parsing data, but was not so sofisticated with transducing as you for the solutions; however, when I run your solution with babashka, I get long overflow error...

My solution : https://github.com/arnaudgeiser/advent-of-code/blob/master/2023/clojure/src/advent_of_code/day4.clj Impressive @mail191

🤔 not sure @piotr.kaznowski, maybe differences in input data? i'm running it locally with babashka as well

@mail191 sorry, edit -- I missed the reverse in parsing! Sorry for confusion, pretty impressed with your solution!

https://github.com/FelipeCortez/advent-of-code/blob/master/2023/04.clj

that Rubik's cube is giving me flashbacks to last year, day 22

@felipecortezfi I had to make a debugger for that task to find out why my answer was constantly wrong

I did too, but could not get it right even with that!

@mail191’s solution https://squint-cljs.github.io/squint/?boilerplate=https%3A%2F%2Fgist.githubusercontent.com%2Fborkdude%2Fcf94b492d948f7f418aa81ba54f428ff%2Fraw%2F3e871513ab6f2462841f75fc99668f841f33dabb%2Faoc_ui.cljs&repl=true&src=OzsgSGVscGVyIGZ1bmN0aW9uczoKOzsgKGZldGNoLWlucHV0IHllYXIgZGF5KSAtIGdldCBBT0MgaW5wdXQKOzsgKGFwcGVuZCBzdHIpIC0gYXBwZW5kIHN0ciB0byBET00KOzsgKHNweSB4KSAtIGxvZyB4IHRvIGNvbnNvbGUgYW5kIHJldHVybiB4CgooZGVmbiBwb2ludHMgW3hdCiAgKGludCAoTWF0aC9wb3cgMiAoZGVjIHgpKSkpCgooZGVmbiB0b3RhbHMtcmYKICAoW3hzXSAocmVkdWNlICsgeHMpKQogIChbeHMgeF0gKGNvbmogeHMgKHJlZHVjZSArIDEgKHRha2UgeCB4cykpKSkpCgooZGVmbiBpbnRlcnNlY3Rpb24gWyYgeHNdCiAgKHJlZHVjZSAoZm4gW2FjYyBzXQogICAgICAgICAgICAoc2V0IChmaWx0ZXIgIyguaGFzIGFjYyAlKSBzKSkpIHhzKSkKCihjb21tZW50CiAgKGludGVyc2VjdGlvbiAjezEgMiAzfSAjezIgMyA0IDUgNn0pCiAgKHRyYW5zZHVjZSAoY29tcCAobWFwIGluYykgKG1hcCBkZWMpKSArIFsxIDIgM10pKQoKKGRlZiBpbiAocmV2ZXJzZSAoc3RyL3NwbGl0LWxpbmVzIChqcy1hd2FpdCAoZmV0Y2gtaW5wdXQgMjAyMyA0KSkpKSkKCihsZXQgW3hmIChjb21wCiAgICAgICAgICAgKG1hcCAocGFydGlhbCByZS1zZXEgIyJcZCsiKSkKICAgICAgICAgICAobWFwIHJlc3QpCiAgICAgICAgICAgKG1hcCAocGFydGlhbCBtYXB2IHBhcnNlLWxvbmcpKQogICAgICAgICAgIChtYXAgKHBhcnRpYWwgc3BsaXQtYXQgMTApKQogICAgICAgICAgIChtYXAgKHBhcnRpYWwgbWFwdiBzZXQpKQogICAgICAgICAgIChtYXAgKHBhcnRpYWwgYXBwbHkgaW50ZXJzZWN0aW9uKSkKICAgICAgICAgICAobWFwIGNvdW50KSldCiAgOzsgZGVidWc6CiAgOzsgKGpzL2NvbnNvbGUubG9nIChpbnRvIFtdIHhmIGluKSkKICAoYXBwZW5kIChzdHIgIlBhcnQgQToiICh0cmFuc2R1Y2UgKGNvbXAgeGYgKG1hcCBwb2ludHMpKSArIGluKSkpCiAgKGFwcGVuZCAoc3RyICJQYXJ0IEI6IiAodHJhbnNkdWNlIHhmIHRvdGFscy1yZiAoKSBpbikpKSk%3D

classic AoC state machine problem 😄 https://github.com/potetm/advent-of-code/blob/master/src/advent_2023/day_4.clj

I'm relieved to see day 4's input is nicer than day 3

here's my solution: https://github.com/rmrt1n/advent-of-code-2023-clj/blob/main/src/aoc/day04.clj

I have managed to get Part 1 done pretty easily - this is much more my speed. Have run out of lunchtime and must get back to my actual job, but will be addressing part 2 later on,.. It's nice to be having fun with AoC again...

https://github.com/wevre/advent-of-code/blob/master/src/advent_of_code/2023/day_04.clj

@tsulej, I agree that reverse is the a key, but also important is conj-ing onto a list () (in reference to Sam’s solution).

?? why need reverse?

@michaeljweaver yes, it's a consequence of backward processing. It makes things easier than going forward.

I had a hunch there was some solution like that and I started writing stuff down and trying to figure it out but then my brain hurt and I just went with forward approach. Impressive, @mail191.

Here is how it goes when reverse processing is used (marked elements are added + 1):

;; => [4 2 2 1 0 0]
;; 0 - '()
;; 0 - '(1)
;; 1 - '(1 1)
         ^
;; 2 - '(2 1 1)
         ^ ^
;; 2 - '(4 2 1 1)
         ^ ^ 
;; 4 - '(7 4 2 1 1)
         ^ ^ ^ ^
;; => (15 7 4 2 1 1 )
;; => 30

;; => [1 1 1 1 1 1]
;; 4 - [1 2 2 2 2 1]
;; 2 - [1 2 4 4 2 1]
;; 2 - [1 2 4 8 6 1]
;; 1 - [1 2 4 8 14 1]
;; 0 - [1 2 4 8 14 1]
;; 0 - [1 2 4 8 14 1]
;; => 30

And this way you don’t have to keep track of the card id.

Exactly

This explains a lot and still hurts my brain. I need to look at that again tomorrow morning when I am well rested 😅

Still, it's not like I could find such solution myself 😄

pt 2 looks like a dp problem

dp? I know what that means in other contexts but not software engineering...

dynamic programming. I'm not good at explaining it so here's https://stackoverflow.com/a/29149754 from stack overflow

I made a https://github.com/wevre/advent-of-code/blob/master/src/advent_of_code/2023/day_04_v2.clj trying out Sam’s reverse processing. Timewise it seems to be the same, maybe slightly faster. With transduce, if you don’t need the transducer xform , do you just use identity? Or is there a function other than transduce to use in that case?

Thx @hi897

not exactly elegant but did the job

i originally did a forward-processing approach using vector adds to avoid the double reduce. but i couldn’t unsee the reverse approach with transducers, so once I understood @mail191’s had to do the same. one original bit i like is counting winners by using a forward looking regex to find winners that exist later in the line. #"(?<=:.*)(?=\b(\d+)\b.*\|.*\b\1\b)", then count matches, no need for sets of integers. https://github.com/tschady/advent-of-code/blob/main/src/aoc/2023/d04.clj

Haha, it's a real code golf.

I saw a post on reddit that did something similar, @tws. That’s a clever use of regex.

dp is a scam

Took me too long to figure it out

It's just caching.

> one original bit i like is counting winners by using a forward looking regex to find winners that exist later in the line this is awesome! i learn so much regex from other people during aoc

simple reduce: https://github.com/CarnunMP/Advent-of-Code/blob/master/src/y2023/d4.clj

lol @tws, you legend

I just finished. started late. Part two is a bit slow, but it works. lol

(ns advent-of-code.day-four
  (:require [clojure.math :as math]
            [clojure.string :as string]
            [clojure.set :as cset]))

(defn card->winners
  [line]
  (as-> (string/split line #":") s
    (last s)
    (string/split s #"\|")
    (map #(set (filter not-empty (string/split % #" "))) s)
    (apply cset/intersection s)
    (count s)))

(defn part-one
  []
  (apply +
         (map (fn [line]
                (let [winners (card->winners line)]
                  (if (pos? winners)
                    (int (math/pow 2 (dec winners)))
                    0)))
              (line-seq ( "./input/day4.txt")))))

(defn card->number
  [card]
  (-> card
      (string/split #":")
      (first)
      (string/split #" ")
      (last)
      (parse-long)))

(defn helper
  [cards processing]
  (mapv (fn [line]
          (let [winners (card->winners line)
                card-num (card->number line)]
            (if (pos? winners)
              (into [line]
                    (helper cards
                            (subvec cards
                                    card-num
                                    (+ card-num winners))))
              line)))
        processing))

(defn count-scratchcards
  [cards processing]
  (count (flatten (helper cards processing))))

(defn part-two
  []
  (count-scratchcards
   (vec (line-seq ( "./input/day4.txt")))
   (vec (line-seq ( "./input/day4.txt")))))

https://github.com/maxrothman/advent-of-code/blob/main/2023/clj2023/src/clj2023/day4.clj. I like to use iterate for this sort of thing because it makes it easier to debug the intermediate steps. If performance ends up being an issue you can always convert it to reduce or a recursive fn later.

@max.r.rothman FYI, you can use reductions to get intermediate steps of a reduce. The upside is that you don't have to manually iterate items of a collection.

Yeah I know, for this one though I wanted to iterate 2 collections in parallel while retaining access to the remaining items in one of the collections. I’m sure I could’ve fit that into reduce but anytime I need to iterate a collection and access the remaining items I go straight for recursion and destructuring. Probably because I learned FP in Haskell 😂

Basically recursion/iterate are more flexible when you’re not sure you understand the problem, so I often find it easier to start there

@tws Once again, your solutions are just incredible. 🫡 sir.

Thanks! but this one is pure stolen valor from @mail191’s eye-opener.

https://gitlab.com/maximoburrito/advent2023/-/blob/main/src/day04/main.clj

kind of a nasty nested reduce, but it worked! https://github.com/russmatney/advent-of-code/blob/master/src/_2023/_04/core.clj

https://gist.github.com/samcf/ecc76b013cf03c8d3797f5936bce0ae1 Uhh this is a pretty bad solution even if it looks terse... there is surely a more efficient recursion strategy here Much improved version https://github.com/samcf/advent-of-code/blob/main/2023-04-scratchcards.clj