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,984 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 131 132 133 134 135 136 137 138 139 140 141 142 143 | use vstd::prelude::*;
fn main() {}
verus! {
pub struct Solution;
impl Solution {
pub open spec fn max_diag_val(nums: Seq<Vec<i32>>, i: int) -> int
decreases nums.len() - i
{
if i >= nums.len() {
0int
} else {
let d = i + nums[i].len() - 1;
let rest = Self::max_diag_val(nums, i + 1);
if d > rest { d } else { rest }
}
}
pub open spec fn diag_seg(nums: Seq<Vec<i32>>, d: int, hi: int, lo: int) -> Seq<i32>
decreases (if hi >= lo && hi >= 0 { hi - lo + 1 } else { 0 }) as nat
{
if hi < lo || hi < 0 {
Seq::<i32>::empty()
} else {
let j = d - hi;
let head = if hi < nums.len() && 0 <= j && j < nums[hi].len() {
seq![nums[hi][j]]
} else {
Seq::<i32>::empty()
};
head + Self::diag_seg(nums, d, hi - 1, lo)
}
}
pub open spec fn total_len(nums: Seq<Vec<i32>>, i: int) -> int
decreases i
{
if i <= 0 { 0int } else { Self::total_len(nums, i - 1) + nums[i - 1].len() as int }
}
pub open spec fn diag_order(nums: Seq<Vec<i32>>, max_d: int) -> Seq<i32>
decreases (if max_d >= 0 { max_d + 1 } else { 0 }) as nat
{
if max_d < 0 {
Seq::<i32>::empty()
} else {
let m = nums.len() as int;
let start_i = if max_d < m { max_d } else { m - 1 };
Self::diag_order(nums, max_d - 1) + Self::diag_seg(nums, max_d, start_i, 0)
}
}
pub fn find_diagonal_order(nums: Vec<Vec<i32>>) -> (result: Vec<i32>)
requires
1 <= nums@.len() <= 100000,
forall |i: int| 0 <= i < nums@.len() ==>
1 <= (#[trigger] nums@[i]).len() <= 100000,
forall |i: int, j: int| 0 <= i < nums@.len() && 0 <= j < nums@[i].len() ==>
1 <= (#[trigger] nums@[i][j]) <= 100000,
1 <= Self::total_len(nums@, nums@.len() as int) <= 100000,
ensures
result@ == Self::diag_order(nums@, Self::max_diag_val(nums@, 0)),
{
let m = nums.len();
let mut max_d: usize = 0;
let mut i: usize = m;
while i > 0 {
i = i - 1;
let d = i + nums[i].len() - 1;
if d > max_d {
max_d = d;
}
}
let mut count: Vec<usize> = Vec::new();
let mut k: usize = 0;
while k <= max_d {
count.push(0);
k = k + 1;
}
let mut i2: usize = 0;
while i2 < m {
let row_len = nums[i2].len();
let mut j: usize = 0;
while j < row_len {
let d = i2 + j;
count[d] = count[d] + 1;
j = j + 1;
}
i2 = i2 + 1;
}
let mut offset: Vec<usize> = Vec::new();
offset.push(0);
let mut k2: usize = 0;
while k2 <= max_d {
let next = offset[k2] + count[k2];
offset.push(next);
k2 = k2 + 1;
}
let total = offset[max_d + 1];
let mut result: Vec<i32> = Vec::new();
let mut z: usize = 0;
while z < total {
result.push(0);
z = z + 1;
}
let mut cursor: Vec<usize> = Vec::new();
let mut k3: usize = 0;
while k3 <= max_d {
cursor.push(offset[k3 + 1]);
k3 = k3 + 1;
}
let mut i3: usize = 0;
while i3 < m {
let row_len3 = nums[i3].len();
let mut j3: usize = 0;
while j3 < row_len3 {
let d = i3 + j3;
let old_cursor_d = cursor[d];
cursor[d] = cursor[d] - 1;
let val = nums[i3][j3];
result.set(cursor[d], val);
j3 = j3 + 1;
}
i3 = i3 + 1;
}
result
}
}
}
|