input=${1:-5.txt}

swap(){

local -n _x=$1 _y=$2

local tmp=$_x; _x=$_y; _y=$tmp

}

IFS=$' ,\n'; ANS=0; ANS2=0; declare -Ai C=() D=()

while read -r x y _ X Y; do

if (( x == X )); then

(( y > Y )) && swap y Y

while ((y<=Y)); do C[$x.$y]+=1; ((y++));done

elif (( y == Y )); then

(( x > X )) && swap x X

while ((x<=X)); do C[$x.$y]+=1; ((x++));done

elif (( (X-x) == (Y-y) || (X-x) == -(Y-y) )); then

(( x > X )) && swap x X && swap y Y

if (( y > Y )); then i=-1; else i=1; fi

while ((x<=X)); do D[$x.$y]+=1; ((x++,y+=i));done

fi

done < "$input"

ANS=(${C[@]//1}) # Lazy count. Fails if there are 11 crossings

echo "5A: ${#ANS[@]}"

for i in "${!C[@]}"; do D[$i]+=${C[$i]}; done

ANS2=(${D[@]//1})

echo "5B: ${#ANS2[@]}"

A=$(< "${1:-6.txt}")

A=${A//,}

solve() {

for ((; n < $1; ++n)); do

#births=${A//[^0]}; births=${births//0/8}

births=$(tr -cd 0 <<< "$A" | tr 0 8)

B=$(echo -n "$A" | tr 876543210 765432106 )

A[i]="${B[i]}${births}"

done

}

n=0

solve 80

echo "6A: ${#A}"

A=($(tr , '\n' < "${1:-7.txt}" | sort -n ))

MIN=(99999999 0) MIN2=(9999999999999 0)

N=${#A[@]}

for ((i=A[N/4]; i<A[-N/4]; i++)); do

n=''; for k in ${A[@]};do n+=+$((k-i)); done;

sum=$((${n//-})) # lazy abs()

((MIN>sum)) && MIN=($sum $i)

echo "7A: ${MIN[0]}"

for ((i=A[N/4]; i<A[-N/4]; i++)); do

declare -i sum2=0;

for k in ${A[@]}; do

dist=$((k-i)); dist=${dist/-}

sum2+=$((dist*(dist+1)/2))

done;

((MIN2>sum2)) && MIN2=($sum2 $i)

echo "7B: ${MIN2[0]}"

Advent of Code 2021, done in bash. Because I can't stop

Input can be given on the command line.

Defaults to *number*.txt in the same folder (no leading 0).

Added my input files in input/ folder.

Setting env variable PUREBASH to any value (or giving a second argument) will use slow bash instead of using faster awk when needed.

Description of what I'm doing. Contains spoilers....

1. Dumb looping through all variables.

2. Use a sliding window. 2/3 of the values in the windows are the same, but this is fine.

Simple switch to handle all cases. Both parts handled at once.

1. Slightly tricky. Use a function to find the most/least common number in each position.

2. Same function, but change the input for every char.

1. Use an array to store all lines/rows of a bingo card. Delete numbers from all lines until a line is empty.

2. Remove a card when a line is empty. Keep going until all cards are gone.

1. Mark all points on the grid in a hash table. Return a count of points that are != 1.

2. Mark diagonals on a second hash table. Add the first hash table to it and return a count of points that are != 1.

1. String manipulation. Bad O(), but finishes part 1 in half a second.

2. Too slow...

1. Brute force search.

2. More brute force.