re:followup
If you somehow wanted your whole final array it would also require over 1 Peta byte ^^, memoization definetely reccomended.
zogwarg
joined 2 years ago
Day 11
Some hacking required to make JQ work on part 2 for this one.
Part 1, bruteforce blessedly short
#!/usr/bin/env jq -n -f
last(limit(1+25;
[inputs] | recurse(map(
if . == 0 then 1 elif (tostring | length%2 == 1) then .*2024 else
tostring | .[:length/2], .[length/2:] | tonumber
end
))
)|length)
Part 2, some assembly required, batteries not included
#!/usr/bin/env jq -n -f
reduce (inputs|[.,0]) as [$n,$d] ({}; debug({$n,$d,result}) |
def next($n;$d): # Get next # n: number, d: depth #
if $d == 75 then 1
elif $n == 0 then [1 ,($d+1)]
elif ($n|tostring|length%2) == 1 then [($n * 2024),($d+1)]
else # Two new numbers when number of digits is even #
$n|tostring| .[0:length/2], .[length/2:] | [tonumber,$d+1]
end;
# Push onto call stack #
.call = [[$n,$d,[next($n;$d)]], "break"] |
last(label $out | foreach range(1e9) as $_ (.;
# until/while will blow up recursion #
# Using last-foreach-break pattern #
if .call[0] == "break" then break $out
elif
all( # If all next calls are memoized #
.call[0][2][] as $next
| .memo["\($next)"] or ($next|type=="number"); .
)
then
.memo["\(.call[0][0:2])"] = ([ # #
.call[0][2][] as $next # Memoize result #
| .memo["\($next)"] // $next # #
] | add ) | .call = .call[1:] # Pop call stack #
else
# Push non-memoized results onto call stack #
reduce .call[0][2][] as [$n,$d] (.;
.call = [[$n,$d, [next($n;$d)]]] + .call
)
end
))
# Output final sum from items at depth 0
| .result = .result + .memo["\([$n,0])"]
) | .result
I remember being quite ticked off by her takes about free will, and specifically severly misrepresenting compatibilism and calling philosphers stupid for coming up with the idea.
One look day 9 and I had to leave it until after work (puzzles unlock at 2PM for me), it wasn't THAT hard, but I had to leave it until later.
re:10
Mwahaha I'm just lazy and did are "unique" (single word dropped for part 2) of start/end pairs.
#!/usr/bin/env jq -n -R -f
([
inputs/ "" | map(tonumber? // -1) | to_entries
] | to_entries | map( # '.' = -1 for handling examples #
.key as $y | .value[]
| .key as $x | .value | { "\([$x,$y])":[[$x,$y],.] }
)|add) as $grid | # Get indexed grid #
[
($grid[]|select(last==0)) | [.] | # Start from every '0' head
recurse( #
.[-1][1] as $l | # Get altitude of current trail
( #
.[-1][0] #
| ( .[0] = (.[0] + (1,-1)) ), #
( .[1] = (.[1] + (1,-1)) ) #
) as $np | # Get all possible +1 steps
if $grid["\($np)"][1] != $l + 1 then
empty # Drop path if invalid
else #
. += [ $grid["\($np)"] ] # Build path if valid
end #
) | select(last[1]==9) # Only keep complete trails
| . |= [first,last] # Only Keep start/end
]
# Get score = sum of unique start/end pairs.
| group_by(first) | map(unique|length) | add
Day 9 discussion
Part two for me was also very slow until I, speed up the index search by providing a lower bound for the insertion. for every insertion of size "N",
I have an array lower = [null, 12, 36, ...], since from the left any time you find free space for a given size, the next time must be at an index at least one larger, which makes it close to being O(N) [assuming search for the next free space is more or less constant] instead of O(N^2), went from about 30s to 2s.
https://github.com/zogwarg/advent-of-code/blob/main/2024/jq/09-b.jq
Day 8
Al lot of grid index shuffling these past few days! Not too difficult yet though, will this year be gentler or much harsher later?
Part 2 code in JQ
#!/usr/bin/env jq -n -R -f
[ inputs / "" ] | [.,.[0]|length] as [$H,$W] |
#----- In bound selectors -----#
def x: select(. >= 0 and . < $W);
def y: select(. >= 0 and . < $H);
reduce (
[
to_entries[] | .key as $y | .value |
to_entries[] | .key as $x | .value |
[ [$x,$y],. ] | select(last!=".")
] | group_by(last)[] # Every antenna pair #
| combinations(2) | select(first < last)
) as [[[$ax,$ay]],[[$bx,$by]]] ({};
# Assign linear anti-nodes #
.[ range(-$H;$H) as $i | "\(
[($ax+$i*($ax-$bx)|x), ($ay+$i*($ay-$by)|y)] | select(length==2)
)"] = true
) | length
Day 3 well suited to JQ
Part 2
#!/usr/bin/env jq -n -R -f
reduce (
inputs | scan("do\\(\\)|don't\\(\\)|mul\\(\\d+,\\d+\\)")
| [[scan("(do(n't)?)")[0]], [ scan("\\d+") | tonumber]]
) as [[$do], [$a,$b]] (
{ do: true, s: 0 };
if $do == "do" then .do = true
elif $do then .do = false
elif .do then .s = .s + $a * $b end
) | .s
I would say it goes further and that they have a (pseudo?)magical trust in their own intuitions, as if they are crystal clear revalations from the platonic realms.
And following the foregone conclusion of the author, someone who can never exist and therefore will remain forever hypothetical. (Unless the basilisk would also want to punish all you possible hypothetical children as extra incentive?).
PS- This is almost "A modest proposal" levels of bad, without being satire.
I think that particular talking point also serves an exculpatory purpose: "If it was only a razor-thin victory I might understand being angry with me, but see it's a decisive victory. He has the mandate ~~of heaven~~ of the people (this is a Trumpian victory! not a Democrat failure!) ! It would be wrong not to congratulate him!"
I liked day 13, a bit easy but in the right way.
Edit:
Spoilers
Although saying "minimum" was a bit evil when all of the systems had exactly 1 solution (not necessarily in ℕ^2), I wonder if it's puzzle trickiness, anti-LLM (and unfortunate non comp-sci souls) trickiness or if the puzzle was maybe scaled down from a version where there are more solutions.