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,751 Bytes
033007a | 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 | impl Solution {
fn ms_merge(a: &Vec<i32>, b: &Vec<i32>) -> Vec<i32> {
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(input: &Vec<i32>) -> Vec<i32> {
let n = input.len();
if n <= 1 {
let mut result = Vec::new();
if n == 1 {
result.push(input[0]);
}
return result;
}
let mid = n / 2;
let mut left: Vec<i32> = Vec::new();
let mut i: usize = 0;
while i < mid {
left.push(input[i]);
i = i + 1;
}
let mut right: Vec<i32> = Vec::new();
let mut j: usize = mid;
while j < n {
right.push(input[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
}
fn ms_merge_i64(a: &Vec<i64>, b: &Vec<i64>) -> Vec<i64> {
let mut result: Vec<i64> = 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_i64(input: &Vec<i64>) -> Vec<i64> {
let n = input.len();
if n <= 1 {
let mut result = Vec::new();
if n == 1 {
result.push(input[0]);
}
return result;
}
let mid = n / 2;
let mut left: Vec<i64> = Vec::new();
let mut i: usize = 0;
while i < mid {
left.push(input[i]);
i = i + 1;
}
let mut right: Vec<i64> = Vec::new();
let mut j: usize = mid;
while j < n {
right.push(input[j]);
j = j + 1;
}
let sorted_left = Self::ms_sort_i64(&left);
let sorted_right = Self::ms_sort_i64(&right);
let result = Self::ms_merge_i64(&sorted_left, &sorted_right);
result
}
pub fn max_sum_range_query(nums: Vec<i32>, requests: Vec<Vec<i32>>) -> i32 {
let n = nums.len();
let m = requests.len();
let modval: i64 = 1_000_000_007;
let mut diff: Vec<i64> = Vec::new();
let mut z: usize = 0;
while z < n {
diff.push(0);
z = z + 1;
}
let mut r: usize = 0;
while r < m {
let s = requests[r][0] as usize;
let e = requests[r][1] as usize;
diff[s] = diff[s] + 1;
if e + 1 < n {
diff[e + 1] = diff[e + 1] - 1;
}
r = r + 1;
}
let mut count: Vec<i64> = Vec::new();
let mut running: i64 = 0;
let mut idx: usize = 0;
while idx < n {
running = running + diff[idx];
count.push(running);
idx = idx + 1;
}
let nums = Self::ms_sort(&nums);
let sorted_count = Self::ms_sort_i64(&count);
let mut result: i64 = 0;
let mut k: usize = 0;
while k < n {
result = (result + nums[k] as i64 * sorted_count[k]) % modval;
k = k + 1;
}
result as i32
}
}
|