Day5 part2 done

day5/main.c

@@ -141,6 +141,193 @@ i64 part1() {
 }
 
 i64 part2() {
+  Range* ranges = malloc(100000);
+  i32 rlen = 0;
+
+  while (get_line()) {
+    if (*buf == '\n') break;
+
+    i32 len = 0;
+    i64 min = get_num(buf, &len);
+    buf += len;
+
+    if (*buf != '-') {
+      debug("WEIRD!");
+    }
+    buf++;
+
+    i64 max = get_num(buf, &len);
+
+    ranges[rlen] = (Range){ .min = min, .max = max };
+    debug("%ld: %ld-%ld\n", rlen, ranges[rlen].min, ranges[rlen].max);
+    rlen++;
+  }
+
+  i64 count = 0;
+  Range* dranges = malloc(100000);
+  i32 dlen = 0;
+
+  i32 initialLen = rlen;
+
+  i32 overlaps = 0;
+  i32 subsets = 0;
+  i32 supersets = 0;
+  i32 slidingLeft = 0;
+  i32 slidingRight = 0;
+  for (i32 i = 0; i < rlen; i++) {
+    Range range = ranges[i];
+
+    bool overlapped = false;
+    for (i32 j = 0; j < dlen; j++) {
+      Range drange = dranges[j];
+
+      if (drange.max < range.min) {
+        continue;
+      }
+      if (range.max < drange.min) {
+        continue;
+      }
+
+      overlapped = true;
+
+      if (drange.min <= range.min && range.max <= drange.max) {
+        // Fully contained (no need to add this), can skip
+        // debug("RANGE %ld-%ld (%ld) [[is subset of]] DRANGE %ld-%ld (%ld)\n",
+        //       range.min, range.max, range.max-range.min,
+        //       drange.min, drange.max, drange.max-drange.min);
+        subsets++;
+        break;
+        // We can break instead of continue, bcz if it's within an existing range
+        // then there is no point in counting it at all, it's already full counted
+      }
+
+      if (range.min <= drange.min && drange.max <= range.max) {
+        supersets++;
+
+        Range left = (Range){ .min = range.min, .max = drange.min-1 };
+        Range right = (Range){ .min = drange.max+1, .max = range.max };
+
+        if (range.min != drange.min) {
+          ranges[rlen] = left;
+          rlen++;
+        }
+
+        if (range.max != drange.max) {
+          ranges[rlen] = right;
+          rlen++;
+        }
+
+        debug("SPLIT ");
+
+        break;
+      }
+      else if (range.max > drange.min && range.min < drange.min) {
+        slidingLeft++;
+        // Range leftRange = (Range){ .min = range.min, .max = drange.max-1 };
+        // // Add new range for rechecking
+        // debug("HUH\n");
+        // ranges[rlen] = leftRange;
+        // rlen++;
+        // break;
+
+        // Range rightRange = (Range){ .min = drange.max+1, .max = range.max };
+        Range leftRange = (Range){ .min = range.min, drange.min-1 };
+        // Range leftRange = (Range){ .min = drange.max+1, .max = range.max };
+
+        debug("SLIDING LEFT %ld-%ld overlaps DRANGE %ld-%ld producing LRANGE %ld-%ld\n",
+              range.min, range.max,
+              drange.min, drange.max,
+              leftRange.min, leftRange.max);
+
+        ranges[rlen] = leftRange;
+        rlen++;
+
+        break;
+      } else if (range.min < drange.max && drange.min < range.min) {
+        slidingRight++;
+
+        // Range leftRange = (Range){ .min = range.min, drange.min-1 };
+        Range rightRange = (Range){ .min = drange.max+1, .max = range.max };
+        // Range rightRange  = (Range){ .min = range.min, drange.min-1 };
+
+        // debug("SLIDING RIGHT %s RANGE %ld-%ld (%ld) overlaps with DRANGE %ld-%ld (%ld)\n",
+        //       i > initialLen ? "[[NEW]]" : "",
+        //       range.min, range.max, range.max-range.min,
+        //       drange.min, drange.max, drange.max-drange.min);
+
+        debug("SLIDING RIGHT %ld-%ld overlaps DRANGE %ld-%ld producing RRANGE %ld-%ld\n",
+              range.min, range.max,
+              drange.min, drange.max,
+              rightRange.min, rightRange.max);
+
+        ranges[rlen] = rightRange;
+        rlen++;
+
+        // debug("RIGHT ");
+
+        break;
+      } else if (range.max == drange.min) {
+        Range r = (Range){ .min = range.min, .max = range.max-1 };
+        debug("TOUCHING UPPER %ld-%ld overlaps DRANGE %ld-%ld producing RRANGE %ld-%ld\n",
+              range.min, range.max,
+              drange.min, drange.max,
+              r.min, r.max);
+        ranges[rlen] = r;
+        rlen++;
+      } else if (range.min == drange.max) {
+        Range r = (Range){ .min = range.min+1, .max = range.max };
+        debug("TOUCHING LOWER %ld-%ld overlaps DRANGE %ld-%ld producing RRANGE %ld-%ld\n",
+              range.min, range.max,
+              drange.min, drange.max,
+              r.min, r.max);
+        ranges[rlen] = r;
+        rlen++;
+      } else {
+        debug("HUH\n");
+
+        debug("RANGE %ld-%ld overlaps DRANGE %ld-%ld\n",
+              range.min, range.max,
+              drange.min, drange.max);
+
+        *((volatile void*)0);
+        return -1;
+      }
+
+      overlaps++;
+      // debug("%s RANGE %ld-%ld (%ld) overlaps with DRANGE %ld-%ld (%ld)\n",
+      //       rlen > initialLen ? "[[NEW]]" : "",
+      //       range.min, range.max, range.max-range.min,
+      //       drange.min, drange.max, drange.max-drange.min);
+    }
+
+    if (!overlapped) {
+      i64 diff = range.max - range.min;
+      count += diff+1; // +1 bcz 1-3 is 3-1=2 but 1, 2, 3 is 3, we need to add an extra one
+
+      debug("Added drange: %ld-%ld\n", range.min, range.max);
+      dranges[dlen] = range;
+      dlen++;
+    }
+  }
+
+  debug("Overlaps: %d\n", overlaps);
+  debug("Subsets: %d\n", subsets);
+  debug("Supersets: %d\n", supersets);
+  debug("Sliding Left: %d\n", slidingLeft);
+  debug("Sliding Right: %d\n", slidingRight);
+
+  debug("\nCount: %d\n", count);
+
+  count = 0;
+  for (i32 i = 0;i < dlen; i++) {
+    Range range = dranges[i];
+    i64 diff = range.max-range.min;
+    // debug("%ld-%ld (%ld+1)\n", range.min, range.max, diff);
+    count += diff + 1;
+    // debug("%d COUNT: %ld\n", i, count);
+  }
+
+  return count;
 }
 
 int main() {
@@ -149,8 +336,8 @@ int main() {
   buf = malloc(SIZE);
   memset(buf, 0, SIZE);
 
-  i64 result = part1();
-  // i64 result = part2();
+  // i64 result = part1();
+  i64 result = part2();
   printf("\n%ld\n", result);
 }