From 9650cea992017f93b87faa6c05cd14f3222c5ee8 Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Fri, 6 Dec 2024 09:23:38 -0500
Subject: [PATCH 1/8] day 6, part 1

---
 package.json     |  2 +-
 public/funs.js   | 55 +++++++++++++++++++++++++++++++++++++++++++++++-
 views/index.html |  2 +-
 3 files changed, 56 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index c70fd20..f441f6b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "meowing-holy-carbon",
-  "version": "2024.12.05",
+  "version": "2024.12.06",
   "description": "Travis's Advent of Code 2024",
   "author": "Travis Hardiman",
   "homepage": "https://github.com/dieseltravis/aoc2024/",
diff --git a/public/funs.js b/public/funs.js
index 2195eb8..1af4638 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -344,7 +344,60 @@
       }
     },
     day6: {
-      part1: d => d,
+      part1: (data) => {
+        const guard = {
+          '^': { dy: -1, dx: 0 },
+          '>': { dy: 0, dx: 1 },
+          v: { dy: 1, dx: 0 },
+          '<': { dy: 0, dx: -1 }
+        };
+        const dirs = Object.keys(guard);
+        let guardpos = { y: -1, x: -1 };
+        let guardchar = 'x';
+        let guardrotation = -1;
+        const input = data.trim().split('\n').map((r, y) => {
+          const row = r.split('');
+          const found = row.findIndex(c => dirs.includes(c));
+          if (found >= 0) {
+            guardpos = { y, x: found };
+            guardchar = row[found];
+            guardrotation = dirs.indexOf(guardchar);
+          }
+          return row;
+        });
+        const ymax = input.length;
+        const xmax = input[0].length;
+        const inRange = p => p.y >= 0 && p.y < ymax && p.x >= 0 && p.x < xmax;
+
+        console.log(dirs, guardpos, guardchar, guardrotation, ymax, xmax, input);
+        let safety = 10000;
+        let steps = 0;
+        while (safety--) {
+          input[guardpos.y][guardpos.x] = 'X';
+          let change = guard[guardchar];
+          let nextpos = { y: guardpos.y + change.dy, x: guardpos.x + change.dx };
+          let safety2 = 5;
+          if (!inRange(nextpos)) {
+            break;
+          }
+          while (input[nextpos.y][nextpos.x] === '#' && safety2--) {
+            // rotate right
+            guardrotation = (guardrotation + 1) % 4;
+            guardchar = dirs[guardrotation];
+            change = guard[guardchar];
+            nextpos = { y: guardpos.y + change.dy, x: guardpos.x + change.dx };
+            if (!inRange(nextpos)) {
+              break;
+            }
+          }
+          guardpos = nextpos;
+          steps++;
+        }
+        const grid = input.map(r => r.join('')).join('\n');
+        const count = grid.match(/X/g).length;
+        console.log(safety, steps, '\n' + grid, count);
+        return count;
+      },
       part2: d => d
     },
     day7: {
diff --git a/views/index.html b/views/index.html
index 9765750..40b870c 100644
--- a/views/index.html
+++ b/views/index.html
@@ -25,8 +25,8 @@ <h2>solutions:</h2>
         <li><a href="/day/03">day 03</a></li>
         <li><a href="/day/04">day 04</a></li>
         <li><a href="/day/05">day 05</a></li>
-        <!-- 
         <li><a href="/day/06">day 06</a></li>
+        <!-- 
         <li><a href="/day/07">day 07</a></li>
         <li><a href="/day/08">day 08</a></li>
         <li><a href="/day/09">day 09</a></li>

From 65b7b6b1e68ef34d27f05be09d08807f3fb90adb Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sat, 7 Dec 2024 00:04:42 -0500
Subject: [PATCH 2/8] day 6, part 2 incomplete

---
 public/funs.js | 72 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 71 insertions(+), 1 deletion(-)

diff --git a/public/funs.js b/public/funs.js
index 1af4638..2b847d0 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -398,7 +398,77 @@
         console.log(safety, steps, '\n' + grid, count);
         return count;
       },
-      part2: d => d
+      part2: (data) => {
+        const guard = {
+          '^': { dy: -1, dx: 0 },
+          '>': { dy: 0, dx: 1 },
+          v: { dy: 1, dx: 0 },
+          '<': { dy: 0, dx: -1 }
+        };
+        const dirs = Object.keys(guard);
+        let guardpos = { y: -1, x: -1 };
+        let guardchar = 'x';
+        let guardrotation = -1;
+        const input = data.trim().split('\n').map((r, y) => {
+          const row = r.split('');
+          const found = row.findIndex(c => dirs.includes(c));
+          if (found >= 0) {
+            guardpos = { y, x: found };
+            guardchar = row[found];
+            guardrotation = dirs.indexOf(guardchar);
+          }
+          return row;
+        });
+        const ymax = input.length;
+        const xmax = input[0].length;
+        const inRange = p => p.y >= 0 && p.y < ymax && p.x >= 0 && p.x < xmax;
+
+        console.log(dirs, guardpos, guardchar, guardrotation, ymax, xmax, input);
+        let safety = 10000;
+        let steps = 0;
+        let count = 0;
+        while (safety--) {
+          // console.log(guardpos.y, guardpos.x, guardchar);
+          input[guardpos.y][guardpos.x] = guardchar;
+          let change = guard[guardchar];
+          let nextpos = { y: guardpos.y + change.dy, x: guardpos.x + change.dx };
+          let safety2 = 5;
+          if (!inRange(nextpos)) {
+            break;
+          }
+          while (input[nextpos.y][nextpos.x] === '#' && safety2--) {
+            // rotate right
+            guardrotation = (guardrotation + 1) % 4;
+            guardchar = dirs[guardrotation];
+            change = guard[guardchar];
+            nextpos = { y: guardpos.y + change.dy, x: guardpos.x + change.dx };
+            if (!inRange(nextpos)) {
+              break;
+            }
+          }
+          // look right for repeating
+          const lookrrotate = (guardrotation + 1) % 4;
+          const lookrchar = dirs[lookrrotate];
+          // const oppositechar = dirs[(guardrotation + 3) % 4];
+          const lookrchange = guard[lookrchar];
+          let lookrpos = { y: guardpos.y + lookrchange.dy, x: guardpos.x + lookrchange.dx };
+          let safety3 = 1000;
+          while (safety3-- && inRange(lookrpos) && input[lookrpos.y][lookrpos.x] !== '#') {
+            // TODO: continue bouncing off of obsticles and looking for loop
+            if (input[lookrpos.y][lookrpos.x] === lookrchar) {
+              count++;
+              break;
+            }
+            lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
+          }
+          guardpos = nextpos;
+          steps++;
+        }
+        const grid = input.map(r => r.join('')).join('\n');
+        console.log(safety, steps, '\n' + grid, count);
+        // 508 too low
+        return count;
+      }
     },
     day7: {
       part1: d => d,

From 60de13f3fd59de4a31477e27d2e220a6c0859eaf Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sat, 7 Dec 2024 01:59:51 -0500
Subject: [PATCH 3/8] day 6, part 2: progress but still too low

---
 public/funs.js | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/public/funs.js b/public/funs.js
index 2b847d0..4ba8492 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -447,18 +447,23 @@
             }
           }
           // look right for repeating
-          const lookrrotate = (guardrotation + 1) % 4;
-          const lookrchar = dirs[lookrrotate];
-          // const oppositechar = dirs[(guardrotation + 3) % 4];
-          const lookrchange = guard[lookrchar];
+          let lookrrotate = (guardrotation + 1) % 4;
+          let lookrchar = dirs[lookrrotate];
+          let lookrchange = guard[lookrchar];
           let lookrpos = { y: guardpos.y + lookrchange.dy, x: guardpos.x + lookrchange.dx };
           let safety3 = 1000;
-          while (safety3-- && inRange(lookrpos) && input[lookrpos.y][lookrpos.x] !== '#') {
-            // TODO: continue bouncing off of obsticles and looking for loop
+          while (safety3-- && inRange(lookrpos)) {
             if (input[lookrpos.y][lookrpos.x] === lookrchar) {
               count++;
               break;
             }
+            // TODO: continue bouncing off of obsticles and looking for loop
+            let safety4 = 5;
+            while (input[lookrpos.y][lookrpos.x] === '#' && safety4--) {
+              lookrrotate = (lookrrotate + 1) % 4;
+              lookrchar = dirs[lookrrotate];
+              lookrchange = guard[lookrchar];
+            }
             lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
           }
           guardpos = nextpos;
@@ -467,6 +472,7 @@
         const grid = input.map(r => r.join('')).join('\n');
         console.log(safety, steps, '\n' + grid, count);
         // 508 too low
+        // 1631 too low
         return count;
       }
     },

From f833108095629288be3dba3c1d426c59876a7e4e Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sat, 7 Dec 2024 17:45:16 -0500
Subject: [PATCH 4/8] day 6, part 2: about to refactor this

---
 public/funs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/public/funs.js b/public/funs.js
index 4ba8492..e663255 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -457,7 +457,7 @@
               count++;
               break;
             }
-            // TODO: continue bouncing off of obsticles and looking for loop
+            // continue bouncing off of obstacles and looking for loop
             let safety4 = 5;
             while (input[lookrpos.y][lookrpos.x] === '#' && safety4--) {
               lookrrotate = (lookrrotate + 1) % 4;

From bcceebe0302cc80669a02f9364d70d6ef460ba55 Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sat, 7 Dec 2024 21:43:42 -0500
Subject: [PATCH 5/8] day 6, part 2: refactoring...

---
 public/funs.js | 38 ++++++++++++++++++++++++++++----------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/public/funs.js b/public/funs.js
index e663255..b1f120e 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -426,6 +426,7 @@
         console.log(dirs, guardpos, guardchar, guardrotation, ymax, xmax, input);
         let safety = 10000;
         let steps = 0;
+        const route = [];
         let count = 0;
         while (safety--) {
           // console.log(guardpos.y, guardpos.x, guardchar);
@@ -446,29 +447,46 @@
               break;
             }
           }
+          
+          guardpos = nextpos;
+          route.push({
+            char: guardchar,
+            y: guardpos.y,
+            x: guardpos.x
+          });
+          steps++;
+        }
+        console.log(route);
+
+        const rlen = route.length;
+        for (let i = 0; i < rlen; i++)
+        {
+          const point = route[i];
+          guardpos = { y: point.y, x: point.x };
+          guardchar = point.char;
+          guardrotation = dirs.indexOf(guardchar);
           // look right for repeating
           let lookrrotate = (guardrotation + 1) % 4;
           let lookrchar = dirs[lookrrotate];
           let lookrchange = guard[lookrchar];
           let lookrpos = { y: guardpos.y + lookrchange.dy, x: guardpos.x + lookrchange.dx };
-          let safety3 = 1000;
-          while (safety3-- && inRange(lookrpos)) {
+          let safety5 = 1000;
+          while (safety5-- && inRange(lookrpos)) {
             if (input[lookrpos.y][lookrpos.x] === lookrchar) {
               count++;
               break;
             }
             // continue bouncing off of obstacles and looking for loop
-            let safety4 = 5;
-            while (input[lookrpos.y][lookrpos.x] === '#' && safety4--) {
-              lookrrotate = (lookrrotate + 1) % 4;
-              lookrchar = dirs[lookrrotate];
-              lookrchange = guard[lookrchar];
-            }
+            //let safety6 = 5;
+            //while (input[lookrpos.y][lookrpos.x] === '#' && safety6--) {
+            //  lookrrotate = (lookrrotate + 1) % 4;
+            //  lookrchar = dirs[lookrrotate];
+             // lookrchange = guard[lookrchar];
+            //}
             lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
           }
-          guardpos = nextpos;
-          steps++;
         }
+
         const grid = input.map(r => r.join('')).join('\n');
         console.log(safety, steps, '\n' + grid, count);
         // 508 too low

From 033292eb67d8de7a40ce5c006170cc0ee9b589d3 Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sat, 7 Dec 2024 21:55:50 -0500
Subject: [PATCH 6/8] day 6, part 2: still broken...

---
 public/funs.js | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/public/funs.js b/public/funs.js
index b98ac3b..e60e033 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -447,7 +447,7 @@
               break;
             }
           }
-          
+
           guardpos = nextpos;
           route.push({
             char: guardchar,
@@ -459,8 +459,7 @@
         console.log(route);
 
         const rlen = route.length;
-        for (let i = 0; i < rlen; i++)
-        {
+        for (let i = 0; i < rlen; i++) {
           const point = route[i];
           guardpos = { y: point.y, x: point.x };
           guardchar = point.char;
@@ -476,13 +475,13 @@
               count++;
               break;
             }
-            // continue bouncing off of obstacles and looking for loop
-            //let safety6 = 5;
-            //while (input[lookrpos.y][lookrpos.x] === '#' && safety6--) {
-            //  lookrrotate = (lookrrotate + 1) % 4;
-            //  lookrchar = dirs[lookrrotate];
-             // lookrchange = guard[lookrchar];
-            //}
+            // continue bouncing off of obstacles and looking for loop?
+            let safety6 = 5;
+            while (input[lookrpos.y][lookrpos.x] === '#' && safety6--) {
+              lookrrotate = (lookrrotate + 1) % 4;
+              lookrchar = dirs[lookrrotate];
+              lookrchange = guard[lookrchar];
+            }
             lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
           }
         }

From ad47f1d2c070733f4253ecb1118617f3aa7ea30e Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sun, 8 Dec 2024 01:01:06 -0500
Subject: [PATCH 7/8] day 6, part 2: still broken....

---
 public/funs.js | 68 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 49 insertions(+), 19 deletions(-)

diff --git a/public/funs.js b/public/funs.js
index e60e033..cc39ebf 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -448,9 +448,31 @@
             }
           }
 
+          // look right for repeating
+          let lookrrotate = (guardrotation + 1) % 4;
+          let lookrchar = dirs[lookrrotate];
+          let lookrchange = guard[lookrchar];
+          let lookrpos = { y: guardpos.y + lookrchange.dy, x: guardpos.x + lookrchange.dx };
+          let safety3 = 1000;
+          while (safety3-- && inRange(lookrpos)) {
+            if (route.some(p => p.y === lookrpos.y && p.x === lookrpos.x && p.char === lookrchar)) {
+              count++;
+              break;
+            }
+            // TODO: continue bouncing off of obstacles and looking for loop
+            let safety4 = 5;
+            while (input[lookrpos.y][lookrpos.x] === '#' && safety4--) {
+              lookrrotate = (lookrrotate + 1) % 4;
+              lookrchar = dirs[lookrrotate];
+              lookrchange = guard[lookrchar];
+            }
+            lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
+          }
+
           guardpos = nextpos;
           route.push({
             char: guardchar,
+            rot: dirs.indexOf(guardchar),
             y: guardpos.y,
             x: guardpos.x
           });
@@ -458,38 +480,46 @@
         }
         console.log(route);
 
+        /*
         const rlen = route.length;
-        for (let i = 0; i < rlen; i++) {
+        for (let i = 1; i < rlen; i++) {
           const point = route[i];
-          guardpos = { y: point.y, x: point.x };
-          guardchar = point.char;
-          guardrotation = dirs.indexOf(guardchar);
           // look right for repeating
-          let lookrrotate = (guardrotation + 1) % 4;
+          let lookrrotate = (point.rot + 1) % 4;
           let lookrchar = dirs[lookrrotate];
           let lookrchange = guard[lookrchar];
-          let lookrpos = { y: guardpos.y + lookrchange.dy, x: guardpos.x + lookrchange.dx };
-          let safety5 = 1000;
-          while (safety5-- && inRange(lookrpos)) {
-            if (input[lookrpos.y][lookrpos.x] === lookrchar) {
-              count++;
-              break;
-            }
-            // continue bouncing off of obstacles and looking for loop?
-            let safety6 = 5;
-            while (input[lookrpos.y][lookrpos.x] === '#' && safety6--) {
-              lookrrotate = (lookrrotate + 1) % 4;
-              lookrchar = dirs[lookrrotate];
-              lookrchange = guard[lookrchar];
+          let lookrpos = { y: point.y + lookrchange.dy, x: point.x + lookrchange.dx };
+          if (inRange(lookrpos)) {
+            const dd = guard[point.char];
+            const o = { y: point.y + dd.dy, x: point.x + dd.dx };
+            if (inRange(o) && input[o.y][o.x] !== '#') {
+              let safety5 = 10000;
+              while (safety5-- && inRange(lookrpos)) {
+                // if (input[lookrpos.y][lookrpos.x] === lookrchar) {
+                if (route.some(p => p.y === lookrpos.y && p.x === lookrpos.x && p.char === lookrchar)) {
+                  input[o.y][o.x] = 'O';
+                  count++;
+                  break;
+                }
+                // continue bouncing off of obstacles and looking for loop?
+                let safety6 = 5;
+                while (input[lookrpos.y][lookrpos.x] === '#' && safety6--) {
+                  lookrrotate = (lookrrotate + 1) % 4;
+                  lookrchar = dirs[lookrrotate];
+                  lookrchange = guard[lookrchar];
+                }
+                lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
+              }
             }
-            lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
           }
         }
+        */
 
         const grid = input.map(r => r.join('')).join('\n');
         console.log(safety, steps, '\n' + grid, count);
         // 508 too low
         // 1631 too low
+        // 1632 too low
         return count;
       }
     },

From da3bbbf64e4e599d2f4902794f425babd1799dba Mon Sep 17 00:00:00 2001
From: Travis Hardiman <dieseltravis@users.noreply.github.com>
Date: Sun, 8 Dec 2024 20:50:37 -0500
Subject: [PATCH 8/8] day 6, part 2: less broken...?

---
 public/funs.js | 57 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 19 deletions(-)

diff --git a/public/funs.js b/public/funs.js
index 9438660..bd461a9 100644
--- a/public/funs.js
+++ b/public/funs.js
@@ -428,6 +428,7 @@
         let steps = 0;
         const route = [];
         let count = 0;
+        const blocks = [];
         while (safety--) {
           // console.log(guardpos.y, guardpos.x, guardchar);
           input[guardpos.y][guardpos.x] = guardchar;
@@ -448,34 +449,51 @@
             }
           }
 
+          guardpos = nextpos;
+          route.push({
+            char: guardchar,
+            rot: dirs.indexOf(guardchar),
+            y: guardpos.y,
+            x: guardpos.x
+          });
+
           // look right for repeating
+          const lookloop = [];
           let lookrrotate = (guardrotation + 1) % 4;
           let lookrchar = dirs[lookrrotate];
           let lookrchange = guard[lookrchar];
-          let lookrpos = { y: guardpos.y + lookrchange.dy, x: guardpos.x + lookrchange.dx };
-          let safety3 = 1000;
-          while (safety3-- && inRange(lookrpos)) {
-            if (route.some(p => p.y === lookrpos.y && p.x === lookrpos.x && p.char === lookrchar)) {
-              count++;
-              break;
-            }
-            // TODO: continue bouncing off of obstacles and looking for loop
-            let safety4 = 5;
-            while (input[lookrpos.y][lookrpos.x] === '#' && safety4--) {
+          let lookrpos = { y: guardpos.y, x: guardpos.x };
+          let lookrnextpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
+          let safety4 = 1000;
+          while (inRange(lookrnextpos) && inRange(lookrpos) && safety4-- > 0) {
+            let safety3 = 4;
+            while (input[lookrnextpos.y][lookrnextpos.x] === '#' && safety3-- > 0) {
               lookrrotate = (lookrrotate + 1) % 4;
               lookrchar = dirs[lookrrotate];
               lookrchange = guard[lookrchar];
+              lookrnextpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
+              console.log(safety3, lookrchar, lookrrotate, lookrnextpos.y, lookrnextpos.x);
+              if (!inRange(lookrnextpos)) {
+                break;
+              }
+            }
+            if (safety3 <= 0) {
+              console.log('safety3');
             }
-            lookrpos = { y: lookrpos.y + lookrchange.dy, x: lookrpos.x + lookrchange.dx };
+            lookrpos = lookrnextpos;
+            if (route.some(p => p.y === lookrpos.y && p.x === lookrpos.x && p.char === lookrchar) || lookloop.some(p => p.y === lookrpos.y && p.x === lookrpos.x && p.char === lookrchar)) {
+              const dd = guard[guardchar];
+              const o = { y: guardpos.y + dd.dy, x: guardpos.x + dd.dx };
+              count++;
+              blocks.push(o);
+              break;
+            }
+            lookloop.push(lookrpos);
+            // continue bouncing off of obstacles and looking for loop
+          }
+          if (safety4 <= 0) {
+            console.log('safety4', { y: guardpos.y, x: guardpos.x });
           }
-
-          guardpos = nextpos;
-          route.push({
-            char: guardchar,
-            rot: dirs.indexOf(guardchar),
-            y: guardpos.y,
-            x: guardpos.x
-          });
           steps++;
         }
         console.log(route);
@@ -515,6 +533,7 @@
         }
         */
 
+        blocks.forEach(p => { input[p.y][p.x] = 'O'; });
         const grid = input.map(r => r.join('')).join('\n');
         console.log(safety, steps, '\n' + grid, count);
         // 508 too low