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:
File size: 3,509 Bytes
b2a430f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn sorted(s: Seq<i32>) -> bool {
forall|i: int, j: int| 0 <= i < j < s.len() ==> s[i] <= s[j]
}
pub open spec fn count_occ(s: Seq<i32>, val: i32) -> int
decreases s.len(),
{
if s.len() == 0 { 0 }
else {
(if s.last() == val { 1int } else { 0int })
+ Self::count_occ(s.drop_last(), val)
}
}
pub open spec fn is_perm(a: Seq<i32>, b: Seq<i32>) -> bool {
a.len() == b.len() && forall|v: i32| Self::count_occ(a, v) == Self::count_occ(b, v)
}
pub open spec fn even_index_sum(s: Seq<i32>) -> int
decreases s.len(),
{
if s.len() < 1 {
0int
} else if s.len() < 2 {
s[0] as int
} else {
s[0] as int + Self::even_index_sum(s.subrange(2, s.len() as int))
}
}
fn ms_merge(a: &Vec<i32>, b: &Vec<i32>) -> (result: Vec<i32>)
requires Self::sorted(a@), Self::sorted(b@)
ensures
Self::sorted(result@),
result@.len() == a@.len() + b@.len(),
Self::is_perm(result@, a@ + b@),
{
let mut result: Vec<i32> = Vec::new();
let mut i: usize = 0;
let mut j: usize = 0;
while i < a.len() || j < b.len()
{
if i < a.len() && (j >= b.len() || a[i] <= b[j]) {
result.push(a[i]);
i = i + 1;
} else {
result.push(b[j]);
j = j + 1;
}
}
result
}
fn ms_sort(nums: &Vec<i32>) -> (result: Vec<i32>)
ensures
Self::sorted(result@),
Self::is_perm(result@, nums@),
{
let n = nums.len();
if n <= 1 {
let mut result = Vec::new();
if n == 1 {
result.push(nums[0]);
}
return result;
}
let mid = n / 2;
let mut left: Vec<i32> = Vec::new();
let mut i: usize = 0;
while i < mid
{
left.push(nums[i]);
i = i + 1;
}
let mut right: Vec<i32> = Vec::new();
let mut j: usize = mid;
while j < n
{
right.push(nums[j]);
j = j + 1;
}
let sorted_left = Self::ms_sort(&left);
let sorted_right = Self::ms_sort(&right);
let result = Self::ms_merge(&sorted_left, &sorted_right);
result
}
pub fn max_coins(piles: Vec<i32>) -> (result: i32)
requires
3 <= piles.len() <= 100000,
piles.len() % 3 == 0,
forall|i: int| 0 <= i < piles.len() ==> 1 <= #[trigger] piles[i] <= 10000,
ensures
exists|sorted_piles: Seq<i32>|
Self::sorted(sorted_piles)
&& sorted_piles.len() == piles.len()
&& Self::is_perm(sorted_piles, piles@)
&& result as int == Self::even_index_sum(
sorted_piles.subrange(
(sorted_piles.len() / 3) as int,
sorted_piles.len() as int,
),
),
{
let sorted = Self::ms_sort(&piles);
let n = sorted.len();
let mut sum: i32 = 0;
let third = n / 3;
let mut k = third;
while k < n {
sum = sum + sorted[k];
k = k + 2;
}
sum
}
}
}
|