for now
This commit is contained in:
lda committed
1 parent
39f466c59a
commit
79c67497fa
7 files changed
+1377
-18
No files matched your search
@@ -26,7 +26,7 @@ impl DB {
|
||||
if !self.inner.windows(2).all(|w| w[0] < w[1]) {
|
||||
return Err("Inner vector must be strictly increasing".to_string());
|
||||
}
|
||||
if self.inner.last().map_or(false, |&x| x >= self.len) {
|
||||
if self.inner.last().is_some_and(|&x| x >= self.len) {
|
||||
return Err("Inner values must be less than len".to_string());
|
||||
}
|
||||
Ok(())
|
||||
@@ -80,7 +80,7 @@ impl DB {
|
||||
/// Removes the last value from the sequence.
|
||||
pub fn pop(&mut self) -> Option<u32> {
|
||||
let return_value = self.last();
|
||||
if let Some(_) = return_value {
|
||||
if return_value.is_some() {
|
||||
if let Some(&last_inner) = self.inner.last() {
|
||||
if self.len - last_inner == 1 {
|
||||
self.inner.pop();
|
||||
@@ -185,8 +185,8 @@ impl DB {
|
||||
if val == avail[0] && up {
|
||||
if self.inner.len() == val as usize {
|
||||
self.inner.push(ind);
|
||||
} else {
|
||||
self.inner.get_mut(val as usize).map(|e| *e += 1);
|
||||
} else if let Some(e) = self.inner.get_mut(val as usize) {
|
||||
*e += 1
|
||||
}
|
||||
} else if val == avail[1] && !up {
|
||||
self.inner
|
||||
@@ -227,7 +227,7 @@ impl DB {
|
||||
|
||||
/// Converts the compressed sequence back to a full vector.
|
||||
pub fn vec(&self) -> Vec<u32> {
|
||||
let mut count = (0..).into_iter();
|
||||
let mut count = 0..;
|
||||
self.inner
|
||||
.iter()
|
||||
.chain([self.len].iter())
|
||||
@@ -306,7 +306,7 @@ mod test {
|
||||
fn last() {
|
||||
let db = DB::new();
|
||||
assert_eq!(db.len(), 0);
|
||||
assert!(matches!(db.last(), None));
|
||||
assert!(db.last().is_none());
|
||||
|
||||
let db = DB::with_len(1);
|
||||
assert!(matches!(db.last(), Some(0)));
|
||||
@@ -357,7 +357,7 @@ mod test {
|
||||
assert_eq!(db.vec(), c)
|
||||
}
|
||||
#[test]
|
||||
#[should_panic]
|
||||
// #[should_panic]
|
||||
fn invalid_push() {
|
||||
let mut db = DB::new();
|
||||
// dbg!(&db.inner);
|
||||
@@ -371,10 +371,10 @@ mod test {
|
||||
// dbg!(db.vec());
|
||||
db.push(2).unwrap();
|
||||
dbg!(db.len() != 0);
|
||||
db.push(4).expect("this is the one");
|
||||
assert!(db.push(4).is_err());
|
||||
}
|
||||
#[test]
|
||||
#[should_panic]
|
||||
// #[should_panic]
|
||||
fn invalid_push_2() {
|
||||
let mut db = DB::new();
|
||||
// dbg!(&db.inner);
|
||||
@@ -385,7 +385,7 @@ mod test {
|
||||
// dbg!(db.vec());
|
||||
db.push(2).unwrap();
|
||||
dbg!(db.len() != 0);
|
||||
db.push(1).expect("this is the one yall");
|
||||
assert!(db.push(1).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -422,7 +422,7 @@ mod test {
|
||||
}
|
||||
#[test]
|
||||
fn avail() {
|
||||
let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
let c = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
let ctodb = DB {
|
||||
|
||||
@@ -80,7 +80,7 @@ impl DB {
|
||||
|
||||
/// Returns the last value in the sequence
|
||||
pub fn last_value(&self) -> Option<u32> {
|
||||
if self.len() == 0 {
|
||||
if self.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(self.inner.len() as u32)
|
||||
@@ -346,3 +346,416 @@ mod tests {
|
||||
assert_eq!(db.range_of(2), None);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// /// working as intended: i am happy
|
||||
// #[cfg(test)]
|
||||
// mod test {
|
||||
// use super::DB;
|
||||
// #[test]
|
||||
// fn db_to_vec() {
|
||||
// let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
// let clen = 16;
|
||||
// assert_eq!(clen as usize, c.len());
|
||||
// let ctodb = DB {
|
||||
// inner: ctodb,
|
||||
// len: clen,
|
||||
// };
|
||||
// assert!(ctodb.validate().is_ok());
|
||||
// assert_eq!(ctodb.to_vec(), c);
|
||||
// }
|
||||
// #[test]
|
||||
// fn pop_and_get() {
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
// let clen = 17;
|
||||
// let mut db = DB {
|
||||
// inner: ctodb,
|
||||
// len: clen,
|
||||
// };
|
||||
// assert_eq!(db.get(4), Some(1));
|
||||
// assert_eq!(db.get(12), Some(3));
|
||||
// assert_eq!(db.get(18), None);
|
||||
// assert_eq!(db.get(0), Some(0));
|
||||
// assert_eq!(db.get(17), None);
|
||||
// assert_eq!(db.get(16), Some(4));
|
||||
// // assert_eq!(db.pop(), Some(4));
|
||||
|
||||
// // println!("len:{} inner: {:?} vec: {:?}",db.len(), db.inner, db.vec());
|
||||
// // while let Some(_) = db.pop() {
|
||||
// // println!("len:{} inner: {:?} vec: {:?}",db.len(), db.inner, db.vec());
|
||||
|
||||
// // };
|
||||
// let mut vec = db.to_vec();
|
||||
// while db.len() > 0 {
|
||||
// assert_eq!(db.pop(), vec.pop())
|
||||
// }
|
||||
// assert_eq!(db.pop(), vec.pop());
|
||||
// assert_eq!(db.len(), 0);
|
||||
// }
|
||||
// #[test]
|
||||
// fn last() {
|
||||
// let db = DB::new();
|
||||
// assert_eq!(db.len(), 0);
|
||||
// assert!(db.last_value().is_none());
|
||||
|
||||
// let db = DB::with_len(1);
|
||||
// assert!(matches!(db.last_value(), Some(0)));
|
||||
|
||||
// // assert!(db.pop() == 0);
|
||||
// // assert_eq!(db.len(), 0);
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn range_of() {
|
||||
// let ctodb = vec![4, 7, 9, 12, 15, 23, 27, 31, 38, 41];
|
||||
// let clen = 49;
|
||||
// let mut db = DB {
|
||||
// inner: ctodb,
|
||||
// len: clen,
|
||||
// };
|
||||
// assert_eq!(db.range_of(0), Some(0..4));
|
||||
// assert_eq!(db.range_of(1), Some(4..7));
|
||||
// assert_eq!(db.range_of(11), None);
|
||||
// assert_eq!(db.range_of(10), Some(41..clen));
|
||||
// assert_eq!(db.pop(), Some(10));
|
||||
// assert_eq!(db.range_of(10), Some(41..clen - 1));
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn push() {
|
||||
// let mut db = DB::new();
|
||||
// let mut c = vec![];
|
||||
// let mut push = |i| {
|
||||
// db.push(i).unwrap();
|
||||
// c.push(i);
|
||||
// };
|
||||
// for _ in 0..6 {
|
||||
// push(0);
|
||||
// }
|
||||
// for _ in 0..3 {
|
||||
// push(1);
|
||||
// }
|
||||
// for _ in 0..5 {
|
||||
// push(2);
|
||||
// }
|
||||
// for _ in 0..2 {
|
||||
// push(3);
|
||||
// }
|
||||
// for _ in 0..1 {
|
||||
// push(4);
|
||||
// }
|
||||
// assert_eq!(db.to_vec(), c)
|
||||
// }
|
||||
// #[test]
|
||||
// // #[should_panic]
|
||||
// fn invalid_push() {
|
||||
// let mut db = DB::new();
|
||||
// // dbg!(&db.inner);
|
||||
// db.push(1).unwrap();
|
||||
// // dbg!(&db.inner);
|
||||
// for _ in 3..=11 {
|
||||
// db.push(1).unwrap();
|
||||
// }
|
||||
|
||||
// // dbg!(&db.inner);
|
||||
// // dbg!(db.vec());
|
||||
// db.push(2).unwrap();
|
||||
// dbg!(db.len() != 0);
|
||||
// assert!(db.push(4).is_err());
|
||||
// }
|
||||
// #[test]
|
||||
// // #[should_panic]
|
||||
// fn invalid_push_2() {
|
||||
// let mut db = DB::new();
|
||||
// // dbg!(&db.inner);
|
||||
|
||||
// db.push(0).unwrap();
|
||||
// db.push(1).unwrap();
|
||||
// // dbg!(&db.inner);
|
||||
// // dbg!(db.vec());
|
||||
// db.push(2).unwrap();
|
||||
// dbg!(db.len() != 0);
|
||||
// assert!(db.push(1).is_err());
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn change() {
|
||||
// let mut c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let mut ctodb = DB {
|
||||
// inner: ctodb,
|
||||
// len: c.len() as _,
|
||||
// };
|
||||
// let mut change = |i, v| {
|
||||
// ctodb.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
// change(13, 3);
|
||||
// change(3, 1);
|
||||
// change(7, 2);
|
||||
|
||||
// assert_eq!(ctodb.inner, DB::try_from_vec(c).unwrap().inner)
|
||||
// }
|
||||
// #[test]
|
||||
// fn from_vec() {
|
||||
// let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let ctodb = DB {
|
||||
// inner: ctodb,
|
||||
// len: c.len() as _,
|
||||
// };
|
||||
// let c2 = DB::try_from_vec(c).unwrap();
|
||||
// assert_eq!(ctodb.inner, c2.inner);
|
||||
// assert_eq!(ctodb.len, c2.len);
|
||||
// }
|
||||
// #[test]
|
||||
// fn avail() {
|
||||
// let c = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let ctodb = DB {
|
||||
// inner: ctodb,
|
||||
// len: c.len() as _,
|
||||
// };
|
||||
// ctodb.available_values(3).unwrap();
|
||||
// ctodb.available_values(7).unwrap() ;
|
||||
// dbg!(ctodb.available_values(13).unwrap());
|
||||
|
||||
// dbg!(ctodb.available_values(0).unwrap(),);
|
||||
// dbg!(ctodb.available_values(4).unwrap(), );
|
||||
// dbg!(ctodb.available_values(11).unwrap(), );
|
||||
// dbg!(ctodb.available_values(12).unwrap(), );
|
||||
// dbg!(ctodb.available_values(15).unwrap(), );
|
||||
// dbg!(ctodb.available_values(16).unwrap(),);
|
||||
// assert!(ctodb.available_values(17).is_err());
|
||||
// }
|
||||
// #[test]
|
||||
// fn avail_hard() {
|
||||
// let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let db = DB::try_from_vec(c).unwrap();
|
||||
// dbg!(db.available_values(0), );
|
||||
// dbg!(db.available_values(1), );
|
||||
// dbg!(db.available_values(11),);
|
||||
// dbg!(db.available_values(12), );
|
||||
// dbg!(db.available_values(13), );
|
||||
// dbg!(db.available_values(15), );
|
||||
// dbg!(db.available_values(16), );
|
||||
// dbg!(db.available_values(17), );
|
||||
// }
|
||||
// #[test]
|
||||
// fn change_hard() {
|
||||
// let mut c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let mut db = DB::try_from_vec(c.clone()).unwrap();
|
||||
// let change = |d: &mut DB, c: &mut Vec<u32>, i, v| {
|
||||
// d.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
|
||||
// change(&mut db, &mut c, 12, 12);
|
||||
// change(&mut db, &mut c, 16, 14);
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 13, 12);
|
||||
// change(&mut db, &mut c, 14, 12);
|
||||
// change(&mut db, &mut c, 11, 11);
|
||||
// change(&mut db, &mut c, 12, 11);
|
||||
// change(&mut db, &mut c, 13, 11);
|
||||
// change(&mut db, &mut c, 10, 10);
|
||||
// change(&mut db, &mut c, 11, 10);
|
||||
// change(&mut db, &mut c, 12, 10);
|
||||
// change(&mut db, &mut c, 9, 9);
|
||||
// change(&mut db, &mut c, 10, 9);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(", {:?}", DB::try_from_vec(c.clone()).unwrap().to_vec());
|
||||
// }
|
||||
// change(&mut db, &mut c, 11, 9);
|
||||
// change(&mut db, &mut c, 8, 8);
|
||||
// change(&mut db, &mut c, 9, 8);
|
||||
// change(&mut db, &mut c, 10, 8);
|
||||
// change(&mut db, &mut c, 7, 7);
|
||||
// change(&mut db, &mut c, 8, 7);
|
||||
// // change(&mut db, &mut c, 9, 7);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(", {:?}", DB::try_from_vec(c.clone()).unwrap().to_vec());
|
||||
// }
|
||||
// change(&mut db, &mut c, 6, 6);
|
||||
// change(&mut db, &mut c, 7, 6);
|
||||
// // change(&mut db, &mut c, 8, 6);
|
||||
// change(&mut db, &mut c, 5, 5);
|
||||
// change(&mut db, &mut c, 6, 5);
|
||||
// // change(&mut db, &mut c, 7, 5);
|
||||
// change(&mut db, &mut c, 4, 4);
|
||||
// change(&mut db, &mut c, 5, 4);
|
||||
// // change(&mut db, &mut c, 6, 4);
|
||||
// change(&mut db, &mut c, 3, 3);
|
||||
// change(&mut db, &mut c, 4, 3);
|
||||
// // change(&mut db, &mut c, 5, 3);
|
||||
// change(&mut db, &mut c, 2, 2);
|
||||
// change(&mut db, &mut c, 3, 2);
|
||||
// // change(&mut db, &mut c, 4, 2);
|
||||
// change(&mut db, &mut c, 1, 1);
|
||||
// // change(&mut db, &mut c, 2, 1);
|
||||
// // change(&mut db, &mut c, 3, 1);
|
||||
// change(&mut db, &mut c, 0, 0);
|
||||
// // change(&mut db, &mut c, 1, 0);
|
||||
// // change(&mut db, &mut c, 2, 0);
|
||||
// {
|
||||
// let db2 = DB::try_from_vec(c.clone()).unwrap();
|
||||
// println!("e: {c:?}, {:?}", db2.to_vec());
|
||||
// println!("{:?}", db);
|
||||
// assert_eq!(db, db2);
|
||||
// }
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn change_harder() {
|
||||
// let mut c = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13];
|
||||
// let mut db = DB::try_from_vec(c.clone()).unwrap();
|
||||
// let change = |d: &mut DB, c: &mut Vec<u32>, i, v| {
|
||||
// d.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 12, 12);
|
||||
// println!("m: {:?}", db);
|
||||
// change(&mut db, &mut c, 16, 14);
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 13, 12);
|
||||
// change(&mut db, &mut c, 14, 12);
|
||||
// change(&mut db, &mut c, 11, 11);
|
||||
// change(&mut db, &mut c, 12, 11);
|
||||
// change(&mut db, &mut c, 13, 11);
|
||||
// change(&mut db, &mut c, 10, 10);
|
||||
// change(&mut db, &mut c, 11, 10);
|
||||
// change(&mut db, &mut c, 12, 10);
|
||||
// change(&mut db, &mut c, 9, 9);
|
||||
// change(&mut db, &mut c, 10, 9);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(", {:?}", DB::try_from_vec(c.clone()).unwrap().to_vec());
|
||||
// }
|
||||
// change(&mut db, &mut c, 11, 9);
|
||||
// change(&mut db, &mut c, 8, 8);
|
||||
// change(&mut db, &mut c, 9, 8);
|
||||
// change(&mut db, &mut c, 10, 8);
|
||||
// change(&mut db, &mut c, 7, 7);
|
||||
// change(&mut db, &mut c, 8, 7);
|
||||
// // change(&mut db, &mut c, 9, 7);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(", {:?}", DB::try_from_vec(c.clone()).unwrap().to_vec());
|
||||
// }
|
||||
// change(&mut db, &mut c, 6, 6);
|
||||
// change(&mut db, &mut c, 7, 6);
|
||||
// // change(&mut db, &mut c, 8, 6);
|
||||
// change(&mut db, &mut c, 5, 5);
|
||||
// change(&mut db, &mut c, 6, 5);
|
||||
// // change(&mut db, &mut c, 7, 5);
|
||||
// change(&mut db, &mut c, 4, 4);
|
||||
// change(&mut db, &mut c, 5, 4);
|
||||
// // change(&mut db, &mut c, 6, 4);
|
||||
// change(&mut db, &mut c, 3, 3);
|
||||
// change(&mut db, &mut c, 4, 3);
|
||||
// // change(&mut db, &mut c, 5, 3);
|
||||
// change(&mut db, &mut c, 2, 2);
|
||||
// change(&mut db, &mut c, 3, 2);
|
||||
// // change(&mut db, &mut c, 4, 2);
|
||||
// change(&mut db, &mut c, 1, 1);
|
||||
// // change(&mut db, &mut c, 2, 1);
|
||||
// // change(&mut db, &mut c, 3, 1);
|
||||
// change(&mut db, &mut c, 0, 0);
|
||||
// // change(&mut db, &mut c, 1, 0);
|
||||
// // change(&mut db, &mut c, 2, 0);
|
||||
// {
|
||||
// let db2 = DB::try_from_vec(c.clone()).unwrap();
|
||||
// println!("e: {c:?}, {:?}", db2.to_vec());
|
||||
// println!("{:?}", db);
|
||||
// assert_eq!(db, db2);
|
||||
// }
|
||||
// }
|
||||
|
||||
// // #[test]
|
||||
// // fn prop_idk() {
|
||||
// // let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// // let mut db = DB::try_from_vec(c.clone()).unwrap();
|
||||
// // dbg!(&mut db).propagate_to_end(2, 2);
|
||||
// // dbg!(&db);
|
||||
// // println!("{:?}", db.vec());
|
||||
// // assert_eq!(db.inner, vec![0, 1]);
|
||||
// // let mut db = DB::try_from_vec(c.clone()).unwrap();
|
||||
// // db.propagate_to_end(2, 3);
|
||||
// // println!("{:?}", db.vec());
|
||||
// // assert_eq!(db.inner, vec![0, 1, 2]);
|
||||
// // }
|
||||
// // #[test]
|
||||
// // fn prop() {
|
||||
// // let base = [
|
||||
// // 0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
|
||||
// // 14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
|
||||
// // 26, 26,
|
||||
// // ];
|
||||
|
||||
// // let prop = |bd: &mut DB, cc: &mut Vec<u32>, i, v: u32| {
|
||||
// // cc.get_mut(i as usize..).unwrap().fill(v);
|
||||
// // bd.propagate_to_end(i, v);
|
||||
// // };
|
||||
// // {
|
||||
// // let mut c = base.to_vec();
|
||||
// // let mut db = DB::try_from_vec(c.to_vec()).unwrap();
|
||||
|
||||
// // prop(&mut db, &mut c, 15, 7);
|
||||
// // prop(&mut db, &mut c, 28, 8);
|
||||
|
||||
// // println!("{db:?}, {c:?}");
|
||||
|
||||
// // assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
|
||||
// // assert_eq!(db.vec(), c);
|
||||
// // }
|
||||
// // }
|
||||
// // #[test]
|
||||
// // #[should_panic]
|
||||
// // fn prop_failcase() {
|
||||
// // let base = [
|
||||
// // 0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
|
||||
// // 14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
|
||||
// // 26, 26,
|
||||
// // ];
|
||||
|
||||
// // let prop = |bd: &mut DB, cc: &mut Vec<u32>, i, v: u32| {
|
||||
// // cc.get_mut(i as usize..).unwrap().fill(v);
|
||||
// // bd.propagate_to_end(i, v);
|
||||
// // };
|
||||
// // {
|
||||
// // let mut c = base.to_vec();
|
||||
// // let mut db = DB::try_from_vec(c.to_vec()).unwrap();
|
||||
|
||||
// // // prop(&mut db, &mut c, 12, 6);
|
||||
// // prop(&mut db, &mut c, 28, 14);
|
||||
|
||||
// // println!("{db:?}, {c:?}");
|
||||
|
||||
// // assert_eq!(db.vec(), c);
|
||||
// // assert_eq!(db, DB::try_from_vec(c.clone()).unwrap());
|
||||
// // }
|
||||
// // }
|
||||
// }
|
||||
@@ -0,0 +1,206 @@
|
||||
use std::cmp::Ordering;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct MonotonicSequence {
|
||||
/// Stores (position, value) pairs where value increases
|
||||
/// Always includes (0, initial_value) as first element
|
||||
jumps: Vec<(usize, u32)>,
|
||||
/// Length of the sequence
|
||||
length: usize,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum ChangeError {
|
||||
/// Position beyond sequence length
|
||||
OutOfBounds { pos: usize, length: usize },
|
||||
/// Change would break monotonic property
|
||||
InvalidChange {
|
||||
pos: usize,
|
||||
new_value: u32,
|
||||
reason: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl MonotonicSequence {
|
||||
/// Create new sequence starting with given value
|
||||
pub fn new(initial_value: u32, length: usize) -> Self {
|
||||
Self {
|
||||
jumps: vec![(0, initial_value)],
|
||||
length,
|
||||
}
|
||||
}
|
||||
|
||||
/// Get value at position
|
||||
pub fn get(&self, pos: usize) -> Option<u32> {
|
||||
if pos >= self.length {
|
||||
return None;
|
||||
}
|
||||
|
||||
// Binary search for last jump <= pos
|
||||
match self.jumps.binary_search_by(|(jump_pos, _)| {
|
||||
if *jump_pos <= pos {
|
||||
Ordering::Less
|
||||
} else {
|
||||
Ordering::Greater
|
||||
}
|
||||
}) {
|
||||
// Exact match found
|
||||
Ok(idx) => Some(self.jumps[idx].1),
|
||||
// No exact match, use last smaller value
|
||||
Err(idx) if idx > 0 => Some(self.jumps[idx - 1].1),
|
||||
// Position before first jump
|
||||
Err(_) => Some(0),
|
||||
}
|
||||
}
|
||||
|
||||
/// Can we change value at position to new_value?
|
||||
pub fn can_change(&self, pos: usize, new_value: u32) -> Result<bool, ChangeError> {
|
||||
if pos >= self.length {
|
||||
return Err(ChangeError::OutOfBounds {
|
||||
pos,
|
||||
length: self.length
|
||||
});
|
||||
}
|
||||
|
||||
// Get current value
|
||||
let _current = self.get(pos).unwrap();
|
||||
|
||||
// Get value before (if any)
|
||||
let value_before = if pos > 0 {
|
||||
self.get(pos - 1).unwrap()
|
||||
} else {
|
||||
// If at start, can only change to 0 or 1
|
||||
return Ok(new_value <= 1);
|
||||
};
|
||||
|
||||
// Get value after (if any)
|
||||
let value_after = if pos < self.length - 1 {
|
||||
self.get(pos + 1).unwrap()
|
||||
} else {
|
||||
// If at end, just need to check previous value
|
||||
return Ok(new_value >= value_before && new_value <= value_before + 1);
|
||||
};
|
||||
|
||||
// Main rules:
|
||||
// 1. Can't decrease by more than 1 from previous
|
||||
// 2. Can't increase by more than 1 from previous
|
||||
// 3. Next value must be valid relative to new value
|
||||
Ok(
|
||||
new_value >= value_before &&
|
||||
new_value <= value_before + 1 &&
|
||||
value_after >= new_value &&
|
||||
value_after <= new_value + 1
|
||||
)
|
||||
}
|
||||
|
||||
/// Change value at position
|
||||
pub fn change(&mut self, pos: usize, new_value: u32) -> Result<(), ChangeError> {
|
||||
if !self.can_change(pos, new_value)? {
|
||||
return Err(ChangeError::InvalidChange {
|
||||
pos,
|
||||
new_value,
|
||||
reason: "Change would break monotonic property".to_string(),
|
||||
});
|
||||
}
|
||||
|
||||
// Find existing jump at this position (if any)
|
||||
let existing_jump = self.jumps.iter()
|
||||
.position(|(jump_pos, _)| *jump_pos == pos);
|
||||
|
||||
match existing_jump {
|
||||
Some(idx) => {
|
||||
// We have a jump here already
|
||||
if self.get(pos - 1).unwrap() == new_value {
|
||||
// New value same as previous - remove jump
|
||||
self.jumps.remove(idx);
|
||||
} else {
|
||||
// Update jump value
|
||||
self.jumps[idx].1 = new_value;
|
||||
}
|
||||
}
|
||||
None => {
|
||||
// No jump here yet
|
||||
if self.get(pos - 1).unwrap() != new_value {
|
||||
// Value different from previous - insert new jump
|
||||
let insert_pos = self.jumps.partition_point(|(jump_pos, _)| *jump_pos < pos);
|
||||
self.jumps.insert(insert_pos, (pos, new_value));
|
||||
}
|
||||
// If same as previous, no jump needed
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Convert to regular vector
|
||||
pub fn to_vec(&self) -> Vec<u32> {
|
||||
let mut result = Vec::with_capacity(self.length);
|
||||
let mut last_jump = 0;
|
||||
let mut current_value = self.jumps[0].1;
|
||||
|
||||
for pos in 0..self.length {
|
||||
// Check if we're at a new jump point
|
||||
if last_jump + 1 < self.jumps.len() && pos == self.jumps[last_jump + 1].0 {
|
||||
last_jump += 1;
|
||||
current_value = self.jumps[last_jump].1;
|
||||
}
|
||||
result.push(current_value);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_basic_operations() {
|
||||
// Create [0,0,1,1,2,2]
|
||||
let mut seq = MonotonicSequence::new(0, 6);
|
||||
seq.change(2, 1).unwrap();
|
||||
seq.change(4, 2).unwrap();
|
||||
|
||||
assert_eq!(seq.get(0), Some(0));
|
||||
assert_eq!(seq.get(1), Some(0));
|
||||
assert_eq!(seq.get(2), Some(1));
|
||||
assert_eq!(seq.get(3), Some(1));
|
||||
assert_eq!(seq.get(4), Some(2));
|
||||
assert_eq!(seq.get(5), Some(2));
|
||||
assert_eq!(seq.get(6), None);
|
||||
|
||||
assert_eq!(seq.to_vec(), vec![0,0,1,1,2,2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_invalid_changes() {
|
||||
let mut seq = MonotonicSequence::new(0, 6);
|
||||
seq.change(2, 1).unwrap();
|
||||
seq.change(4, 2).unwrap();
|
||||
|
||||
// Can't decrease by more than 1
|
||||
assert!(seq.can_change(4, 0).is_err());
|
||||
|
||||
// Can't increase by more than 1
|
||||
assert!(seq.can_change(1, 2).is_err());
|
||||
|
||||
// Can't create invalid sequence
|
||||
assert!(seq.change(3, 0).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_modify_jumps() {
|
||||
let mut seq = MonotonicSequence::new(0, 6);
|
||||
seq.change(2, 1).unwrap();
|
||||
seq.change(4, 2).unwrap();
|
||||
|
||||
// Remove jump by setting to previous value
|
||||
seq.change(2, 0).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0,0,0,0,2,2]);
|
||||
|
||||
// Move jump point
|
||||
seq.change(3, 1).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0,0,0,1,2,2]);
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,11 @@ use db::DB;
|
||||
// use db2::{DBError, DB as DB2};
|
||||
|
||||
pub mod db;
|
||||
pub mod db2;
|
||||
#[allow(dead_code)]
|
||||
mod db2;
|
||||
#[allow(dead_code)]
|
||||
mod db3;
|
||||
pub mod monotonic_sequence;
|
||||
|
||||
pub fn lcs_gen(str1: &str, str2: &str) -> Vec<Vec<u32>> {
|
||||
let c1: Vec<char> = str1.chars().collect();
|
||||
|
||||
@@ -0,0 +1,735 @@
|
||||
//! claude cooked
|
||||
//! most of code is me? no most of code is claude
|
||||
|
||||
use std::cmp::Ordering;
|
||||
|
||||
#[derive(Default, Debug, Clone, PartialEq)]
|
||||
pub struct MonotonicSequence {
|
||||
/// Stores (position, value) pairs where value increases
|
||||
/// Always includes (0, initial_value) as first element
|
||||
// storing values this time even tho index exists (less confusing)
|
||||
jumps: Vec<(usize, u32)>,
|
||||
/// Length of the sequence
|
||||
length: usize,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
pub enum SequenceError {
|
||||
OutOfBounds {
|
||||
pos: usize,
|
||||
length: usize,
|
||||
},
|
||||
ValueTooLow {
|
||||
pos: usize,
|
||||
attempted: u32,
|
||||
min_allowed: u32, // based on previous value
|
||||
},
|
||||
ValueTooHigh {
|
||||
pos: usize,
|
||||
attempted: u32,
|
||||
max_allowed: u32, // based on next value constraints
|
||||
},
|
||||
}
|
||||
|
||||
impl MonotonicSequence {
|
||||
/// Create new sequence starting with given value
|
||||
pub fn with(initial_value: u32, length: usize) -> Self {
|
||||
// can initial value be whatever? should it only be 0?
|
||||
Self {
|
||||
jumps: vec![(0, initial_value)],
|
||||
length,
|
||||
// only push / pop / truncate / drain! can be implemented
|
||||
// should change this
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new() -> Self{Default::default()}
|
||||
// jumps function
|
||||
/// `self.jumps[result of this function]` to get info
|
||||
fn get_jump_index(&self, pos: usize) -> usize {
|
||||
match self.jumps.binary_search_by(|(jump_point, _value)| {
|
||||
if *jump_point <= pos {
|
||||
Ordering::Less
|
||||
} else {
|
||||
Ordering::Greater
|
||||
}
|
||||
}) {
|
||||
// we are literally At a jump point
|
||||
Ok(index) => index,
|
||||
// Below Zero
|
||||
Err(0) => 0,
|
||||
// debug_assert_ne!(index, 0); // confident
|
||||
Err(index) => index - 1,
|
||||
}
|
||||
}
|
||||
/// Get value at position
|
||||
///
|
||||
/// this would return none if pos == self.len()
|
||||
pub fn get(&self, pos: usize) -> Option<u32> {
|
||||
// check for bounds
|
||||
if pos >= self.length {
|
||||
return None;
|
||||
};
|
||||
// find the place to put
|
||||
Some(self.jumps[self.get_jump_index(pos)].1)
|
||||
}
|
||||
/// a superset of can_set, giving no fucks about self.length.
|
||||
// code in can_set moved to here
|
||||
fn can_be(&self, pos: usize) -> (u32, u32) {
|
||||
// let _current_value = self.get(pos).unwrap(); // in bound,
|
||||
|
||||
// this new value must be:
|
||||
// in the middle of previous value and next value.
|
||||
// if prev is 2, next is 4, this must be 3
|
||||
// if prev is 2, next is 3, this can be 2 or 3
|
||||
// if prev is 2, next is 2, this must be 2
|
||||
|
||||
let previous_value = if pos > 0 {
|
||||
self.get(pos - 1).unwrap() // len cant be 0 from above check
|
||||
} else {
|
||||
// pos is 0
|
||||
let current_value = self.jumps[0].1;
|
||||
|
||||
let next_or_current = self
|
||||
.get(1) // literally have one value, so first is also last
|
||||
.unwrap_or(current_value + 1); // so uh i believe the first value can be whatever
|
||||
|
||||
// why not current_valu + 1?
|
||||
// wellllll... what if self.get(1) == self.get(0)?? no you cant increase.
|
||||
return (current_value, next_or_current); // huh
|
||||
};
|
||||
|
||||
let next_value = if pos < self.length - 1
|
||||
// will this support self.length if we remove - 1? no
|
||||
// infact its already supported if we allow this code to be run in the first place:
|
||||
// index len - 1 (or index len if we are pushing) they dont have no next value
|
||||
{
|
||||
self.get(pos + 1).unwrap()
|
||||
} else {
|
||||
// pos is at last item
|
||||
let len = self.jumps.len();
|
||||
let current_value = self.jumps[len - 1].1;
|
||||
return (current_value, current_value + 1);
|
||||
};
|
||||
|
||||
// let _previous_valid = new_value == previous_value || new_value == previous_value + 1;
|
||||
// let _next_valid = new_value == next_value || new_value == next_value - 1;
|
||||
let middle_only = if next_value - previous_value == 2 {
|
||||
1
|
||||
} else {
|
||||
0
|
||||
};
|
||||
// safe no overflow: next value >= previous value, but if by 2 then next value must be at least 2
|
||||
(previous_value + middle_only, next_value - middle_only) // i dont have to care about actually using new value? what?
|
||||
}
|
||||
|
||||
/// What values can we set to at position pos?
|
||||
pub fn can_set(&self, pos: usize, _new_value: u32) -> Result<(u32, u32), SequenceError> {
|
||||
if pos >= self.length {
|
||||
return Err(SequenceError::OutOfBounds {
|
||||
pos,
|
||||
length: self.length,
|
||||
});
|
||||
}
|
||||
// changed: moved, remove ok put here instead // why do i not commit frequently
|
||||
Ok(self.can_be(pos))
|
||||
}
|
||||
// Can we change value at position to new_value?
|
||||
|
||||
// rather normal impl more normal than above
|
||||
pub fn can_set_2(&self, pos: usize, new_value: u32) -> Result<bool, SequenceError> {
|
||||
let (min, max) = self.can_set(pos, new_value)?;
|
||||
Ok(min <= new_value && new_value <= max)
|
||||
// if 2, 4 which NEVER happens btw then can you not be 4? well but it never happens
|
||||
}
|
||||
|
||||
/// Change value at position
|
||||
pub fn set(&mut self, pos: usize, value: u32) -> Result<(), SequenceError> {
|
||||
let (min, max) = dbg!(self.can_set(pos, value)?); // already checked for bounds here
|
||||
if value < min {
|
||||
return Err(SequenceError::ValueTooLow {
|
||||
pos,
|
||||
attempted: value,
|
||||
min_allowed: min,
|
||||
});
|
||||
} else if value > max {
|
||||
return Err(SequenceError::ValueTooHigh {
|
||||
pos,
|
||||
attempted: value,
|
||||
max_allowed: max,
|
||||
});
|
||||
} else if min == value && max == value {
|
||||
return Ok(());
|
||||
}
|
||||
// every single singular instance of in between is solved
|
||||
// [2, (3), 4] min == max == 3
|
||||
|
||||
let current_value = self.get(pos).unwrap(); // maybe a duplicate
|
||||
if value == current_value {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// now current_value needs to change to value.
|
||||
// case 1.
|
||||
// value == min, so current value MUST be max. like how else
|
||||
if value == min {
|
||||
let at = self.get_jump_index(pos);
|
||||
debug_assert_eq!(current_value, max);
|
||||
debug_assert_eq!(self.jumps[at].0, pos);
|
||||
let (ind, val) = self.jumps.get_mut(pos).unwrap(); // pos here is valid. already checked bounds
|
||||
|
||||
debug_assert_eq!(current_value, *val);
|
||||
*ind += 1;
|
||||
// if ind is self.length now then we need to pop
|
||||
if *ind >= self.length {
|
||||
let re_moved = self.jumps.pop(); // its just moved (+ 1) also its removed
|
||||
#[cfg(debug_assertions)]
|
||||
{
|
||||
if let Some(ind_and_val) = re_moved {
|
||||
debug_assert_eq!(ind_and_val, (self.length, max))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// case 2: value == max, current must be min
|
||||
else if value == max {
|
||||
debug_assert_eq!(current_value, min);
|
||||
// let at = self.get_jump_index(pos + 1);
|
||||
let Some((index, _val)) = dbg!(self.jumps.get_mut(pos + 1)) else {
|
||||
// pos + 1 is len
|
||||
// pos is the end. Not a jump point, as current_value == min
|
||||
debug_assert_eq!(self.length, pos + 1);
|
||||
self.jumps.push((pos, value));
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
assert_ne!(*index, 0);
|
||||
// we want to decrease my guy
|
||||
// but what if index == 1?
|
||||
// at that place current value == min, value == max ([(0),1,1,1])
|
||||
// so we just lower my guy and then pop first.
|
||||
|
||||
*index -= 1;
|
||||
|
||||
if *index == 0 {
|
||||
let val = *_val; // wow rust is cool guys
|
||||
let removed = self.jumps.remove(0);
|
||||
debug_assert_eq!(val - 1, current_value);
|
||||
assert_eq!(removed, (0, val - 1));
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
self.length
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.length == 0
|
||||
}
|
||||
|
||||
/// Convert to regular vector
|
||||
pub fn to_vec(&self) -> Vec<u32> {
|
||||
let mut result = Vec::with_capacity(self.length);
|
||||
let mut last_jump = 0;
|
||||
let mut current_value = self.jumps[0].1;
|
||||
|
||||
for pos in 0..self.length {
|
||||
// Check if we're at a new jump point
|
||||
if last_jump + 1 < self.jumps.len() && pos == self.jumps[last_jump + 1].0 {
|
||||
last_jump += 1;
|
||||
current_value = self.jumps[last_jump].1;
|
||||
}
|
||||
result.push(current_value);
|
||||
}
|
||||
|
||||
result
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_basic_operations() {
|
||||
// Create [0,0,1,1,2,2]
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.set(2, 1).unwrap();
|
||||
seq.set(4, 2).unwrap();
|
||||
|
||||
assert_eq!(seq.get(0), Some(0));
|
||||
assert_eq!(seq.get(1), Some(0));
|
||||
assert_eq!(seq.get(2), Some(1));
|
||||
assert_eq!(seq.get(3), Some(1));
|
||||
assert_eq!(seq.get(4), Some(2));
|
||||
assert_eq!(seq.get(5), Some(2));
|
||||
assert_eq!(seq.get(6), None);
|
||||
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_invalid_changes() {
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.length = 3; // temp
|
||||
dbg!(&seq);
|
||||
seq.set(2, 1).unwrap();
|
||||
seq.length = 5; // temp
|
||||
seq.set(4, 2).unwrap();
|
||||
seq.length = 6; // temp
|
||||
|
||||
// Can't decrease by more than 1
|
||||
assert!(!seq.can_set_2(4, 0).unwrap());
|
||||
|
||||
// Can't increase by more than 1
|
||||
assert!(!seq.can_set_2(1, 2).unwrap());
|
||||
|
||||
// Can't create invalid sequence
|
||||
assert!(seq.set(3, 0).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_modify_jumps() {
|
||||
let mut seq = MonotonicSequence::with(0, 6);
|
||||
seq.length = 3; // temp
|
||||
seq.set(2, 1).unwrap();
|
||||
seq.length = 5; // temp
|
||||
seq.set(4, 2).unwrap();
|
||||
seq.length = 6; // temp
|
||||
|
||||
seq.set(2, 0).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 0, 0, 1, 2, 2]);
|
||||
|
||||
seq.set(1, 1).unwrap();
|
||||
assert_eq!(seq.to_vec(), vec![0, 1, 1, 1, 2, 2]);
|
||||
}
|
||||
}
|
||||
|
||||
// /// working as intended: i am happy
|
||||
// #[cfg(test)]
|
||||
// mod lda_test {
|
||||
// use super::MonotonicSequence;
|
||||
// #[test]
|
||||
// fn db_to_vec() {
|
||||
// let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![(0, 0), (4, 1), (8, 2), (12, 3), (14, 4)];
|
||||
// let clen = 16;
|
||||
// assert_eq!(clen as usize, c.len());
|
||||
// let ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: clen,
|
||||
// };
|
||||
// assert!(ctodb.validate().is_ok());
|
||||
// assert_eq!(ctodb.to_vec(), c);
|
||||
// }
|
||||
// #[test]
|
||||
// fn pop_and_get() {
|
||||
// let ctodb = vec![(0, 0), (4, 1), (8, 2), (12, 3), (14, 4)];
|
||||
// let clen = 17;
|
||||
// let mut db = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: clen,
|
||||
// };
|
||||
// assert_eq!(db.get(4), Some(1));
|
||||
// assert_eq!(db.get(12), Some(3));
|
||||
// assert_eq!(db.get(18), None);
|
||||
// assert_eq!(db.get(0), Some(0));
|
||||
// assert_eq!(db.get(17), None);
|
||||
// assert_eq!(db.get(16), Some(4));
|
||||
// // assert_eq!(db.pop(), Some(4));
|
||||
|
||||
// // println!("length:{} jumps: {:?} vec: {:?}",db.len(), db.jumps, db.vec());
|
||||
// // while let Some(_) = db.pop() {
|
||||
// // println!("length:{} jumps: {:?} vec: {:?}",db.len(), db.jumps, db.vec());
|
||||
|
||||
// // };
|
||||
// let mut vec = db.to_vec();
|
||||
// while db.len() > 0 {
|
||||
// assert_eq!(db.pop(), vec.pop())
|
||||
// }
|
||||
// assert_eq!(db.pop(), vec.pop());
|
||||
// assert_eq!(db.len(), 0);
|
||||
// }
|
||||
// #[test]
|
||||
// fn last() {
|
||||
// let db = MonotonicSequence::new();
|
||||
// assert_eq!(db.len(), 0);
|
||||
// assert!(db.last_item().is_none());
|
||||
|
||||
// let db = MonotonicSequence::with(0, 1);
|
||||
// assert!(matches!(db.last_item(), Some(0)));
|
||||
|
||||
// // assert!(db.pop() == 0);
|
||||
// // assert_eq!(db.len(), 0);
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn range_of() {
|
||||
// let ctodb = vec![4, 7, 9, 12, 15, 23, 27, 31, 38, 41];
|
||||
// let clen = 49;
|
||||
// let mut db = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: clen,
|
||||
// };
|
||||
// assert_eq!(db.range_of(0), Some(0..4));
|
||||
// assert_eq!(db.range_of(1), Some(4..7));
|
||||
// assert_eq!(db.range_of(11), None);
|
||||
// assert_eq!(db.range_of(10), Some(41..clen));
|
||||
// assert_eq!(db.pop(), Some(10));
|
||||
// assert_eq!(db.range_of(10), Some(41..clen - 1));
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn push() {
|
||||
// let mut db = MonotonicSequence::new();
|
||||
// let mut c = vec![];
|
||||
// let mut push = |i| {
|
||||
// db.push(i).unwrap();
|
||||
// c.push(i);
|
||||
// };
|
||||
// for _ in 0..6 {
|
||||
// push(0);
|
||||
// }
|
||||
// for _ in 0..3 {
|
||||
// push(1);
|
||||
// }
|
||||
// for _ in 0..5 {
|
||||
// push(2);
|
||||
// }
|
||||
// for _ in 0..2 {
|
||||
// push(3);
|
||||
// }
|
||||
// for _ in 0..1 {
|
||||
// push(4);
|
||||
// }
|
||||
// assert_eq!(db.to_vec(), c)
|
||||
// }
|
||||
// #[test]
|
||||
// // #[should_panic]
|
||||
// fn invalid_push() {
|
||||
// let mut db = MonotonicSequence::new();
|
||||
// // dbg!(&db.jumps);
|
||||
// db.push(1).unwrap();
|
||||
// // dbg!(&db.jumps);
|
||||
// for _ in 3..=11 {
|
||||
// db.push(1).unwrap();
|
||||
// }
|
||||
|
||||
// // dbg!(&db.jumps);
|
||||
// // dbg!(db.vec());
|
||||
// db.push(2).unwrap();
|
||||
// dbg!(db.len() != 0);
|
||||
// assert!(db.push(4).is_err());
|
||||
// }
|
||||
// #[test]
|
||||
// // #[should_panic]
|
||||
// fn invalid_push_2() {
|
||||
// let mut db = MonotonicSequence::new();
|
||||
// // dbg!(&db.jumps);
|
||||
|
||||
// db.push(0).unwrap();
|
||||
// db.push(1).unwrap();
|
||||
// // dbg!(&db.jumps);
|
||||
// // dbg!(db.to_vec());
|
||||
// db.push(2).unwrap();
|
||||
// dbg!(db.len() != 0);
|
||||
// assert!(db.push(1).is_err());
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn change() {
|
||||
// let mut c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let mut ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: c.len() as _,
|
||||
// };
|
||||
// let mut change = |i, v| {
|
||||
// ctodb.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
// change(13, 3);
|
||||
// change(3, 1);
|
||||
// change(7, 2);
|
||||
|
||||
// assert_eq!(
|
||||
// ctodb.jumps,
|
||||
// MonotonicSequence::try_from_vec(c).unwrap().jumps
|
||||
// )
|
||||
// }
|
||||
// #[test]
|
||||
// fn from_vec() {
|
||||
// let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: c.len() as _,
|
||||
// };
|
||||
// let c2 = MonotonicSequence::try_from_vec(c).unwrap();
|
||||
// assert_eq!(ctodb.jumps, c2.jumps);
|
||||
// assert_eq!(ctodb.len, c2.len);
|
||||
// }
|
||||
// #[test]
|
||||
// fn avail() {
|
||||
// let c = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
|
||||
// let ctodb = vec![4, 8, 12, 14];
|
||||
|
||||
// let ctodb = MonotonicSequence {
|
||||
// jumps: ctodb,
|
||||
// length: c.len() as _,
|
||||
// };
|
||||
// assert_eq!(ctodb.available_values(3), (Some([0, 1]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(7), (Some([1, 2]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(13), (Some([3, 4]), Some(false)));
|
||||
|
||||
// assert_eq!(ctodb.available_values(0), (Some([0, 0]), None));
|
||||
// assert_eq!(ctodb.available_values(4), (Some([0, 1]), Some(true)));
|
||||
// assert_eq!(ctodb.available_values(11), (Some([2, 3]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(12), (Some([2, 3]), Some(true)));
|
||||
// assert_eq!(ctodb.available_values(15), (Some([4, 5]), Some(false)));
|
||||
// assert_eq!(ctodb.available_values(16), (Some([4, 5]), Some(true)));
|
||||
// assert_eq!(ctodb.available_values(17), (None, None));
|
||||
// }
|
||||
// #[test]
|
||||
// fn avail_hard() {
|
||||
// let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let db = MonotonicSequence::try_from_vec(c).unwrap();
|
||||
// assert_eq!(db.available_values(0), (Some([0, 1]), None));
|
||||
// assert_eq!(db.available_values(1), (Some([1, 2]), None));
|
||||
// assert_eq!(db.available_values(11), (Some([11, 12]), None));
|
||||
// assert_eq!(db.available_values(12), (Some([12, 13]), Some(true)));
|
||||
// assert_eq!(db.available_values(13), (Some([13, 13]), None));
|
||||
// assert_eq!(db.available_values(15), (Some([13, 13]), None));
|
||||
// assert_eq!(db.available_values(16), (Some([13, 14]), Some(false)));
|
||||
// assert_eq!(db.available_values(17), (Some([13, 14]), Some(true)));
|
||||
// }
|
||||
// #[test]
|
||||
// fn change_hard() {
|
||||
// let mut c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// let change = |d: &mut MonotonicSequence, c: &mut Vec<u32>, i, v| {
|
||||
// d.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
|
||||
// change(&mut db, &mut c, 12, 12);
|
||||
// change(&mut db, &mut c, 16, 14);
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 13, 12);
|
||||
// change(&mut db, &mut c, 14, 12);
|
||||
// change(&mut db, &mut c, 11, 11);
|
||||
// change(&mut db, &mut c, 12, 11);
|
||||
// change(&mut db, &mut c, 13, 11);
|
||||
// change(&mut db, &mut c, 10, 10);
|
||||
// change(&mut db, &mut c, 11, 10);
|
||||
// change(&mut db, &mut c, 12, 10);
|
||||
// change(&mut db, &mut c, 9, 9);
|
||||
// change(&mut db, &mut c, 10, 9);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 11, 9);
|
||||
// change(&mut db, &mut c, 8, 8);
|
||||
// change(&mut db, &mut c, 9, 8);
|
||||
// change(&mut db, &mut c, 10, 8);
|
||||
// change(&mut db, &mut c, 7, 7);
|
||||
// change(&mut db, &mut c, 8, 7);
|
||||
// // change(&mut db, &mut c, 9, 7);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 6, 6);
|
||||
// change(&mut db, &mut c, 7, 6);
|
||||
// // change(&mut db, &mut c, 8, 6);
|
||||
// change(&mut db, &mut c, 5, 5);
|
||||
// change(&mut db, &mut c, 6, 5);
|
||||
// // change(&mut db, &mut c, 7, 5);
|
||||
// change(&mut db, &mut c, 4, 4);
|
||||
// change(&mut db, &mut c, 5, 4);
|
||||
// // change(&mut db, &mut c, 6, 4);
|
||||
// change(&mut db, &mut c, 3, 3);
|
||||
// change(&mut db, &mut c, 4, 3);
|
||||
// // change(&mut db, &mut c, 5, 3);
|
||||
// change(&mut db, &mut c, 2, 2);
|
||||
// change(&mut db, &mut c, 3, 2);
|
||||
// // change(&mut db, &mut c, 4, 2);
|
||||
// change(&mut db, &mut c, 1, 1);
|
||||
// // change(&mut db, &mut c, 2, 1);
|
||||
// // change(&mut db, &mut c, 3, 1);
|
||||
// change(&mut db, &mut c, 0, 0);
|
||||
// // change(&mut db, &mut c, 1, 0);
|
||||
// // change(&mut db, &mut c, 2, 0);
|
||||
// {
|
||||
// let db2 = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// println!("e: {c:?}, {:?}", db2.to_vec());
|
||||
// println!("{:?}", db);
|
||||
// assert_eq!(db, db2);
|
||||
// }
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn change_harder() {
|
||||
// let mut c = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13];
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// let change = |d: &mut MonotonicSequence, c: &mut Vec<u32>, i, v| {
|
||||
// d.change(i, v);
|
||||
// c[i as usize] = v;
|
||||
// };
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 12, 12);
|
||||
// println!("m: {:?}", db);
|
||||
// change(&mut db, &mut c, 16, 14);
|
||||
// {
|
||||
// println!("f: {c:?}");
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
|
||||
// change(&mut db, &mut c, 13, 12);
|
||||
// change(&mut db, &mut c, 14, 12);
|
||||
// change(&mut db, &mut c, 11, 11);
|
||||
// change(&mut db, &mut c, 12, 11);
|
||||
// change(&mut db, &mut c, 13, 11);
|
||||
// change(&mut db, &mut c, 10, 10);
|
||||
// change(&mut db, &mut c, 11, 10);
|
||||
// change(&mut db, &mut c, 12, 10);
|
||||
// change(&mut db, &mut c, 9, 9);
|
||||
// change(&mut db, &mut c, 10, 9);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 11, 9);
|
||||
// change(&mut db, &mut c, 8, 8);
|
||||
// change(&mut db, &mut c, 9, 8);
|
||||
// change(&mut db, &mut c, 10, 8);
|
||||
// change(&mut db, &mut c, 7, 7);
|
||||
// change(&mut db, &mut c, 8, 7);
|
||||
// // change(&mut db, &mut c, 9, 7);
|
||||
// {
|
||||
// println!("m: {:?}", db);
|
||||
// print!("{c:?}");
|
||||
// println!(
|
||||
// ", {:?}",
|
||||
// MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
|
||||
// );
|
||||
// }
|
||||
// change(&mut db, &mut c, 6, 6);
|
||||
// change(&mut db, &mut c, 7, 6);
|
||||
// // change(&mut db, &mut c, 8, 6);
|
||||
// change(&mut db, &mut c, 5, 5);
|
||||
// change(&mut db, &mut c, 6, 5);
|
||||
// // change(&mut db, &mut c, 7, 5);
|
||||
// change(&mut db, &mut c, 4, 4);
|
||||
// change(&mut db, &mut c, 5, 4);
|
||||
// // change(&mut db, &mut c, 6, 4);
|
||||
// change(&mut db, &mut c, 3, 3);
|
||||
// change(&mut db, &mut c, 4, 3);
|
||||
// // change(&mut db, &mut c, 5, 3);
|
||||
// change(&mut db, &mut c, 2, 2);
|
||||
// change(&mut db, &mut c, 3, 2);
|
||||
// // change(&mut db, &mut c, 4, 2);
|
||||
// change(&mut db, &mut c, 1, 1);
|
||||
// // change(&mut db, &mut c, 2, 1);
|
||||
// // change(&mut db, &mut c, 3, 1);
|
||||
// change(&mut db, &mut c, 0, 0);
|
||||
// // change(&mut db, &mut c, 1, 0);
|
||||
// // change(&mut db, &mut c, 2, 0);
|
||||
// {
|
||||
// let db2 = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// println!("e: {c:?}, {:?}", db2.to_vec());
|
||||
// println!("{:?}", db);
|
||||
// assert_eq!(db, db2);
|
||||
// }
|
||||
// }
|
||||
|
||||
// #[test]
|
||||
// fn prop_idk() {
|
||||
// let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// dbg!(&mut db).propagate_to_end(2, 2);
|
||||
// dbg!(&db);
|
||||
// println!("{:?}", db.to_vec());
|
||||
// assert_eq!(db.jumps, vec![0, 1]);
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
|
||||
// db.propagate_to_end(2, 3);
|
||||
// println!("{:?}", db.to_vec());
|
||||
// assert_eq!(db.jumps, vec![0, 1, 2]);
|
||||
// }
|
||||
// #[test]
|
||||
// fn prop() {
|
||||
// let base = [
|
||||
// 0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
|
||||
// 14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
|
||||
// 26, 26,
|
||||
// ];
|
||||
|
||||
// let prop = |bd: &mut MonotonicSequence, cc: &mut Vec<u32>, i, v: u32| {
|
||||
// cc.get_mut(i as usize..).unwrap().fill(v);
|
||||
// bd.propagate_to_end(i, v);
|
||||
// };
|
||||
// {
|
||||
// let mut c = base.to_vec();
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.to_vec()).unwrap();
|
||||
|
||||
// prop(&mut db, &mut c, 15, 7);
|
||||
// prop(&mut db, &mut c, 28, 8);
|
||||
|
||||
// println!("{db:?}, {c:?}");
|
||||
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// assert_eq!(db.to_vec(), c);
|
||||
// }
|
||||
// }
|
||||
// #[test]
|
||||
// #[should_panic]
|
||||
// fn prop_failcase() {
|
||||
// let base = [
|
||||
// 0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
|
||||
// 14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
|
||||
// 26, 26,
|
||||
// ];
|
||||
|
||||
// let prop = |bd: &mut MonotonicSequence, cc: &mut Vec<u32>, i, v: u32| {
|
||||
// cc.get_mut(i as usize..).unwrap().fill(v);
|
||||
// bd.propagate_to_end(i, v);
|
||||
// };
|
||||
// {
|
||||
// let mut c = base.to_vec();
|
||||
// let mut db = MonotonicSequence::try_from_vec(c.to_vec()).unwrap();
|
||||
|
||||
// // prop(&mut db, &mut c, 12, 6);
|
||||
// prop(&mut db, &mut c, 28, 14);
|
||||
|
||||
// println!("{db:?}, {c:?}");
|
||||
|
||||
// assert_eq!(db.to_vec(), c);
|
||||
// assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
@@ -245,12 +245,13 @@ where
|
||||
let mut dp = vec![vec![None; len2 + 1]; len1 + 1];
|
||||
|
||||
// Fill the base cases
|
||||
for i in 1..=len1 {
|
||||
dp[i][0] = Some(CostOperation {
|
||||
|
||||
dp.iter_mut().enumerate().skip(1).for_each(|(i, r)| {
|
||||
r[0] = Some(CostOperation {
|
||||
cost: i as i32,
|
||||
operation: Delete,
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
for j in 1..=len2 {
|
||||
dp[0][j] = Some(CostOperation {
|
||||
@@ -303,7 +304,7 @@ where
|
||||
(substitute_cost, sub_op),
|
||||
]
|
||||
.into_iter()
|
||||
.filter_map(|(c, o)| c.and_then(|c| Some((c, o))))
|
||||
.filter_map(|(c, o)| c.map(|c| (c, o)))
|
||||
.min_by_key(|c| c.0)
|
||||
.map(|(c, o)| CostOperation {
|
||||
cost: c,
|
||||
|
||||
+1
-1
@@ -31,7 +31,7 @@ impl std::fmt::Display for CostOperationVec<'_> {
|
||||
None => "bih".to_string(),
|
||||
};
|
||||
let longest = strind.len().max(strcost.len()).max(strop.len());
|
||||
let tabl = (longest + tab_len - 1) / tab_len; // these two lines
|
||||
let tabl = longest.div_ceil(tab_len); // these two lines
|
||||
let longer = tabl * tab_len + tab_len - 1; // work so idc
|
||||
let tabind = (longer - strind.len()) / tab_len;
|
||||
let tabcost = (longer - strcost.len()) / tab_len;
|
||||
|
||||
Reference in new issue
Block a user