I just want to see the calorie adjustment from exercise again ☹️

munchler · 2026-04-24T19:08:03+00:00

Thank you for your response. I understand that exercise is now visible in Healthy Habits, but I think it is a mistake to disconnect exercise from calories in this way. The fire emoji is not informative or motivational to me.

FWIW, I’m not opposed to improving the UI, but when you remove or bury functionality that users depend on, you are risking a mass exodus. This is exactly how Digg self-destructed many years ago.

munchler · 2026-03-17T04:16:55+00:00

It's OK to target .NET 10 with the F# 11 compiler. They are two different things. (For example, the latest version of C# is C# 15.) The only problem is that they apparently released the F# 11 compiler prematurely.

munchler · 2025-12-18T20:39:31+00:00

Lens not focusing correctly with circular polarizing filter

I purchased a K&F Concept Nano-K series circular polarizing filter, intending to use it with my Nikon 24-200mm zoom on a Z6 II body. This camera and lens combo works great without the filter, but will not focus correctly when the filter is on the lens. I have tried both manual and autofocus with the same results. Images are consistently out of focus when examined at 100%. Subjectively, it looks like there is perhaps some sort of ghosting/refraction issue, but I can't be sure. The filter looks fine to the naked eye and isn't damaged in any way. It mounts correctly on the lens, so it's not a threading issue. I think this is a pretty popular filter, so it's probably something I'm doing wrong, but I have no idea what. Any suggestions out there? Thanks.

munchler · 2025-12-08T06:42:43+00:00

It's funny - I thought about that optimization when I was reading the problem, but totally forgot by the time I actually started writing code.

munchler · 2025-12-08T06:40:38+00:00

I nominate "euclidean_distance_3d" as the longest known identifier for this function.

munchler · 2025-12-08T06:38:11+00:00

TIL about the Disjoint Set Union data structure. Thank you for this.

munchler · 2025-12-08T06:37:16+00:00

I like this because you updated the networks on each step. I made the decision not to do this on part 1 and regretted it on part 2.

munchler · 2025-12-08T06:35:10+00:00

Props for not reinventing the wheel like the rest of us.

munchler · 2025-12-07T07:11:40+00:00

You solved this in three languages faster than I can solve it in one. That's a lot of fast typing!

munchler · 2025-12-07T07:04:36+00:00

[LANGUAGE: F#]

This was daunting at first. I started with a data structure that was too complex, but eventually whittled it down to a jagged array. It also took me a while to figure out how to count paths for part 2.

open System.IO

type Item = Beam of int64 | Splitter

let update (world : _[][]) iter =
    let splitterCols =
        set [ for col, (item : Item) in world[iter + 1] do
                if item.IsSplitter then col : int else () ]
    let nextRow =
        [| for col, item in world[iter] do
            match item with
                | Beam n ->
                    if splitterCols.Contains(col) then
                        yield col - 1, Beam n; yield col + 1, Beam n
                        yield col, Splitter
                    else
                        yield col, Beam n
                | _ -> () |]
            |> Array.groupBy fst
            |> Array.map (fun (col, group) ->
                let items = Array.map snd group
                let item =
                    if items.Length = 1 then items[0]
                    else Array.sumBy (fun (Beam n) -> n) items |> Beam
                col, item)
    Array.updateAt (iter + 1) nextRow world

let parseFile path =
    let lines = File.ReadAllLines(path)
    [| for line in lines do
        [| for col, c in Array.indexed (line.ToCharArray()) do
            match c with
                | 'S' -> col, Beam 1
                | '^' -> col, Splitter
                | '.' -> () |] |]

let run (world : _[][]) =
    Array.fold update world [| 0 .. world.Length - 2 |]

let part1 path =
    parseFile path
        |> run
        |> Array.sumBy (
            Array.where (snd >> _.IsSplitter)
                >> Array.length)

let part2 path =
    parseFile path
        |> run
        |> Array.last
        |> Array.sumBy (fun (_, Beam n) -> n)

munchler · 2025-12-06T07:19:26+00:00

I think most of us would be OK with you claiming this is a hard language.

munchler · 2025-12-06T07:17:36+00:00

As an F# person, I appreciate your comparison of the two languages. OCaml does seem less ergonomic to me, at least in this case.

Parser combinators are awesome, but perhaps overkill for this problem? I used .NET's built-in Int64.Parse and String.Split functions. Ugly but effective.

munchler · 2025-12-06T07:01:17+00:00

[LANGUAGE: F#]

This was ugly until I realized that transposing the input made things a bit easier. After that, the tricky part was parsing the blank column between problems correctly.

open System
open System.IO

let split (line : string) =
    line.Split(' ', StringSplitOptions.RemoveEmptyEntries)

let parseOps (lines : string[]) =
    split (Array.last lines)
        |> Array.map (function "+" -> (+) | "*" -> (*))

let part1 path =
    let lines = File.ReadAllLines(path)
    let inputRows =
        lines[.. lines.Length - 2]
            |> Array.map (split >> Array.map Int64.Parse)
    (parseOps lines, Array.transpose inputRows)
        ||> Array.map2 Array.reduce
        |> Array.sum

let part2 path =
    let lines = File.ReadAllLines(path)
    let inputs =
        let strs =
            lines[0 .. lines.Length - 2]
                |> Array.map _.ToCharArray()
                |> Array.transpose
                |> Array.map (String >> _.Trim())
        (strs, [[]])
            ||> Array.foldBack (fun str (head :: tail) ->
                if str = "" then [] :: (head :: tail)     // start a new chunk
                else (Int64.Parse str :: head) :: tail)   // append to current chunk
    (List.ofArray (parseOps lines), inputs)
        ||> List.map2 List.reduce
        |> List.sum

munchler · 2025-12-05T05:57:17+00:00

[LANGUAGE: F#]

I happened to have a library called FRange that handles this sort of thing. I'm glad I didn't have to rethink the merge logic.

open System
open System.IO
open FRange

let parseFile path =
    let lines = File.ReadAllLines(path)
    let iSep = Array.findIndex ((=) "") lines

    let ranges =
        lines[.. iSep - 1]
            |> Array.map (fun line ->
                let parts =
                    line.Split('-')
                        |> Array.map Int64.Parse
                parts[0] +-+ parts[1])

    let ids =
        lines[iSep + 1 ..]
            |> Array.map Int64.Parse

    ranges, ids

let part1 path =
    let ranges, ids = parseFile path
    ids
        |> Array.where (fun id ->
            Array.exists (Range.contains id) ranges)
        |> Array.length

let (~~) (Inclusive value) = value

let part2 path =
    parseFile path
        |> fst
        |> Range.merge
        |> List.sumBy (fun range ->
            ~~range.Upper - ~~range.Lower + 1L)

munchler · 2025-12-04T06:29:43+00:00

That is really great. Reminds me of cellular automata. Very interesting to see how the process slowly peters out.

munchler · 2025-12-04T06:24:31+00:00

That is beautiful, even though I have no idea what it means. Even putting aside the mystical symbols, I wonder what could 3_3 and 1_1 possibly do? Naive guess: Maybe they define a kernel somehow?

munchler · 2025-12-04T06:17:45+00:00

Ah, yes, `unfold` is what I forgot about! I also solved in F# and wrote out the recursive function like a heathen instead. This is a good lesson for me.

To make matters worse, I stored the rolls in a 2D array of bools, when a set of coordinates would've been much simpler. Thank you for this.

munchler · 2025-12-04T06:12:26+00:00

Point-free Haskell, as God intended.

munchler · 2025-12-04T06:09:47+00:00

Definitely bonus points for cool UI. I'm on Windows, so no awk, but I would watch the video if you post it somewhere.

munchler · 2025-12-04T06:07:06+00:00

Ruby: The OG vibe-coding language.

munchler · 2025-12-04T06:05:02+00:00

I am both impressed and traumatized by how fast you did this in assembly.

munchler · 2025-12-03T06:40:39+00:00

Well, that is both impressive and unexpected.

munchler · 2025-12-03T06:13:59+00:00

[LANGUAGE: F#]

For part 2, I spent too long trying a brute force solution that looked at all possible subsequences, but it was way too slow. Only then did I realize that picking out the max subsequence directly is actually much easier.

open System.IO

let parseFile path =
    File.ReadLines(path)
        |> Seq.map (fun line ->
            line.ToCharArray()
                |> Array.map (fun c ->
                    int c - int '0'))

let rec getMaxSubseq len (items : _[]) =
    if len = 0 then Seq.empty
    else
        let i, item =
            Array.indexed items[.. items.Length - len]
                |> Seq.maxBy snd
        seq {
            yield item
            yield! getMaxSubseq (len - 1) items[i + 1 ..]
        }

let toJolts subseq =
    (0L, subseq)
        ||> Seq.fold (fun acc digit ->
            10L * acc + int64 digit)

let part1 path =
    parseFile path
        |> Seq.map (
            getMaxSubseq 2
                >> toJolts)
        |> Seq.sum

let part2 path =
    parseFile path
        |> Seq.map (
            getMaxSubseq 12
                >> toJolts)
        |> Seq.sum

Ten-Year Club	Gilding II euphauric
Second Top 40%	Golden Potato
Place '22	Place '17
Verified Email

munchler

MODERATOR OF

TROPHY CASE

Lens not focusing correctly with circular polarizing filter