15/22/23: Pure bash. Minor speedup in slowest days

einarjon · einarjon · commit 6533a9f0d8b0 · 2024-03-07T15:06:53.000Z
14: Use printf -v instead of eval

15B: Use function name reference instead of eval

22B: Remove subshells for score
Simplify hash and recursion check.
Script return code is not depending on the winner of part 2.
Speeds up by 15% for some reason.

23B: Add optional pure bash version instead of awk only. Runs in
about 20 minutes. Had a 15 minute version but I didn't commit it.

Cleanup: Use globs in game of life.
diff --git a/11.sh b/11.sh
@@ -7,10 +7,10 @@ while [ ${#I} != 0 ]; do
     for i in $I; do
         for j in $J; do
             x=${B[i]:j:1}
-            if [[ "$x" == "L" || "$x" == "X" ]]; then
+            if [[ "$x" == [LX] ]]; then
                 s="${B[i-1]:j-1:3}${B[i]:j-1:3}${B[i+1]:j-1:3}"
                 s=${s//[L.]}; s=${s/$x}
-                if [[ ${#s} == 0 ]]; then x=X; elif [[ ${#s} -ge 4 ]]; then x=L; fi
+                if [[ -z $s ]]; then x=X; elif (( ${#s} >= 4 )); then x=L; fi
             fi
             l+=$x
         done
@@ -33,7 +33,7 @@ while [ ${#change} != 0 ]; do
     for i in $I; do
         for j in $J; do
             x=${B[i]:$j:1}
-            [[ "$x" != "L" && "$x" != "X" ]] && l+=$x && continue
+            [[ "$x" != [LX] ]] && l+=$x && continue
             r=${B[i]:j+1}; r=${r//.}; R=${B[i]:0:j}; R=${R//.}
             s=${R: -1}${r:0:1}
             k=1; d=${B[i-k]:j-k:1}; while [ "$d" = '.' ]; do ((++k)); d=${B[i-k]:j-k:1}; done; s+=$d
@@ -44,7 +44,7 @@ while [ ${#change} != 0 ]; do
             k=1; d=${B[i+k]:j+k:1}; while [ "$d" = '.' ]; do ((++k)); d=${B[i+k]:j+k:1}; done; s+=$d
             #[[ ${#s} == 8 ]] || echo "ERROR: ($s) $k = $i, $j"
             s=${s//L}
-            if [[ ${#s} == 0 ]]; then l+=X; elif [[ ${#s} -ge 5 ]]; then l+=L; else l+=$x; fi
+            if [[ -z $s ]]; then l+=X; elif (( ${#s} >= 5 )); then l+=L; else l+=$x; fi
         done
         [ "${B[i]}" != "L${l}L" ] && change+=1
         C+=(L${l}L); l=
diff --git a/14.sh b/14.sh
@@ -1,11 +1,11 @@
 #! /usr/bin/env bash
 IFS=$'\n'
 A=($(< "${1:-14.txt}"))
-declare -a mem
+declare -a mem mem2
 for i in "${A[@]}"; do
     case $i in
-        mask*) y=${i//*= }; o=$((2#${y//X/0})); z=$((2#${y//X/1}));;
-        mem*)  y=${i//*= }; eval "${i// =*}=$(((y&z)|o))";;
+        mask*) y=${i/*= }; o=$((2#${y//X/0})); z=$((2#${y//X/1}));;
+        mem*)  y=${i/*= }; printf -v "${i/ =*}" "%s" $(((y&z)|o));;
     esac
 done
 printf -v sum "+%s" "${mem[@]}"
diff --git a/15.sh b/15.sh
@@ -1,6 +1,5 @@
 #! /usr/bin/env bash
 A=($(<"${1:-15.txt}"))
-PUREBASH=${2:-$PUREBASH}
 declare -a B=()
 i=0; l=""
 for a in "${A[@]}"; do B[a]=$((++i)); done
@@ -9,28 +8,27 @@ while [ $i -lt 2020 ]; do
 done
 echo "15A: $n"
 
-# eval is slow, but large arrays are slower
 # Split the higher numbers into smaller arrays
+# large arrays are incredibly slow
 sharded_swap() { # syntax: l=B[$1]; B[$1]=$2
-    local x="B$(($1>>8))[$(($1&255))]"
-    #local x="B$(($1>>6))[$1&63]"
-    eval "l=\${$x}; $x=$2"
+    local -n x=$1
+    l=$x; x=$2
 }
 
-if [ -n "$PUREBASH" ]; then
+if [[ -n ${2:-$PUREBASH} ]]; then
     trap 'echo "Giving up (i=$i, $SECONDS seconds)"; exit 1' TERM INT
-    echo "This could take 15-20 minutes. Ctrl-C or 'kill $$' to stop."
+    echo "Part 2 could take 15-20 minutes. Ctrl-C or 'kill $$' to stop."
     declare -a B{1..1000}
-    for N in $(seq 1000000 1000000 30000000 ); do
+    for N in {1000000..30000000..1000000}; do
         while ((i < N)); do
             n=$((i-${l:-$i}));
             if (( n < 2048 )); then
                 l=${B[n]}; B[n]=$((++i))
             else
-                sharded_swap $n $((++i))
+                sharded_swap "B$((n>>8))[$((n&255))]" $((++i))
             fi
         done
-        echo "$i took $SECONDS seconds" ;
+        echo "$i took $SECONDS seconds"
     done
     echo "15B: $n"
 else
diff --git a/17.sh b/17.sh
@@ -30,7 +30,7 @@ solve17() {
     done
     for i in "${!C[@]}"; do
         if [[ -n "${B[$i]}" ]]; then
-            [[ ${#C[$i]} == 2 || ${#C[$i]} == 3 ]] || unset "B[$i]"
+            [[ ${#C[$i]} == [23] ]] || unset "B[$i]"
         else
             [[ ${#C[$i]} == 3 ]] && B[$i]=1
         fi
diff --git a/22.sh b/22.sh
@@ -17,28 +17,27 @@ while [[ -n "$A" && -n "$B" ]]; do
     B=(${B[@]:1})
     #((++round%500==0)) && echo "$round: ${#A[@]}/${#B[@]}"
 done
-echo "22A: $(score "${A[@]}" "${B[@]}")"
+printf "22A: "; score "${A[@]}" "${B[@]}"
 
 r() {
   declare -A H
-  local a=($1) b=($2) hash
+  local a=($1) b=($2) depth=$3
   # shellcheck disable=SC2128,SC2181
   while [[ -n "$a" && -n "$b" ]]; do
-    hash=${a[*]}X${b[*]}
-    if (( H[${hash// /_}]++ > 0)); then
+    if (( ++H[${a[*]}X${b[*]}] > 1)); then
         return 0
     elif [[ $a -lt ${#a[@]} && $b -lt ${#b[@]} ]];  then
-        r "${a[*]:1:a}" "${b[*]:1:b}"
+        r "${a[*]:1:a}" "${b[*]:1:b}" $((depth+1))
     else
         [[ $a -gt $b ]]
     fi
     if [[ $? == 0 ]]; then a+=($a $b); else b+=($b $a); fi
     a=(${a[@]:1})
     b=(${b[@]:1})
-    #((${#H[@]}%1000==0)) && echo "$round:${#H[@]}: ${#a[@]}/${#b[@]}"
+    #((${#H[@]}%1000==0)) && echo "$depth:${#H[@]}: ${#a[@]}/${#b[@]}"
   done
-  ((${#a[*]}+${#b[*]} == N)) && echo "22B: $(score "${a[@]}" "${b[@]}")"
-  return ${#b[@]}
+  [[ $depth != 0 ]] && return ${#b[@]}
+  printf "22B: "; score "${a[@]}" "${b[@]}"
 }
 
-r "${C[*]:0:N/2}" "${C[*]:N/2}"
+r "${C[*]:0:N/2}" "${C[*]:N/2}" 0
diff --git a/23.sh b/23.sh
@@ -13,24 +13,60 @@ while [ "${A:i:1}" != "$c" ]; do ((++i==9)) && i=0; done
 ((++i==9)) && i=0
 done
 echo "23A: ${A/*1}${A/1*}"
-A=$(<"${1:-23.txt}")
+A=$(<"${1:-23.txt}") a=0 b=0 c=0
 #A=389125467
-grep -o "[1-9]" <<< "$A" | awk '
-{ if(last){ C[last]=$0 }else{ cup=$0 }; last=$0; ++i; }
-END{
-N=10000000;
-max=1000000;
-C[last]=++i;
-while (i<max) {C[i-1]=++i}
-C[max]=cup;
-for (i=0; i<N; i++) {
-  a=C[cup]; b=C[a]; c=C[b];
-  d=cup; if (--d<=0) { d=max }
-    while (d == a || d == b || d == c) {
-    if (--d<=0) { d=max }
-  }
-  C[cup]=C[c];
-  tmp=C[d]; C[d]=a; C[c]=tmp; cup=C[cup];
+if [[ -n ${2:-$PUREBASH} ]]; then
+getC() {
+    local -n x_=$1 Cy=$2
+    # shellcheck disable=SC2034
+    x_=$Cy
+}
+swap() {
+    declare -n Cc=$1 Cd=$2 Ccup=$3
+    Ccup=$Cc; tmp=$Cd; Cd=$a; Cc=$tmp; cup=$Ccup
 }
-printf "23B: %d*%d = %d\n", C[1] , C[C[1]], C[1]*C[C[1]]
-}'
+    trap 'echo "Giving up (i=$i, $SECONDS seconds)"; exit 1' TERM INT
+    echo "Part 2 could take 15-20 minutes. Ctrl-C or 'kill $$' to stop."
+    N=10000000 max=1000000
+    B=($(grep -o "[1-9]" <<< "$A"))
+    cup=${B[0]}
+    j=0; for i in {1..1000000}; do printf -v "C$((j>>8))[j&255]" "%s" "$i"; j=$i; done
+    last=$cup; for i in "${B[@]:1}"; do C0[last]=$i; last=$i;  done
+    printf -v "C$((max>>8))[max&255]" "%s" "$cup"
+    echo "Ready $SECONDS second $cup"
+    i=0
+    for N in {500000..10000000..500000}; do
+        for (( ; i < N; ++i)); do
+            getC a "C$((cup>>8))[cup&255]"; getC b "C$((a>>8))[a&255]"; getC c "C$((b>>8))[b&255]"
+            ((d=cup-1)) || d=$max
+            while ((d == a || d == b || d == c)); do
+                ((--d)) || d=$max
+            done
+            swap "C$((c>>8))[c&255]" "C$((d>>8))[d&255]" "C$((cup>>8))[cup&255]"
+        done
+        echo "$i took $SECONDS seconds: cup=$cup"
+    done
+    a=${C0[1]}; getC b "C$((a>>8))[a&255]"
+    echo "23B: $a * $b = $((a*b))"
+else
+    grep -o "[1-9]" <<< "$A" | awk '
+    { if(last){ C[last]=$0 }else{ cup=$0 }; last=$0; ++i; }
+    END {
+        N=10000000;
+        max=1000000;
+        C[last]=++i;
+        while (i<max) {C[i-1]=++i}
+        C[max]=cup;
+        for (i=0; i<N; i++) {
+            #if (i%500000 ==0) {print i, "cup=", cup }
+            a=C[cup]; b=C[a]; c=C[b];
+            d=cup; if (--d<=0) { d=max }
+            while (d == a || d == b || d == c) {
+                if (--d<=0) { d=max }
+            }
+            C[cup]=C[c]; tmp=C[d]; C[d]=a; C[c]=tmp;
+            cup=C[cup];
+        }
+        printf "23B(awk): %d*%d = %d\n", C[1] , C[C[1]], C[1]*C[C[1]]
+    }'
+fi
diff --git a/24.sh b/24.sh
@@ -30,7 +30,7 @@ solve24() {
     done
     for i in "${!C[@]}"; do
         if [[ -n "${B[$i]}" ]]; then
-            [[ ${#C[$i]} == 1 || ${#C[$i]} == 2 ]] || unset "B[$i]"
+            [[ ${#C[$i]} == [12] ]] || unset "B[$i]"
         else
             [[ ${#C[$i]} == 2 ]] && B[$i]=1
         fi
diff --git a/25.sh b/25.sh
@@ -1,7 +1,6 @@
 #! /usr/bin/env bash
 A=($(< "${1:-25.txt}"))
-PUREBASH=${2:-$PUREBASH}
-if [ -n "$PUREBASH" ]; then
+if [[ -n ${2:-$PUREBASH} ]]; then
     trap 'echo "Giving up after $SECONDS seconds"; exit 1' INT TERM
     echo "This could take a minute. Ctrl-C or 'kill $$' to exit"
     declare -i k=1 e=1 key1=${A[0]} key2=${A[1]}
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@ https://adventofcode.com/2020/
 
 Input not included, but can be given on the command line.
 Defaults to *number*.txt in the same folder (no leading 0).
-Setting env variable PUREBASH to any value (or giving a second argument) will use slow bash instead of using faster awk in days 15 and 25.
+Setting env variable PUREBASH to any value (or giving a second argument) will use slow bash instead of using faster awk in days 15, 23 and 25.
 
 Description of what I'm doing. Contains spoilers....
 
@@ -66,7 +66,7 @@ Description of what I'm doing. Contains spoilers....
  2. Simple (possibly not correct) implementation of Chinese Remainder Theorem.
 
 ### 14.sh
- 1. Switch case similar to day 4 and 8. Use eval to avoid parsing the number in mem\[x\].
+ 1. Switch case similar to day 4 and 8. Use printf -v to avoid parsing the number in mem\[x\].
  2. Use IFS and read to simplify handling.
     Recursive function that converts the first X to 1 and 0, and calls itself twice until no X remains. Then do the thing.
 
@@ -113,13 +113,13 @@ Description of what I'm doing. Contains spoilers....
 
 ### 23.sh
  1. String manipulation. Lots of trial and error to get it right.
- 2. Not suitable for bash. Done in awk, but still takes about half a minute
+ 2. Just over 20 minutes in bash. Awk is more than 60 times faster.
 
 ### 24.sh
  1. Use an X-Y grid with only diagonals. One step can be (±2,0) or (±1,±1). Modify input so that standalone e/w are doubled, and count the total movement.
  2. Hex game of life. Use the same index trick as day 17. Access the grid manually, since a loop would be a PITA.
 
 ### 25.sh
- 1. A couple of while loops. Yay.
+ 1. While loop for 15M rounds. Yay. Awk finishes in seconds.
  2. I need to complete 20-2 to get this one. Nope.
 
