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 pref_sum(a: Seq<i64>, idx: int) -> int | |
| recommends | |
| 0 <= idx <= a.len(), | |
| decreases idx, | |
| { | |
| if idx <= 0 { | |
| 0int | |
| } else { | |
| pref_sum(a, idx - 1) + a[idx - 1] as int | |
| } | |
| } | |
| pub open spec fn leftmost_l(s: Seq<u8>, lo: int, hi: int) -> int | |
| recommends | |
| 0 <= lo <= hi <= s.len(), | |
| decreases if hi > lo { hi - lo } else { 0int }, | |
| { | |
| if lo >= hi { | |
| -1int | |
| } else if s[lo] == 1u8 { | |
| lo | |
| } else { | |
| leftmost_l(s, lo + 1, hi) | |
| } | |
| } | |
| pub open spec fn rightmost_r(s: Seq<u8>, lo: int, hi: int) -> int | |
| recommends | |
| 0 <= lo <= hi <= s.len(), | |
| decreases if hi > lo { hi - lo } else { 0int }, | |
| { | |
| if lo >= hi { | |
| -1int | |
| } else if s[hi - 1] == 2u8 { | |
| hi - 1 | |
| } else { | |
| rightmost_r(s, lo, hi - 1) | |
| } | |
| } | |
| pub open spec fn greedy(a: Seq<i64>, s: Seq<u8>, lo: int, hi: int) -> int | |
| recommends | |
| a.len() == s.len(), | |
| 0 <= lo <= hi <= a.len(), | |
| decreases if hi > lo { hi - lo } else { 0int }, | |
| { | |
| let l = leftmost_l(s, lo, hi); | |
| let r = rightmost_r(s, lo, hi); | |
| if l < 0 || r < 0 || l >= r { | |
| 0int | |
| } else { | |
| (pref_sum(a, r + 1) - pref_sum(a, l)) + greedy(a, s, l + 1, r) | |
| } | |
| } | |
| impl Solution { | |
| pub fn max_score(a: Vec<i64>, s: Vec<u8>) -> (result: i64) | |
| requires | |
| 2 <= a.len() <= 200_000, | |
| a.len() == s.len(), | |
| forall|i: int| 0 <= i < a.len() ==> 1 <= a[i] <= 100_000, | |
| forall|i: int| 0 <= i < s.len() ==> s[i] == 1u8 || s[i] == 2u8, | |
| ensures | |
| result as int == greedy(a@, s@, 0, a.len() as int), | |
| { | |
| let n = a.len(); | |
| let mut prefix: Vec<i64> = Vec::with_capacity(n + 1); | |
| prefix.push(0); | |
| let mut i: usize = 0; | |
| while i < n { | |
| let next = prefix[i] + a[i]; | |
| prefix.push(next); | |
| i = i + 1; | |
| } | |
| let mut total: i64 = 0; | |
| let mut lo: usize = 0; | |
| let mut hi: usize = n; | |
| let mut keep_going: bool = true; | |
| while keep_going { | |
| while lo < hi && s[lo] != 1 { | |
| lo = lo + 1; | |
| } | |
| while lo < hi && s[hi - 1] != 2 { | |
| hi = hi - 1; | |
| } | |
| if lo + 1 < hi { | |
| total = total + prefix[hi] - prefix[lo]; | |
| lo = lo + 1; | |
| hi = hi - 1; | |
| } else { | |
| keep_going = false; | |
| } | |
| } | |
| total | |
| } | |
| } | |
| } | |