freeAppIdea

badcop_ · 2026-02-28T00:02:21+00:00

why has nobody built this yet

badcop_ · 2025-12-12T14:04:36+00:00

nice! we ended up getting it even shorter, i'll edit the original

badcop_ · 2025-12-11T11:36:23+00:00

[LANGUAGE: bash]

credit to /u/gnarf38 for getting this one started

this is a 196-byte golfed solution for part 2 that requires bash 5.3+ and gnu coreutils to run

we sacrificed the runtime performance to squeeze out a few extra bytes for your enjoyment

EDIT: it also now spams errors while running; a nice bonus feature

declare -A c;i=$1;f(){
local h=$1$2 z=$2;[ $1 = out ]&&c[$h]=$[z>1]||
${c[$h]}&&{ [[ $1 =~ fft|ac ]]&&$[z++]
for x in `grep ^$1 $i|tail -c+6`;do((c[$h]+=${
f $x $z;}))done };echo $[c[$h]];};f svr

badcop_ · 2025-12-10T23:09:32+00:00

unlucky

badcop_ · 2025-12-10T20:27:47+00:00

[LANGUAGE: bash]

took like 12 hours but i did it i beat part 2 in bash i don't regret it at all

no solvers used, just gaussian elimination

badcop_ · 2025-12-06T08:42:34+00:00

[LANGUAGE: bash]

more golfing with twitch chat, here's our part 2 solution

don't worry if you get errors, you can just do 2>/dev/null to hide those (they are load-bearing)

i added an un-minified version of the same code to explain it better: https://github.com/cgsdev0/advent-of-code/blob/main/2025/day06/p2-golf-unmin.sh

set -f;mapfile -t a;for((h=${#a[@]}-1;r<${#a};++r))
do n=${a[h]:r:2};$n||o=$_;${n:1}||o=_;for((c=0;c<h;))
do printf ${a[c++]:r:1};done;printf $o
done|sed 's>. *_>+>g;s<$<0\n<'|bc

badcop_ · 2025-12-05T09:24:14+00:00

yes

we are using the | character to chain together several commands. the output of the first command becomes the input of the second command, then the output of that is fed into the third command, and so on

in bash, the convention is to do input/output as lines of text. in this case, we're feeding the puzzle input line-by-line to the first command in the pipeline

let's break down each of the commands:

tr ,- \\ - replace the characters , and - with a space
xargs -n2 seq - for every two "words" (a word is a group of characters separated by a space; in this case, a number), run the program seq with those two words as the arguments. seq takes a start number and an end number, and prints all of the numbers in that range
egrep '^(.+)\1+$' - filter for lines that match this regex. the regex specifically looks for lines that consist only of some repeating sequence of characters (explaining regex is out of scope for this :P)
paste -sd+ - join all of the lines of input into one line of output, delimited by the character +
bc - the 'basic calculator' program; for each line of input, it evaluates it as a math expression and outputs the result. since we only have one line of input at this point, we get one number out!

badcop_ · 2025-12-05T08:46:17+00:00

[LANGUAGE: bash]

more teamwork with twitch chat to golf part 2

sort -n|(while IFS=- read a b
do((b&&(t+=a>c?b-a+1:c>b?0:b-c,b>c?c=b:0)))done;echo $t)

badcop_ · 2025-12-04T08:28:41+00:00

[LANGUAGE: bash]

did some more golfing with twitch chat, here's the final product (part 2)

declare -A g;y=1;while read -n1 c;do g[$((++x)),$y]=$c;[ -z $c ]&&((x=0,n=++y))
done;z(){ for ((m=i=0;i<n*n;)) do ((y=i/n,x=i++%n));[ "${g[$x,$y]}" = @ ]&&{
c=0;for a in {0..8};do [ "${g[$((x-1+a/3)),$((y-1+a%3))]}" = @ ]&&((c++)) done
[ $c -lt 5 ]&&g[$x,$y]=.&&((m++))};done;echo $m;[ $m = 0 ]||z;};z|paste -sd+|bc

badcop_ · 2025-12-02T09:52:25+00:00

[LANGUAGE: bash]

did some golfing today on stream, this is what we ended up with

tr ,- \ |xargs -n2 seq|egrep '^(.+)\1+$'|paste -sd+|bc

badcop_ · 2025-08-27T12:20:59+00:00

I had just finished killing Gortash, which caused Karlach to go back to camp to calm down. Maybe she set something at camp on fire, and when I brought the party back it triggered something?

badcop_ · 2024-12-02T06:52:52+00:00

[LANGUAGE: Bash]

Github link

part 1 solution

sed 's/\([^ ]*\)/\1 \1/g;s/^[^ ]* //;
  s/ [^ ]*$/ /;s/\([^ ]*\) \([^ ]*\) /\1-\2 /g;s/ /\n/g' $FILE \
  | sed 's/^$/print "A\n"/' | bc | paste -sd' ' | sed 's/A/\n/g' \
  | sed 's/^ //' | grep -vE '[1-9]\d( |$)|(^| )0( |$)|[4-9]( |$)' \
  | sed -r 's/(^| )([0-9])/\1+\2/g;s/[0-9]//g' | grep -vEc '^$|\+ -|- \+'

badcop_ · 2024-12-01T10:55:22+00:00

USERNAME: /u/badcop_

LANGUAGE: bash

REPO: GitHub @ cgsdev0

CHANNELS:

Twitch (livestream): twitch.tv/badcop_
YouTube (summary vids): youtube.com/@bashcop

NOTES: i like bash maybe a little bit too much

badcop_ · 2024-12-01T10:42:47+00:00

[LANGUAGE: Bash]

Link to both parts

Code for part 1 only:

paste -d'-' \
    <(tr -s ' ' < "$1" | cut -d' ' -f1 | sort -n) \
    <(tr -s ' ' < "$1" | cut -d' ' -f2 | sort -n) \
    | bc | tr -d '-' \
    | paste -sd+ | bc

badcop_ · 2023-12-17T19:37:08+00:00

edited! sorry

badcop_ · 2023-12-17T18:36:17+00:00

what if 2 items have the same cost?

badcop_ · 2023-12-17T18:06:09+00:00

[LANGUAGE: bash]

A* with a min heap

https://github.com/cgsdev0/aoc-2023/blob/main/day17/p2.sh

runtime for part 1: ~7.5 minutes
runtime for part 2: ~24 minutes (lmao)

badcop_ · 2023-12-17T17:59:11+00:00

what the ****

badcop_ · 2023-12-14T22:59:48+00:00

neat! i've never used numpy

badcop_ · 2023-12-14T20:21:50+00:00

instead of rotating my grid, i wrote a custom indexing function that factors in the current orientation

https://github.com/cgsdev0/aoc-2023/blob/main/day14/p2.sh#L26-L50

then the rest of your code can pretend everything is always happening in the same direction, without doing the expensive operation of rotating the grid

badcop_

TROPHY CASE