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 value_occurs(permutation: Seq<i32>, value: int) -> bool { | |
| exists|pos: int| 0 <= pos < permutation.len() && permutation[pos] == value | |
| } | |
| pub open spec fn all_values_occur(permutation: Seq<i32>) -> bool { | |
| forall|value: int| 1 <= value <= permutation.len() ==> value_occurs(permutation, value) | |
| } | |
| pub open spec fn is_valid_permutation(permutation: Seq<i32>) -> bool { | |
| 1 <= permutation.len() <= 100_000 | |
| && forall|i: int| 0 <= i < permutation.len() ==> 1 <= permutation[i] <= permutation.len() | |
| && forall|i: int, j: int| 0 <= i < j < permutation.len() ==> permutation[i] != permutation[j] | |
| && all_values_occur(permutation) | |
| } | |
| pub open spec fn are_valid_queries(queries: Seq<i32>, n: int) -> bool { | |
| 1 <= queries.len() <= 100_000 | |
| && forall|i: int| 0 <= i < queries.len() ==> 1 <= queries[i] <= n | |
| } | |
| pub open spec fn position_of(permutation: Seq<i32>, value: int) -> int | |
| recommends | |
| is_valid_permutation(permutation), | |
| 1 <= value <= permutation.len(), | |
| { | |
| choose|pos: int| 0 <= pos < permutation.len() && permutation[pos] == value | |
| } | |
| pub open spec fn total_vasya(permutation: Seq<i32>, queries: Seq<i32>, k: int) -> int | |
| recommends | |
| is_valid_permutation(permutation), | |
| are_valid_queries(queries, permutation.len() as int), | |
| 0 <= k <= queries.len(), | |
| decreases k, | |
| { | |
| if k <= 0 { | |
| 0 | |
| } else { | |
| total_vasya(permutation, queries, k - 1) + position_of(permutation, queries[k - 1] as int) + 1 | |
| } | |
| } | |
| pub open spec fn total_petya(permutation: Seq<i32>, queries: Seq<i32>, k: int) -> int | |
| recommends | |
| is_valid_permutation(permutation), | |
| are_valid_queries(queries, permutation.len() as int), | |
| 0 <= k <= queries.len(), | |
| decreases k, | |
| { | |
| if k <= 0 { | |
| 0 | |
| } else { | |
| total_petya(permutation, queries, k - 1) + permutation.len() - position_of(permutation, queries[k - 1] as int) | |
| } | |
| } | |
| impl Solution { | |
| pub fn effective_approach(permutation: Vec<i32>, queries: Vec<i32>) -> (result: (i64, i64)) | |
| requires | |
| is_valid_permutation(permutation@), | |
| all_values_occur(permutation@), | |
| are_valid_queries(queries@, permutation.len() as int), | |
| ensures | |
| result.0 as int == total_vasya(permutation@, queries@, queries.len() as int), | |
| result.1 as int == total_petya(permutation@, queries@, queries.len() as int), | |
| { | |
| let n = permutation.len(); | |
| let mut positions = Vec::new(); | |
| let mut t = 0usize; | |
| while t <= n { | |
| positions.push(0i64); | |
| t += 1; | |
| } | |
| let mut i = 0usize; | |
| while i < n { | |
| let value = permutation[i] as usize; | |
| positions.set(value, i as i64 + 1); | |
| i += 1; | |
| } | |
| let mut vasya = 0i64; | |
| let mut petya = 0i64; | |
| let mut j = 0usize; | |
| while j < queries.len() { | |
| let value = queries[j] as usize; | |
| let p = positions[value]; | |
| vasya += p; | |
| petya += n as i64 - p + 1; | |
| j += 1; | |
| } | |
| (vasya, petya) | |
| } | |
| } | |
| } | |