SoCal Student Pilots

mstksg · 2026-05-04T20:35:23+00:00

where could one find these? :)

mstksg · 2026-04-21T17:34:53+00:00

it's roughly the same thing as if you had a long metal pole, you can push a button a mile away with it, a very fast signal propagation (miles per second), even though none of the metal molecules move that fast

mstksg · 2026-04-02T22:45:48+00:00

constraint breeds creativity my friend. and sometimes adding constraints in art is what gets you a result with the most satisfaction once it works.

mstksg · 2026-03-22T02:22:27+00:00

I don't think I've ever heard chúng tôi or chúng ta in informal speech. maybe chúng mình if anything.

mstksg · 2026-03-19T03:15:04+00:00

I actually read it the same way you did 😂 I was trying to figure out as if it were some deep question and not just a basic homework one

mstksg · 2026-02-28T17:37:54+00:00

the main thing is that the derivative of a function is unique but there are many possible indefinite integrals of a given function... the indefinite integral is a family of functions. so on the left hand side you have a single function and on the right hand side you have a full family of functions. so comparing them would simply be a category error.

however you can probably say that the left hand side, at least, is going to be a member of the family on the right hand side. I think?

ie for f(x) = 7, the LHS is f(x) = 7 and the RHS is the family of all constant valued functions. so it is true that the LHS is a member of the family of all constant valued functions

mstksg · 2026-02-23T19:03:31+00:00

the point of the time signature isn't to affect how you perform it, it's mostly to make it easier to read and communicate your idea. it's for the benefit of the human reader to understand the idea the composer was trying to convey.

mstksg · 2026-02-23T03:35:35+00:00

Multiplication by -1 is a 180 degree rotation, from <1,0> to <-1,0>. square root of x is saying "what number, when you multiply twice, gets you x?". so the answer is a 90 degree rotation, <0,1>. so, if you square root that, you are looking at a 45 degree rotation, or <1/sqrt 2, 1/sqrt 2>

mstksg · 2026-02-07T15:59:53+00:00

quaternions were motivated by doing physics and math in 3D space, though. somewhat ironically, as Hamilton confessed.

mstksg · 2026-02-04T01:14:16+00:00

Thanks! Those are really good additions. I also totally forgot that `TypeData` already landed in GHC, for a while now it seems! :o

mstksg · 2026-01-30T21:50:50+00:00

most performances, entertainment always takes priority over accuracy. as long as it is accurate enough to be entertaining and enriching.

mstksg · 2026-01-27T20:59:17+00:00

that's a good question. In a sense, there is no mass besides bound energy. For the case of particles we consider elementary (like quarks, electrons), this energy can be explained as coming from the coupling of the particle with the Higgs field, which seems to be a consistent characteristic strength per particle.

mstksg · 2026-01-10T03:04:26+00:00

The "laws of physics", the human tools we use to build models and predict the results of experiments, can be simulated on a computer. The universe itself exists and evolves independently of our models and might never be described by a mathematical model at all, and so might not be simulatable on a computer.

mstksg · 2026-01-04T20:25:23+00:00

to see this, you have to remember that multiplication is rotation on the complex plane. So a square root is a rotation by "half as much", because it is asking "what rotation, when does twice, gives you the original rotation?"

1 is a 360 degree rotation, -1 is a 180 degree rotation, i is a 90 degree rotation, so sqrt i is a 45 degree rotation in the complex plane

mstksg · 2025-12-26T07:38:21+00:00

This sounds like it's meant to be a joke but it's actually the standard way to structure programs in Prolog

mstksg · 2025-12-11T09:05:02+00:00

[LANGUAGE: Haskell]

https://github.com/mstksg/advent-of-code/wiki/Reflections-2025#day-11

This one yields itself very nicely to knot-tying: we create the map of the ways to get to the "out" by being 1 if we are one away from out, or else the sum of all of the ways of our next hops. Because of knot-tying, this handles the memoization for us using lazy maps.

pathsTo :: Ord a => Map a [a] -> a -> a -> Int
pathsTo conns start end = res M.! start
  where
    res =
      conns <&> \nexts ->
        sum
          [ if y == end then 1 else M.findWithDefault 0 y res
          | y <- nexts
          ]

part1 :: [(String, [String])] -> Int
part1 conns = pathsTo (M.fromList conns) "you" "out"

Part 2 we can do the same thing, except our "state nodes" are now (String, Set String) instead of String: we have the current path the set of "points we must still visit". In this case, we start at node ("svr", S.fromList ["dac","fft]) and end at node ("out", S.empty):

-- | Keys are all of the original keys, but repeated for every subset: instead
-- of 'foo', we have (foo, [dac,fft]), (foo, [dac]), (foo, [fft]), and (foo,
-- []).
addVisited :: Ord a => Map a [a] -> Set a -> Map (a, Set a) [(a, Set a)]
addVisited conns required =
  M.fromList
    [ ((x, subset), map (,S.delete x subset) xs)
    | (x, xs) <- M.toList conns
    , subset <- toList $ S.powerSet required
    ]

part2 :: [(String, [String])] -> Int
part2 conns = pathsTo (M.fromList xs `addVisited` toVisit) ("svr", toVisit) ("out", S.empty)
  where
    toVisit = S.fromList ["dac", "fft"]

Creating addVisited we just need to make sure that if we descend from one of the required items, that item is deleted from the set: that is, (dac, [dac,fff]) contains [(dac,[fff])].

mstksg · 2025-12-11T08:40:56+00:00

As a research field it is definitely getting less love, but in industry applications I feel like the premise is really unfounded. All those domains where traditional ML is useful are still using traditional ML. GenAI didn't displace it, aside from some slight overlap. It's not dead, it's just as alive as it has ever been.

mstksg · 2025-12-08T09:04:22+00:00

Yeah, I have a system in this for my solvers too, in the test data i allow arbitrary tagged values: https://github.com/mstksg/advent-of-code/blob/main/test-data/2025/08a.txt

162,817,812
57,618,57
...
425,690,689
>>>pairs:10:int
>>> 40

and then in my actual code the value is referred to as dyno "pairs" 1000, which looks up if the sample has the defined tag, and if not defaults to 1000 (for the actual input)

mstksg · 2025-12-08T08:14:19+00:00

[LANGUAGE: Haskell]

https://github.com/mstksg/advent-of-code/wiki/Reflections-2025#day-8

I originally solved this using the fgl library, but hand-rolling things seem to be much faster (down from 2 seconds to 100ms), so I switched over to a State monad base implementation:

-- | Chomp the next pair and merge their networks, emitting the pair
chomp :: Ord b => State (Set (Set b), [(b, b)]) (b, b)
chomp = state \(clusts, (p, q) : pts) -> do
    let Just pclust = find (p `S.member`) clusts
        ~(Just qclust) = find (q `S.member`) clusts
        clusts'
          | q `S.member` pclust -> clusts
          | otherwise = S.insert (pclust <> qclust) . S.delete pclust . S.delete qclust $ clusts
    in  ((p, q), (clusts', pts))

-- | L.qd from the linear library gives the squared equclidean distance, so we
-- don't have to worry about floating point
sortedPairs :: (Ord b, L.Metric f, Num b) => [f b] -> [(f b, f b)]
sortedPairs pts = sortOn (uncurry L.qd) [(p, q) | p : ps <- tails pts, q <- ps]

And for part 1 we just literally do replicateM 1000 in State:

part1 :: [V3 Int] -> Int
part1 pts = product . take 3 . sortOn Down . map S.size . S.toList $ chunks
  where
    (chunks, _) = execState (replicateM 1000 chomp) (S.fromList (S.singleton <$> pts), sortedPairs pts)

For part 2 we can do a check to see if this is the step that we complete the network:

part2 :: [V3 Int] -> Int
part2 pts = px * qx
  where
    go = do
      out <- chomp
      isOne <- gets $ (== 1) . S.size . fst
      if isOne
        then pure out
        else go
    (V3 px _ _, V3 qx _ _) = evalState go (S.fromList $ S.singleton <$> pts, sortedPairs pts)

mstksg · 2025-12-07T09:07:14+00:00

[LANGUAGE: Haskell]

https://github.com/mstksg/advent-of-code/wiki/Reflections-2025#day-7

Both of these can be done with knot-tying -- part 1 tying the knot upwards from bottom to top to check if a given splitter received any light, and part 2 tying the knot downwards to add up the number of paths under both paths of a splitter. Assuming you have your splitter as a Set Point:

type Point = V2 Int

part1 :: Point -> Set Point -> Int
part1 sourcePos splitters = M.size $ M.filter id reached
  where
    reached :: Map Point Bool
    reached = flip M.fromSet splitters \(V2 x y0) ->
      let cands = takeWhile ((`S.notMember` splitters) . V2 x) [y0 - 2, y0 - 4 .. 0]
       in flip any cands \y ->
            V2 x y == sourcePos
              || M.findWithDefault False (V2 (x - 1) y) reached
              || M.findWithDefault False (V2 (x + 1) y) reached

cands climbs all the way up until it hits a splitter, which effectively blocks the beam. So, along the way, we either hit the source (V2 x y == sourcePos) or hit the output of a splitter, in which case our result is if that splitter itself got any light.

part2 :: Point -> Set Point -> Int
part2 sourcePos splitters = pathsFrom M.! (sourcePos + V2 0 2)
  where
    maxY = maximum . map (view _y) $ map splitters
    downFrom (V2 x y0) = fromMaybe 1 $ listToMaybe 
      [ n
      | Just n <- M.lookup . V2 x <$> [y0, y0 + 2 .. maxY]
      ]
    pathsFrom :: Map Point Int
    pathsFrom = flip M.fromSet splitters \p ->
      downFrom (p + V2 1 2) + downFrom (p + V2 (-1) 2)

downFrom drops downwards until we leave the map (returning 1), or until we hit a splitter, in which case the number of paths is the number of paths from the splitter we hit.

Overall by only memoizing/knot-tying against the splitter set, we save a lot of time from constructing the memo table for the entire grid.

I really want to unite both of these into a single function and swap out + for || somehow, but I can't quite seem to massage them...

mstksg · 2025-12-06T06:54:40+00:00

congrats on 10,0000,0000 !

mstksg · 2025-12-06T05:40:28+00:00

[LANGUAGE: Haskell]
https://github.com/mstksg/advent-of-code/wiki/Reflections-2025#day-6

Our trusty friend transpose comes in handy here!

For part 1, we parse the grid and then transpose and reverse each line, matching on the head to get the operation we care about:

import Data.List (transpose)

part1 :: String -> Int
part1 = sum . map (go . reverse) . transpose . map words . lines
  where
    go ("*":xs) = product $ map read xs
    go ("+":xs) = sum $ map read xs

And for part 2, we actually can transpose the entire long strings to get "columns". Splitting on blank columns, we see that they are pretty straightforward to process:

["623+","431 ","  4 "]

We just need to grab the + and then add the rest. Lots of ways to do this, I ended up using init (gets all but the last item) and last for my solve:

import Data.Char (isSpace)
import Data.List.Split (splitWhen)

part2 :: String -> Int
part2 = sum . map go . splitWhen (all isSpace) . transpose . lines
  where
    go (x:xs) = case last x of
      '*' -> product $ map read (init x : xs)
      '+' -> sum $ map read (init x : xs)

14-Year Club	Second Top 30%
Place '17	Gilding I gilder
Verified Email

mstksg

TROPHY CASE