add: d03

2025/03/all.rs

@@ -0,0 +1,66 @@
+use std::cmp::Ordering;
+
+fn cmp_with_eq_as_gt<T: Ord>(a: &T, b: &T) -> Ordering {
+    let order = a.cmp(b);
+    if order == Ordering::Equal {
+        Ordering::Greater
+    } else {
+        order
+    }
+}
+
+fn p1(bats: [u8; DIGS]) -> usize {
+    let bats_but_last = &bats[0..(bats.len() - 1)];
+
+    let first_dig = unsafe {
+        bats_but_last
+            .iter()
+            .enumerate()
+            .max_by(|a, b| cmp_with_eq_as_gt(a.1, b.1))
+            .unwrap_unchecked()
+    };
+    let last_dig = unsafe { bats[(first_dig.0 + 1)..].iter().max().unwrap_unchecked() };
+
+    let arr_max_jolts = ((first_dig.1 - b'0') * 10) + (last_dig - b'0');
+
+    Into::<usize>::into(arr_max_jolts)
+}
+
+const DIGS: usize = 12;
+
+#[unsafe(no_mangle)]
+fn challenge_usize_duple(buf: &[u8]) -> (usize, usize) {
+    let mut total_joltage1 = 0;
+    let mut total_joltage2 = 0;
+
+    let s = unsafe { str::from_utf8_unchecked(buf) };
+    for array in s.trim().split('\n') {
+        let bats = array.as_bytes();
+
+        let mut digs = [0u8; DIGS];
+        digs.iter_mut()
+            .enumerate()
+            .fold(0, |max_left, (i, dig): (_, &mut u8)| {
+                let max_bat = unsafe {
+                    bats[max_left..(bats.len() - DIGS + i + 1)]
+                        .iter()
+                        .enumerate()
+                        .max_by(|a, b| cmp_with_eq_as_gt(a.1, b.1))
+                        .unwrap_unchecked()
+                };
+
+                *dig = *max_bat.1;
+                max_left + max_bat.0 + 1
+            });
+
+        let n = digs
+            .iter()
+            .map(|d| d - b'0')
+            .fold(0_usize, |left, r| left * 10 + Into::<usize>::into(r));
+
+        total_joltage1 += p1(digs);
+        total_joltage2 += n;
+    }
+
+    (total_joltage1, total_joltage2)
+}

2025/03/p1.rs

@@ -0,0 +1,34 @@
+use std::cmp::Ordering;
+
+fn cmp_with_eq_as_gt<T: Ord>(a: &T, b: &T) -> Ordering {
+    let order = a.cmp(b);
+    if order == Ordering::Equal {
+        Ordering::Greater
+    } else {
+        order
+    }
+}
+
+#[unsafe(no_mangle)]
+fn challenge_usize(buf: &[u8]) -> usize {
+    let mut total_joltage = 0;
+
+    let s = unsafe { str::from_utf8_unchecked(buf) };
+    for array in s.trim().split('\n') {
+        let bats = array.as_bytes();
+        let bats_but_last = &bats[0..(bats.len() - 1)];
+
+        let first_dig = bats_but_last
+            .iter()
+            .enumerate()
+            .max_by(|a, b| cmp_with_eq_as_gt(a.1, b.1))
+            .unwrap();
+        let last_dig = bats[(first_dig.0 + 1)..].iter().max().unwrap();
+
+        println!("-->> {first_dig:?} {last_dig}");
+        let arr_max_jolts = ((first_dig.1 - b'0') * 10) + (last_dig - b'0');
+        total_joltage += Into::<usize>::into(arr_max_jolts);
+    }
+
+    total_joltage
+}

2025/03/p2.rs

@@ -0,0 +1,47 @@
+use std::cmp::Ordering;
+
+fn cmp_with_eq_as_gt<T: Ord>(a: &T, b: &T) -> Ordering {
+    let order = a.cmp(b);
+    if order == Ordering::Equal {
+        Ordering::Greater
+    } else {
+        order
+    }
+}
+
+const DIGS: usize = 12;
+
+#[unsafe(no_mangle)]
+fn challenge_usize(buf: &[u8]) -> usize {
+    let mut total_joltage = 0;
+
+    let s = unsafe { str::from_utf8_unchecked(buf) };
+    for array in s.trim().split('\n') {
+        let bats = array.as_bytes();
+
+        let mut digs = [0u8; DIGS];
+        digs.iter_mut()
+            .enumerate()
+            .fold(0, |max_left, (i, dig): (_, &mut u8)| {
+                let max_bat = bats[max_left..(bats.len() - DIGS + i + 1)]
+                    .iter()
+                    .enumerate()
+                    .max_by(|a, b| cmp_with_eq_as_gt(a.1, b.1))
+                    .unwrap();
+
+                *dig = *max_bat.1;
+
+                max_left + max_bat.0 + 1
+            });
+
+        let n = digs
+            .iter()
+            .map(|d| d - b'0')
+            .fold(0_usize, |left, r| left * 10 + Into::<usize>::into(r));
+
+        // println!("-->> {digs:?} {n:?}",);
+        total_joltage += n;
+    }
+
+    total_joltage
+}