day 20 part 2 (bash): final version

2020/OUTPUT

@@ -448,6 +448,12 @@ ex2.bash : res=412
 ================= day20 =================
 =========================================
 
++++++++++++++++++ ex1
 ex1.bash : res=5966506063747
-	time: 0:00.54 real, 0.53 user, 0.00 sys
+	time: 0:00.56 real, 0.56 user, 0.00 sys
-	context-switch:	1+1, page-faults: 0+223
+	context-switch:	4+1, page-faults: 0+224
+
++++++++++++++++++ ex2
+ex2.bash res=1714
+	time: 0:02.14 real, 2.05 user, 0.02 sys
+	context-switch:	1146+1, page-faults: 0+605

2020/day20/OUTPUT

@@ -1,4 +1,8 @@
 ex1.bash : res=5966506063747
-	time: 0:00.54 real, 0.53 user, 0.00 sys
+	time: 0:00.56 real, 0.56 user, 0.00 sys
-	context-switch:	1+1, page-faults: 0+223
+	context-switch:	4+1, page-faults: 0+224
+
+ex2.bash res=1714 
+	time: 0:02.14 real, 2.05 user, 0.02 sys
+	context-switch:	1146+1, page-faults: 0+605
 

2020/day20/ex2.bash

@@ -8,9 +8,8 @@ shopt -s extglob
 
 source tile.bash
 
-#declare -A strings
 declare -a strings T R B L RT RR RB RL nums
-declare -a final finalfoo
+declare -a final
 declare -A FINAL
 declare -a CORNER EDGE CENTRAL
 declare -i count=-1 SQUARE
@@ -41,7 +40,6 @@ case "$count" in
         exit 0
         ;;
 esac
-printf "size=%d\n" "$SQUARE"
 
 declare top bottom left right
 declare fliptop flipbottom flipleft flipright
@@ -68,9 +66,7 @@ for key in "${!nums[@]}"; do
     RL+=("$flipleft")
 
 done
-#echo BORDERS:
+
-#print_all_borders
-#exit 0
 ALL="${T[*]} ${R[*]} ${B[*]} ${L[*]} ${RT[*]} ${RR[*]} ${RB[*]} ${RL[*]} "
 ALLSIZE=${#ALL}
 
@@ -83,7 +79,6 @@ for ((i=0; i<${#nums[@]}; ++i)); do
         ((c += (ALLSIZE-${#S})/10))
     done
     # 6 is 4 for itself, + 2 for other matching
-    #printf "%s: %d\n" "${nums[$i]}" "$c"
     case "$c" in
         6)
             CORNER+=("$i")
@@ -98,60 +93,29 @@ for ((i=0; i<${#nums[@]}; ++i)); do
 
 done
 
-printf "CENTRAL[%d]=%s\n" "${#CENTRAL[@]}" "${CENTRAL[*]}"
-printf "EDGE[%d]=%s\n" "${#EDGE[@]}" "${EDGE[*]}"
-printf "CORNER[%d]=%s\n" "${#CORNER[@]}" "${CORNER[*]}"
-for ((i=0; i<${#CORNER[@]}; ++i)); do
-    printf "corner[%d]=%d\n" "$i" "${nums[$i]}"
-done
-
-#printf "ALL=%s\n" "$ALL"
-printf "ALLSIZE=%d\n" "$ALLSIZE"
-printf "%s : count=%d\n" "$CMD" "$count"
-
 for ((row=0; row<SQUARE; ++row)); do
     for ((col=0; col<SQUARE; ++col)); do
-        for k in "${!FINAL[@]}"; do
-            printf "final[%s]=%d\n" "$k" "${FINAL[$k]}"
-        done
         found=0
-        printf "square(%d,%d)\n" "$row" "$col"
         ################################## 1st tile (top left)
         if ((row==0 && col==0)); then
             # Choose one corner for top-left, find the correct orientation
             i=${CORNER[0]}
-            printf "corner[0]=%d\n" "${nums[$i]}"
             unset "CORNER[0]"
             CORNER=("${CORNER[@]}")
 
-            print_tile "$i"; echo
-            t=${L[$i]}
-            S=${ALL//$t}
-            printf "left matches=%d\n" $((ALLSIZE-${#S}))
-            t=${T[$i]}
-            S=${ALL//$t}
-            printf "top matches=%d\n" $((ALLSIZE-${#S}))
-
             t=${B[$i]}
             S=${ALL//$t}
             # flip vertical if bottom is a corner side
-            printf "bottom matches=%d\n" $((ALLSIZE-${#S}))
             if (( ALLSIZE-${#S} == 10 )); then
-                echo FLIP_V
                 flip_v "$i"
             fi
-            print_tile "$i"; echo
             t=${R[$i]}
             S=${ALL//$t}
             # flip horizontal if right is a corner side
-            printf "right matches=%d\n" $((ALLSIZE-${#S}))
             if (( ALLSIZE-${#S} == 10 )); then
-                echo FLIP_H
                 flip_h "$i"
             fi
-            print_tile "$i"
             FINAL[0,0]="$i"
-            final+=("${nums[$i]}")
             final_add "$row" "$i"
             continue
         fi
@@ -163,7 +127,6 @@ for ((row=0; row<SQUARE; ++row)); do
                 list=("${CORNER[@]}")
             fi
             l=${FINAL[0,$((col-1))]}
-            #printf "FINAL[0,%d]=%d\n" "$((col-1))" "${FINAL[0,$((col-1))]}"
             right right "${strings[$l]}"
             index=0
             for j in "${list[@]}"; do
@@ -173,23 +136,15 @@ for ((row=0; row<SQUARE; ++row)); do
                 # 10 is line size
                 ((c = (LENGTH-${#S})/10))
                 if ((c > 0)); then
-                    echo "border tile match: idx=$index $j [${nums[$j]}]"
-                    print_tile "$j"
                     FINAL[$row,$col]="$j"
-                    final+=("${nums[$j]}")
-                    echo "c=$c"
                     attach_left "$right" "$j"
                     final_add "$row" "$j"
                     if ((col < SQUARE-1)); then
                         unset "EDGE[$index]"
                         EDGE=("${EDGE[@]}")
-                        printf "after removing EDGE $j\n"
-                        printf "EDGE[%d]=%s\n" "${#EDGE[@]}" "${EDGE[*]}"
                     else
                         unset "CORNER[$index]"
                         CORNER=("${CORNER[@]}")
-                        printf "after removing CORNER $j\n"
-                        printf "CORNER[%d]=%s\n" "${#CORNER[@]}" "${CORNER[*]}"
                     fi
                     found=1
                     break
@@ -197,7 +152,6 @@ for ((row=0; row<SQUARE; ++row)); do
                 ((index++))
             done
             if ((found==0)); then
-                printf "NOT FOUND\n"
                 exit 0
             fi
             continue
@@ -210,25 +164,16 @@ for ((row=0; row<SQUARE; ++row)); do
                 list=("${CORNER[@]}")
             fi
             l=${FINAL[$((row-1)),$col]}
-            printf "FINAL[%d,%d]=%d\n" "$((row-1))" "$col" "$l"
-            printf "UPPER TILE"
-            print_tile "$j"
             bottom bottom "${strings[$l]}"
-            printf "UPPER bottom line: %s\n" "$bottom"
             index=0
             for j in "${list[@]}"; do
-                printf "looking for tile %d [%d]\n" "$j" "${nums[$j]}"
                 SIDES="${T[$j]} ${R[$j]} ${B[$j]} ${L[$j]} ${RT[$j]} ${RR[$j]} ${RB[$j]} ${RL[$j]}"
                 LENGTH=${#SIDES}
                 S=${SIDES//$bottom}
                 # 10 is line size
                 ((c = (LENGTH-${#S})/10))
                 if ((c > 0)); then
-                    echo "border tile match: ${nums[$j]}"
-                    print_tile "$j"
                     FINAL[$row,$col]="$j"
-                    final+=("${nums[$j]}")
-                    echo "c=$c"
                     attach_top "$bottom" "$j"
                     final_add "$row" "$j"
                     if ((row < SQUARE-1)); then
@@ -244,7 +189,6 @@ for ((row=0; row<SQUARE; ++row)); do
                 ((index++))
             done
             if ((found==0)); then
-                printf "NOT FOUND\n"
                 exit 0
             fi
             continue
@@ -252,7 +196,6 @@ for ((row=0; row<SQUARE; ++row)); do
         ################################## rest of last row
         if ((row == SQUARE-1)); then
             l=${FINAL[$((row-1)),$col]}
-            printf "FINAL[%d,%d]=%d\n" "$((row-1))" "$col" "${FINAL[$((row-1)),$col]}"
             bottom bottom "${strings[$l]}"
             index=0
             for j in "${EDGE[@]}"; do
@@ -262,11 +205,7 @@ for ((row=0; row<SQUARE; ++row)); do
                 # 10 is line size
                 ((c = (LENGTH-${#S})/10))
                 if ((c > 0)); then
-                    echo "border tile match: ${nums[$j]}"
-                    print_tile "$j"
                     FINAL[$row,$col]="$j"
-                    final+=("${nums[$j]}")
-                    echo "c=$c"
                     attach_top "$bottom" "$j"
                     final_add "$row" "$j"
                     unset "EDGE[$index]"
@@ -277,14 +216,12 @@ for ((row=0; row<SQUARE; ++row)); do
                 ((index++))
             done
             if ((found==0)); then
-                printf "NOT FOUND\n"
                 exit 0
             fi
             continue
         fi
         ################################## central tiles
         l=${FINAL[$((row-1)),$col]}
-        printf "FINAL[%d,%d]=%d\n" "$((col-1))" "${FINAL[$,$((col-1))]}"
         bottom bottom "${strings[$l]}"
         index=0
         for j in "${CENTRAL[@]}"; do
@@ -294,11 +231,7 @@ for ((row=0; row<SQUARE; ++row)); do
             # 10 is line size
             ((c = (LENGTH-${#S})/10))
             if ((c > 0)); then
-                echo "border tile match: ${nums[$j]}"
-                print_tile "$j"
                 FINAL[$row,$col]="$j"
-                final+=("${nums[$j]}")
-                echo "c=$c"
                 attach_top "$bottom" "$j"
                 final_add "$row" "$j"
                 unset "CENTRAL[$index]"
@@ -309,25 +242,12 @@ for ((row=0; row<SQUARE; ++row)); do
             ((index++))
         done
         if ((found==0)); then
-            printf "NOT FOUND\n"
             exit 0
         fi
         continue
     done
 done
 
-for ((r=0; r<SQUARE; ++r)); do
-    for ((c=0; c<SQUARE; ++c)); do
-        k=${FINAL[$r,$c]}
-        printf "%6d" "${nums[$k]}"
-    done
-    printf "\n"
-done
-
-print_final
-trim_borders
-print_final
-
 # dragon:
 #    01234567890123456789
 # 0                    #
@@ -336,18 +256,15 @@ print_final
 find_dragons() {
     local drag l1 l2 l3
     local -i found=0 r c len
-    printf "square=%d\n" "$SQUARE"
+    len=${#final[@]}
-    len=${#finalfoo[@]}
     for ((r=0; r<len-2; ++r)); do
-        l1=${finalfoo[$r]}
+        l1=${final[$r]}
-        l2=${finalfoo[$((r+1))]}
+        l2=${final[$((r+1))]}
-        l3=${finalfoo[$((r+2))]}
+        l3=${final[$((r+2))]}
         for ((c=0; c<len-20; ++c)); do
             drag=${l1:$c+18:1}${l2:$c:1}${l2:$c+5:2}${l2:$c+11:2}${l2:$c+17:3}
             drag+=${l3:$c+1:1}${l3:$c+4:1}${l3:$c+7:1}${l3:$c+10:1}${l3:$c+13:1}${l3:$c+16:1}
-            printf "dragon=%s len=%d\n" "$drag" "${#drag}"
             if [[ "$drag" == '###############' ]]; then
-                printf "found dragon at (%d,%d)\n" "$r" "$c"
                 ((found++))
             fi
         done
@@ -355,240 +272,29 @@ find_dragons() {
     return $found
 }
 
-printf "\n"
-for k in "${!finalfoo[@]}"; do
-    printf "%s\n" "${finalfoo[$k]}"
-done
 for ((i=0; i<4; ++i)); do
     find_dragons
     found=$?
     ((found>0)) && break
 
     fliph_final
-    printf "FLIPH_DRAG\n"
-    for k in "${!finalfoo[@]}"; do
-        printf "%s\n" "${finalfoo[$k]}"
-    done
     find_dragons
     found=$?
     ((found>0)) && break
     fliph_final
 
     flipv_final
-    printf "FLIPV_DRAG\n"
-    for k in "${!finalfoo[@]}"; do
-        printf "%s\n" "${finalfoo[$k]}"
-    done
     find_dragons
     found=$?
     ((found>0)) && break
     flipv_final
 
     rotate_final
-    printf "ROTATE_DRAG\n"
-    for k in "${!finalfoo[@]}"; do
-        printf "%s\n" "${finalfoo[$k]}"
-    done
 done
 
-fullstr="${finalfoo[*]}"
+fullstr="${final[*]}"
 fullstr="${fullstr//[. ]}"
 sharp=${#fullstr}
-printf "found=%d \n" $((sharp - found*15))
+printf "%s res=%d \n" "$CMD" $((sharp - found*15))
 
 exit 0
-
-
-
-
-
-
-
-
-
-
-
-###################################################### testing
-# printf "corner[0]=%d\n" "${nums[$i]}"
-# printf "origin:\n"
-# print_tile "$i"
-# flip_h "$i"
-# printf "horizontal flip:\n"
-# print_tile "$i"
-# flip_h "$i"
-# flip_v "$i"
-# printf "vertical flip:\n"
-# print_tile "$i"
-# flip_v "$i"
-# printf "origin:\n"
-# print_tile "$i"
-# r90 "$i"
-# printf "r90:\n"
-# print_tile "$i"
-
-# #for i in "${CORNER[@]}"; do
-# t=${T[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "T  %s: %d\n" "$t" "$count"
-# t=${R[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "R  %s: %d\n" "$t" "$count"
-# t=${B[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "B  %s: %d\n" "$t" "$count"
-# t=${L[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "L  %s: %d\n" "$t" "$count"
-
-# t=${RT[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "RT %s: %d\n" "$t" "$count"
-# t=${RR[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "RR %s: %d\n" "$t" "$count"
-# t=${RB[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "RB %s: %d\n" "$t" "$count"
-# t=${RL[$i]}; S=${ALL//$t}; ((count=(ALLSIZE-${#S})/10))
-# printf "RL %s: %d\n" "$t" "$count"
-
-# exit 0
-# for t in ${T[$i]} ${R[$i]} ${B[$i]} ${L[$i]} \
-    #                   ${RT[$i]} ${RR[$i]} ${RB[$i]} ${RL[$i]}; do
-#     S=${ALL//$t}
-#     ((count=(ALLSIZE-${#S})/10))
-#     printf "%s: %d\n" "$t" "$count"
-# done
-# echo
-
-# exit 0
-# r90 "$i"
-# printf "r90:\n"
-# print_tile "$i"
-# r90 "$i"
-# r90 "$i"
-# r90 "$i"
-# printf "origin:\n"
-# print_tile "$i"
-
-# r180 "$i"
-# printf "r180:\n"
-# print_tile "$i"
-# r180 "$i"
-# printf "origin:\n"
-# print_tile "$i"
-
-# r270 "$i"
-# printf "r270:\n"
-# print_tile "$i"
-# r90 "$i"
-# printf "origin:\n"
-# print_tile "$i"
-
-#test start
-# key=1
-# str=(${strings[$key]})
-# top1="${str[0]}"
-# bottom1="${str[9]}"
-# declare top bottom left right
-# unset left1 right1
-# for ((i=0; i<10; ++i)); do
-#     left1+=${str[$i]:0:1}
-#     right1+=${str[$i]: -1:1}
-# done
-# top top ${str[@]}
-# bottom bottom ${str[@]}
-# right right ${str[@]}
-# left left ${str[@]}
-# print_tile 1
-# printf "T=%s\n" "$top1"
-# printf "T=%s\n" "$top"
-# echo
-# printf "R=%s\n" "$right1"
-# printf "R=%s\n" "$right"
-# echo
-# printf "B=%s\n" "$bottom1"
-# printf "B=%s\n" "$bottom"
-# echo
-# printf "L=%s\n" "$left1"
-# printf "L=%s\n" "$left"
-# echo
-
-# for ((i=9; i>=0; --i)); do
-#     fliptop1+=${top:$i:1}
-#     flipbottom1+=${bottom:$i:1}
-# done
-# flip fliptop $top
-# flip flibottom $bottom
-# printf "T=%s\n" "$fliptop1"
-# printf "T=%s\n" "$fliptop"
-# echo
-
-# exit 0
-#test end
-
-# printf "RIGHT=%s\n" "$right"
-# # find next tile
-# for j in "${EDGE[@]}"; do
-#     SIDES="${T[$j]} ${R[$j]} ${B[$j]} ${L[$j]} ${RT[$j]} ${RR[$j]} ${RB[$j]} ${RL[$j]}"
-#     LENGTH=${#SIDES}
-#     S=${SIDES//$right}
-#     # 10 is line size
-#     ((c = (LENGTH-${#S})/10))
-#     if ((c > 0)); then
-#         echo "border tile match: ${nums[$j]}"
-#         print_tile "$j"
-#         final+=("${nums[$j]}")
-#         echo "c=$c"
-#         attach_left "$right" "$j"
-#         unset "EDGE[$j]"
-#         EDGE=("${EDGE[@]}")
-#         break
-#     fi
-# done
-
-# echo after done
-# print_tile "$j"
-# right right "${strings[$j]}"
-# printf "RIGHT=%s\n" "$right"
-# # find next tile
-# for j in "${CORNER[@]}"; do
-#     SIDES="${T[$j]} ${R[$j]} ${B[$j]} ${L[$j]} ${RT[$j]} ${RR[$j]} ${RB[$j]} ${RL[$j]}"
-#     LENGTH=${#SIDES}
-#     S=${SIDES//$right}
-#     # 10 is line size
-#     ((c = (LENGTH-${#S})/10))
-#     if ((c > 0)); then
-#         echo "corner tile match: ${nums[$j]}"
-#         final+=("${nums[$j]}")
-#         print_tile "$j"
-#         echo "c=$c"
-#         attach_left "$right" "$j"
-#         unset "CORNER[$j]"
-#         CORNER=("${CORNER[@]}")
-#         break
-#     fi
-# done
-
-
-
-# exit 0
-i=${CORNER[0]}
-printf "corner=%d=%d\n" "$i" "${nums[$i]}"
-printf "origin:\n"
-print_tile "$i"
-flip_h "$i"
-printf "horizontal flip:\n"
-print_tile "$i"
-flip_h "$i"
-flip_v "$i"
-printf "vertical flip:\n"
-print_tile "$i"
-flip_v "$i"
-printf "origin:\n"
-print_tile "$i"
-
-declare l="" r=""
-right r "${strings[$i]}"
-printf "right=%s\n" "$r"
-printf "origin:\n"
-print_tile "$i"
-r=""; l=""
-left l "${strings[$i]}"
-printf "left =%s\n" "$l"
-printf "origin:\n"
-print_tile "$i"
-echo ZOBI

2020/day20/tile.bash

@@ -1,78 +1,28 @@
 #!/usr/bin/bash
 
-print_tile() {
-    local -i t=$1
-    # shellcheck disable=SC2206
-    local -a src=(${strings[$t]})
-    printf "%s\n" "${src[@]}"
-}
-
-print_final() {
-    local k str
-    local -i l len r c
-    local -a tile
-    str=${strings[0]%% *}
-    len=${#str}
-    printf "print_final: len=%d\n" "$len"
-    for ((r=0; r<SQUARE; ++r)); do
-        for ((l=0; l<len; ++l)); do # each line
-            for ((c=0; c<SQUARE; ++c)); do
-                k=${FINAL[$r,$c]}
-                # shellcheck disable=SC2206
-                tile=(${strings[$k]})
-                str=${tile[$l]}
-                printf "%s " "$str"
-            done
-            printf "\n"
-        done
-        printf "\n"
-    done
-}
-
-assemble_final() {
-    local k str
-    local -i l len r c
-    local -a tile
-    str=${strings[0]%% *}
-    len=${#str}
-    for ((r=0; r<SQUARE; ++r)); do
-        for ((l=0; l<len; ++l)); do # each line
-            for ((c=0; c<SQUARE; ++c)); do
-                k=${FINAL[$r,$c]}
-                # shellcheck disable=SC2206
-                tile=(${strings[$k]})
-                str=${tile[$l]}
-                printf "%s " "$str"
-            done
-            printf "\n"
-        done
-        printf "\n"
-    done
-}
 rotate_final() {
     local -i i j len
     local -a new
     local line
-    len=${#finalfoo[@]}
+    len=${#final[@]}
-    printf "rotate foo. len=%d\n" "$len"
     for ((i=len-1; i>=0; --i)); do
-        line=${finalfoo[$i]}
+        line=${final[$i]}
         for ((j=0; j<len; ++j)); do
             new[$j]+=${line:$j:1}
         done
         #dst+=("$str2")
     done
-    finalfoo=("${new[@]}")
+    final=("${new[@]}")
 }
 
 flipv_final() {
     local -i i len
     local -a dst
-    len=${#finalfoo[@]}
+    len=${#final[@]}
     for ((i=0; i<len; ++i)); do
-        dst[$((len-1-i))]=${finalfoo[$i]}
+        dst[$((len-1-i))]=${final[$i]}
     done
-    finalfoo=("${dst[@]}")
+    final=("${dst[@]}")
 }
 
 fliph_final() {
@@ -81,16 +31,16 @@ fliph_final() {
     local -a dst
     local str1 str2
 
-    len=${#finalfoo[@]}
+    len=${#final[@]}
     for ((i=0; i<len; ++i)); do
-        str1=${finalfoo[$i]}
+        str1=${final[$i]}
         str2=""
         for ((j=len-1; j>=0; --j)); do
             str2+=${str1:$j:1}
         done
         dst+=("$str2")
     done
-    finalfoo=("${dst[@]}")
+    final=("${dst[@]}")
 }
 
 final_add() {
@@ -99,10 +49,7 @@ final_add() {
     local -a src=(${strings[$2]})
 
     for ((r=1, t=$((start*8)); r<9; ++r, t++)); do
-        printf "adding tile %d row %d to final %d\n" "$2" "$r" "$t"
+        final[$t]+=${src[$r]:1:8}
-        printf "  %s -> " "${finalfoo[$t]}"
-        finalfoo[$t]+=${src[$r]:1:8}
-        printf "%s\n" "${finalfoo[$t]}"
     done
 }
 
@@ -116,7 +63,6 @@ trim_borders() {
         s=${s#* }
         s=${s% * }
         strings[$k]="$s"
-        #printf "%s\n" "${strings[$k]}"
     done
 }
 
@@ -235,73 +181,46 @@ flip() {
         _r+=${str:$i:1}
     done
 }
-print_all_borders() {
-    local k str
-    local -i i
-    for ((i=0; i<${#strings[@]}; ++i)); do
-        top str "${strings[$i]}"
-        printf "%s\n" "$str"
-        right str "${strings[$i]}"
-        printf "%s\n" "$str"
-        bottom str "${strings[$i]}"
-        printf "%s\n" "$str"
-        left str "${strings[$i]}"
-        printf "%s\n" "$str"
-    done
-}
 # transform $2 tile to match $1 on left
 attach_left() {
     local _l="$1"
     local -i t="$2" m=0
     local s
-    printf "matching left %s for tile:\n" "$_l"
+
-    print_tile "$t"
     for s in ${T[$t]} ${R[$t]} ${B[$t]} ${L[$t]} \
                       ${RT[$t]} ${RR[$t]} ${RB[$t]} ${RL[$t]}; do
-        printf "%d: %s\n" "$m" "$s"
         if [[ "$s" == "$_l" ]]; then
-            echo "attach_left: count=$m"
             break
         fi
         ((m++))
     done
     case $m in
         0)                                        # top
-            printf "match=top\n"
             r270 "$t"
             flip_v "$t"
             ;;
         1)                                        # right
-            printf "match=right\n"
             flip_h "$t"
             ;;
         2)                                        # bottom
-            printf "match=bottom\n"
             r90 "$t"
             ;;
         3)                                        # left
-            printf "match=left\n"
             ;;
         4)                                        # rev top
-            printf "match=rev top\n"
             r270 "$t"
             ;;
         5)                                        # rev right
-            printf "match=rev right\n"
             r180 "$t"
             ;;
         6)                                        # rev bottom
-            printf "match=rev bottom\n"
             r90 "$t"
             flip_v "$t"
             ;;
         7)                                        # rev left
-            printf "match=rev left\n"
             flip_v "$t"
             ;;
     esac
-    echo new orientation:
-    print_tile "$t"
 }
 
 # transform $2 tile to match $1 on left
@@ -309,52 +228,39 @@ attach_top() {
     local _l="$1"
     local -i t="$2" m=0
     local s
-    printf "matching top %s for tile:\n" "$_l"
+
-    print_tile "$t"
     for s in ${T[$t]} ${R[$t]} ${B[$t]} ${L[$t]} \
                       ${RT[$t]} ${RR[$t]} ${RB[$t]} ${RL[$t]}; do
-        printf "%d: %s\n" "$m" "$s"
         if [[ "$s" == "$_l" ]]; then
-            echo "attach_top: count=$m"
             break
         fi
         ((m++))
     done
     case $m in
         0)                                        # top
-            printf "match=top\n"
             ;;
         1)                                        # right
-            printf "match=right\n"
             r270 "$t"
             ;;
         2)                                        # bottom
-            printf "match=bottom\n"
             flip_v "$t"
             ;;
         3)                                        # left
-            printf "match=left\n"
             r90 "$t"
             flip_h "$t"
             ;;
         4)                                        # rev top
-            printf "match=rev top\n"
             flip_h "$t"
             ;;
         5)                                        # rev right
-            printf "match=rev right\n"
             r270 "$t"
             flip_h "$t"
             ;;
         6)                                        # rev bottom
-            printf "match=rev bottom\n"
             r180 "$t"
             ;;
         7)                                        # rev left
-            printf "match=rev left\n"
             r90 "$t"
             ;;
     esac
-    echo new orientation:
-    print_tile "$t"
 }