Datasets:
Tasks:
Text Generation
Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
ArXiv:
Tags:
competitive-programming
code-generation
specification-generation
proof-generation
verification
rust
License:
| use vstd::prelude::*; | |
| fn main() {} | |
| verus! { | |
| pub struct Solution; | |
| pub open spec fn to_int_seq(s: Seq<i32>) -> Seq<int> { | |
| s.map(|_idx: int, x: i32| x as int) | |
| } | |
| pub open spec fn count_above(s: Seq<int>, t: int) -> int | |
| decreases s.len() | |
| { | |
| if s.len() == 0 { 0 } | |
| else { | |
| count_above(s.drop_last(), t) | |
| + if s.last() > t { s.last() - t } else { 0 } | |
| } | |
| } | |
| pub open spec fn value_above(s: Seq<int>, t: int) -> int | |
| decreases s.len() | |
| { | |
| if s.len() == 0 { 0 } | |
| else { | |
| value_above(s.drop_last(), t) | |
| + if s.last() > t { (s.last() + t + 1) * (s.last() - t) / 2 } else { 0 } | |
| } | |
| } | |
| impl Solution { | |
| fn count_above_exec(inventory: &Vec<i32>, threshold: i64) -> (count: i64) | |
| requires | |
| inventory.len() <= 100_000, | |
| forall |i: int| 0 <= i < inventory.len() ==> 1 <= inventory[i] <= 1_000_000_000, | |
| 0 <= threshold <= 1_000_000_000, | |
| ensures | |
| count as int == count_above(to_int_seq(inventory@), threshold as int), | |
| count >= 0, | |
| { | |
| let n = inventory.len(); | |
| let mut count: i64 = 0; | |
| let mut j: usize = 0; | |
| while j < n { | |
| if inventory[j] as i64 > threshold { | |
| count += inventory[j] as i64 - threshold; | |
| } | |
| j += 1; | |
| } | |
| count | |
| } | |
| pub fn max_profit(inventory: Vec<i32>, orders: i32) -> (result: i32) | |
| requires | |
| 1 <= inventory.len() <= 100_000, | |
| forall |i: int| 0 <= i < inventory.len() ==> 1 <= inventory[i] <= 1_000_000_000, | |
| 1 <= orders <= 1_000_000_000, | |
| orders as int <= count_above(to_int_seq(inventory@), 0), | |
| ensures | |
| exists |t: int| { | |
| &&& 0 <= t | |
| &&& count_above(to_int_seq(inventory@), t) <= orders as int | |
| &&& (t == 0 || count_above(to_int_seq(inventory@), t - 1) > orders as int) | |
| &&& result as int == (value_above(to_int_seq(inventory@), t) | |
| + (orders as int - count_above(to_int_seq(inventory@), t)) * t) | |
| % 1_000_000_007 | |
| }, | |
| { | |
| let n = inventory.len(); | |
| let orders_i64 = orders as i64; | |
| let modulo: i128 = 1_000_000_007; | |
| let mut max_inv: i64 = 0; | |
| let mut i: usize = 0; | |
| while i < n { | |
| if inventory[i] as i64 > max_inv { | |
| max_inv = inventory[i] as i64; | |
| } | |
| i += 1; | |
| } | |
| let mut lo: i64 = 0; | |
| let mut hi: i64 = max_inv; | |
| while lo < hi { | |
| let mid = lo + (hi - lo) / 2; | |
| let count = Self::count_above_exec(&inventory, mid); | |
| if count <= orders_i64 { | |
| hi = mid; | |
| } else { | |
| lo = mid + 1; | |
| } | |
| } | |
| let threshold = lo; | |
| let mut total: i128 = 0; | |
| let mut sold: i64 = 0; | |
| let mut k: usize = 0; | |
| while k < n { | |
| let inv = inventory[k] as i64; | |
| if inv > threshold { | |
| sold += inv - threshold; | |
| let inv128 = inv as i128; | |
| let thr128 = threshold as i128; | |
| let a = inv128 + thr128 + 1; | |
| let b = inv128 - thr128; | |
| let contrib = (inv128 + thr128 + 1) * (inv128 - thr128) / 2; | |
| total += contrib; | |
| } | |
| k += 1; | |
| } | |
| let rem128 = (orders_i64 - sold) as i128; | |
| let thr_rem = threshold as i128; | |
| total += rem128 * thr_rem; | |
| (total % modulo) as i32 | |
| } | |
| } | |
| } | |