Episode 12 is AI. Connor r u serious???

As a lambda lover, I fricking love this!

Can you make more videos like this? really enjoyed it!

Every language wants to be a Lisp and every Lisp wants to be a Common Lisp... truth hurts ;) CL-USER> (defparameter *data* '((1 2 3) (5 5 5) (3 1 4))) CL-USER> (loop for x in (mapcar #'(lambda (line) (reduce #'+ line :initial-value 0)) *data*) maximizing x) 15 Or if you like to read the flow of data left to right, with a little help of my usual utilities: CL-USER> (pipeline (x *data*) (mapcar #'(lambda (line) (reduce #'+ line :initial-value 0)) x) (reduce #'max x :initial-value 0)) 15 Or if you like loops because all that reduce and map stuff is so unsimple... CL-USER> (loop for line in *data* maximizing (loop for x in line summing x)) 15

```Elixir Enum.min_max([20,30,22,25]) |> then(fn {min, max} -> Integer.gcd(min, max) end) ``` Skips going over twice for the min and then for the max

I'd submit this Elixir solution ```Elixir [[1,2,3],[5,5,5],[5,6,7]] |> Enum.max_by(&Enum.sum/1) |> Enum.sum() ``` or ```Elixir [[1,2,3],[5,5,5],[5,6,7]] |> Enum.map(&Enum.sum/1) |> Enum.max ``` It is funny how max_by is almost what is needed but not exactly..

Since the C++ code is the only definition of "calculate", it is not a bug. Consequently, the unguarded range in Rust while elegant is wrong.

I guess what people initially start to do is compress songs which are the biggest and see if the size goes under the drive capacity. But if you do this based on the size of the biggest to smallest song then you *may* have to compress more songs than necessary. This is because it is possible for example that only two songs which provided "maximum amount of compression" was needed. But if you do it based on each song size, biggest to smallest song, you"may" end up with a higher count. So focus on compressing songs based on which ones provide the "maximum compression", which is basically what a-b represents, so as to minimize the number of songs that you need to compress.

If one prefers compact syntax, one could produce the same functionality in cpp with -v+1 where v is an array, and across all your projects data structures with operator overloading in the base class, syntax really has nothing to do with the ideas of category theory

I had this silly feeling it can't be necessary to write the scan twice. |(»+`){𝔽-𝔽⌾⌽} This was the first time I wanted a ⟜ variant of ⌾. Prior variants: {|-⟜⌽˝(»+`)˘≍⟜⌽𝕩} # both directions in one 2d array {|-⟜⌽○(»+`)⟜⌽˜𝕩} # ○ to scan both sides, but missing ⌾ And then there's the awfully assymetric reduce and scan variant: |(+´⊸--(»2×+`))

*hits the head on keyboard while holding AltGr* “Extremely beautiful!”

Wow this is some horribly written code

TIL about that Counter and other stuff; that’s nice to know.

His setup and organization is so cool. Love the implementation and love the LSP update!

`calculate = sum . filter even .* enumFromTo`

Honestly a bit disappointed. It might still be BQN, but I was hoping for an array style solution as I was struggling with my own APL solution to part 2. (Then I realised that I literally just had to change an or to a plus so that's good now)

Love your video. Great stuff😊

That 'bug' in C code seemed more like a design choice to me. But anyway, the real and much more sinister bug in the C version lies in the '<='! Think about what happens when top==INT_MAX.

what I wanted to say yesterday is I think you can remove the whole ×≠next? part and always do each on next since when it's empty it stays empty, might be wrong though

what happened to day 8 and 9..?

I want to give BQN a try one day because i can't imagine myself ever being able to write code like this.

Love your videos. I'm doing Advent of Code in Python and Javascript and I understand everything you are saying but none of your code. It's like I'm trying to read an Alien Language.

Thanks to @rubenverg and Rampoina for helped clean up my solution! 🙏 Meant to mention at the top of the video but forgot

I had a bit of fun looking at the structure of the data. The book pages are basically nodes and the order rules are directed edges. So I wanted to pick a line of data, then restrict the rules down to just those nodes, and then look at the graph. I think it's interesting. See here at 4:20 and 6:20 (not BQN related). kzbin.info/www/bejne/qpyrkKN5Yr96fbM

Really? Really?? "That's a rotate"? Is there no getting away from this? 😀

id love to stick my solutions in my own lang in the comments but youtube constantly eats them

1:45 actually -90 deg turn

Rewatching some old videos, I think this is a pretty nice point-free solution in bqn. ×´⊸÷ It's also 4 characters, but instead of an identity it uses bqn's "before". This is a more bqn-way to do it, and it even allows it to be placed in an expression without parentheses: ×´⊸÷ n However, the apl-style solution with identity still works in bqn, but the parentheses are needed: (×´÷⊢) n

I was really surprirsed when I saw people doing pure brute force like this and it actually ran in reasonable time

'beautiful' superquadratic solutions... it could be O(n)...

Can someone explain the delta trick to compute the new direction ? I did not get it.😊

Well, BQN looks... interesting... ;-)

thats cheating

For part 2, instead of testing with every non wall position, I test with only every position from the path I get from part 1, because if the additional wall is not on the original path, the guard won't hit the wall and change path anyway (I didn't use BQN but I did with Rust iterator)

I didn't quite understand your counter approach to check if the guard's path is in a loop... I figured that the obstacle only makes any difference if it's placed in the guard's path, so for each position in the guard's path I put a obstacle and recalculate the new route. My solution to check if an array of positions is in a loop I separated the last two positions and compared if it appeared in the tail of the list. It was a nightmare in JavaScript, but after some tries (3-5 min each) I managed to solve it

Every day I think, surely today's problem can't be solved in BQN, every day I am proven wrong

I feel like you could use table (⌜) to simplify this last expression, no ? +´⥊∾(⌽∘⍉⍟(↕4)m)Xm⌜ 3‿3↕𝕩

I really enjoy your content in general but you literally converted me into array programing 😂. I’ll get started on this next year for sure. Can someone point me to the minute where it is checked that we have at most three digits ?

How long do you take on average to solve a AoC problem in bqn?

well if you say that 3.33 is more readable than the for loop I don't need to see further

Been using this AoC as an opportunity to learn BQN. Didn't know about that pattern where all ordered pairs make an upper triangle. I spent 2 hours on implementing selection sort making things way more complicated xD Min ← (⊑∘(((∊⟜rules)˜⋈)◶⟨⌽,⊢⟩∘⋈)) sorted ← (⌽∾)∘(((((∊⟜(⋈Min´)˜)⊸⊔)∘⊑)∾(1⊸↓))⍟(≠∾))∘⋈¨updates sol ← (+´⊑∘((⌊(÷⟜2)∘≠)⊏⊢)¨)¨updates((≢¨)⊔⊢)sorted

oh, I should clarify I stole the grade down table self thing from bqncrate, so it's presumably by Marshall! not my idea(:

these two are equivalent: 0⌈ 1⌊ ¯2‿¯1‿0‿1‿2 0< ¯2‿¯1‿0‿1‿2

Super cool 😁 fun to see how differently this can be approached. I was also inspired by dzaima's solution, I have a video of mine on my channel if that's interesting

What is the point of constanly having to compare rust to other languages? Can't it stand on its own legs and be a tool in the tool box as the other languages for us to pick up when we need exactly that ONE feature that attrackts you the most? Does it have to be just one swiss-army language in the tool-box? If so I prefer plain old ANSI-C (and java for OOP).

Seriously, this is great ?

Alternative (simpler?) solution to checking the X pattern in part 2: extract the diagonals into a 2x3 matrix, laminate it with its reverse, then check if exactly 2 rows are equal to 'MAS'.

As regards the safe function one can avoid doing the two checks 1≤x≤3 doing |x-2|≤1, in APL: (∧/(1≥∘|2-|)∧(1=≢∘∪∘×))(2-/⊢)

Where can I find more about that diagonals function, while not bqn I tried solving it declaratively but the diagonals broke me.

I am just in my voyage of using APL where all of this was supper valuable. I had watched it before when the value went way over my head.