From 23c52cab0e3fc001e53c03047b8dc9e8128718c1 Mon Sep 17 00:00:00 2001 From: javalsai Date: Tue, 2 Dec 2025 13:15:02 +0100 Subject: [PATCH] add: d02, optimizations might come later will namely add a numberic based algorithm, maybe even the stack .to_string() is too slow also might not do it, grialion already optimized tf out of it --- 2025/02/all.rs | 66 +++++++++++++++++++++++++++++++++++++++++++++++ 2025/02/p1.rs | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2025/02/p2.rs | 54 +++++++++++++++++++++++++++++++++++++++ 2025/tester.rs | 4 +-- 4 files changed, 191 insertions(+), 2 deletions(-) create mode 100644 2025/02/all.rs create mode 100644 2025/02/p1.rs create mode 100644 2025/02/p2.rs diff --git a/2025/02/all.rs b/2025/02/all.rs new file mode 100644 index 0000000..4766a7e --- /dev/null +++ b/2025/02/all.rs @@ -0,0 +1,66 @@ +#[unsafe(no_mangle)] +fn challenge_usize_duple(b: &[u8]) -> (usize, usize) { + let mut total1 = 0; + let mut total2 = 0; + let s = unsafe { str::from_utf8_unchecked(b) }; + + let ranges = s.trim_end().split(','); + for range in ranges { + let (start, end) = range.split_once('-').unwrap(); + let (start, end): (usize, usize) = (start.parse().unwrap(), end.parse().unwrap()); + + for id in start..=end { + let mut buf = [0; _]; + let id_s = &fast_to_string(id, &mut buf); + + if is_repeating1(id_s) { + total1 += id; + } + if is_repeating2(id_s) { + total2 += id; + } + } + } + + (total1, total2) +} + +const MAX_USIZE_LEN: usize = const { usize::MAX.ilog10() + 1 } as usize; +/// Output is reversed btw +fn fast_to_string(mut n: usize, into: &mut [u8; MAX_USIZE_LEN]) -> &mut [u8] { + let mut len = 0; + while n != 0 { + into[len] = (n % 10) as u8 + b'0'; + n /= 10; + len += 1; + } + + &mut into[0..len] +} + +fn is_repeating1(s: &[u8]) -> bool { + if !s.len().is_multiple_of(2) { + return false; + } + + let mid = s.len() / 2; + let (left, right) = s.split_at(mid); + left == right +} + +fn is_repeating2(s: &[u8]) -> bool { + for sublen in 0..(s.len() / 2) { + let sublen = sublen + 1; + if !s.len().is_multiple_of(sublen) { + continue; + } + let pref = &s[0..sublen]; + + let is_repeating = s[sublen..].chunks_exact(sublen).all(|c| c == pref); + if is_repeating { + return true; + } + } + + false +} diff --git a/2025/02/p1.rs b/2025/02/p1.rs new file mode 100644 index 0000000..580061b --- /dev/null +++ b/2025/02/p1.rs @@ -0,0 +1,69 @@ +#[unsafe(no_mangle)] +fn challenge_usize(b: &[u8]) -> usize { + let mut total = 0; + let s = unsafe { str::from_utf8_unchecked(b) }; + + dbg!(is_repeating(b"11")); + let ranges = s.trim_end().split(','); + for range in ranges { + let (start, end) = range.split_once('-').unwrap(); + if start.starts_with('0') || end.starts_with('0') { + continue; + } + let (start, end): (usize, usize) = (start.parse().unwrap(), end.parse().unwrap()); + println!("{start}-{end}"); + + for id in start..=end { + let id_s = id.to_string(); + + if is_repeating(id_s.as_bytes()) { + total += id; + println!("-->> invalid {id_s}"); + } + } + } + + total +} + +const MAX_USIZE_LEN: usize = const { usize::MAX.ilog10() + 1 } as usize; +/// Output is reversed btw +fn fast_to_string(mut n: usize, into: &mut [u8; MAX_USIZE_LEN]) -> &mut [u8] { + let mut len = 0; + while n != 0 { + into[len] = (n % 10) as u8 + b'0'; + n /= 10; + len += 1; + } + + &mut into[0..len] +} + +fn is_repeating(s: &[u8]) -> bool { + if !s.len().is_multiple_of(2) { + return false; + } + + let mid = s.len() / 2; + let (left, right) = s.split_at(mid); + left == right +} + +// LMAO: I did p2 instead of p1 firstly bcs I misread it. + +// fn is_repeating(s: &[u8]) -> bool { +// for sublen in 0..(s.len() / 2) { +// let sublen = sublen + 1; +// if !s.len().is_multiple_of(sublen) { +// continue; +// } +// let pref = &s[0..sublen]; + +// let is_repeating = s[sublen..].chunks_exact(sublen).all(|c| c == pref); +// if is_repeating { +// return true; +// } +// } + +// false +// } diff --git a/2025/02/p2.rs b/2025/02/p2.rs new file mode 100644 index 0000000..389ac65 --- /dev/null +++ b/2025/02/p2.rs @@ -0,0 +1,54 @@ +#[unsafe(no_mangle)] +fn challenge_usize(b: &[u8]) -> usize { + let mut total = 0; + let s = unsafe { str::from_utf8_unchecked(b) }; + + dbg!(is_repeating(b"11")); + let ranges = s.trim_end().split(','); + for range in ranges { + let (start, end) = range.split_once('-').unwrap(); + if start.starts_with('0') || end.starts_with('0') { + continue; + } + let (start, end): (usize, usize) = (start.parse().unwrap(), end.parse().unwrap()); + println!("{start}-{end}"); + + for id in start..=end { + let id_s = id.to_string(); + + if is_repeating(id_s.as_bytes()) { + total += id; + println!("-->> invalid {id_s}"); + } + } + } + + total +} + +// fn is_repeating(s: &[u8]) -> bool { +// if !s.len().is_multiple_of(2) { +// return false; +// } + +// let mid = s.len() / 2; +// let (left, right) = s.split_at(mid); +// left == right +// } + +fn is_repeating(s: &[u8]) -> bool { + for sublen in 0..(s.len() / 2) { + let sublen = sublen + 1; + if !s.len().is_multiple_of(sublen) { + continue; + } + let pref = &s[0..sublen]; + + let is_repeating = s[sublen..].chunks_exact(sublen).all(|c| c == pref); + if is_repeating { + return true; + } + } + + false +} diff --git a/2025/tester.rs b/2025/tester.rs index 04e8efd..229cf40 100644 --- a/2025/tester.rs +++ b/2025/tester.rs @@ -179,9 +179,9 @@ pub mod loader { // SAFETY: This is actually safe as it just creates the fn ptr, no weird fn with weird // drop. untry!(unsafe { handle.symfn::>(c"challenge_isize") }.map(V::Isize)); - untry!(unsafe { handle.symfn::>(c"challenge_isize") }.map(V::Usize)); + untry!(unsafe { handle.symfn::>(c"challenge_usize") }.map(V::Usize)); untry!(unsafe { handle.symfn::>(c"challenge_isize_duple") }.map(V::UsizeDuple)); - untry!(unsafe { handle.symfn::>(c"challenge_isize_duple") }.map(V::IsizeDuple)); + untry!(unsafe { handle.symfn::>(c"challenge_usize_duple") }.map(V::IsizeDuple)); None }