commiting cuz i'm bored

commiting every now and then

binary-subarrays-with-sum/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "binary-subarrays-with-sum"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

binary-subarrays-with-sum/src/main.rs

@@ -0,0 +1,30 @@
+fn main() {
+    println!("Hello, world!");
+    let nums = vec![1, 0, 1, 0, 1];
+    let goal = 2;
+    // Output: 4
+    println!("{}", num_subarrays_with_sum(nums, goal));
+    // let nums = vec![0, 0, 0, 0, 0];
+    // let goal = 0;
+    // // Output: 4
+    // println!("{}", num_subarrays_with_sum(nums, goal));
+}
+pub fn num_subarrays_with_sum(nums: Vec<i32>, goal: i32) -> i32 {
+    fn helper(x: i32, n: usize, nums: Vec<i32>) -> i32 {
+        if x < 0 {
+            return 0;
+        }
+        let mut res = 0;
+        let (mut l, mut cur) = (0, 0);
+        for r in 0..n {
+            cur += nums[r];
+            while cur > x {
+                cur -= nums[l];
+                l += 1;
+            }
+            res += r - l + 1;
+        }
+        res as _
+    }
+    helper(goal, nums.len(), nums.clone()) - helper(goal - 1, nums.len(), nums)
+}

contiguous-array/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "contiguous-array"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

contiguous-array/src/main.rs

@@ -0,0 +1,26 @@
+fn main() {
+    println!("Hello, world!");
+    let nums = vec![0, 0, 1, 0, 0, 0, 1, 1];
+    println!("{}", find_max_length(nums));
+}
+
+pub fn find_max_length(nums: Vec<i32>) -> i32 {
+    let n = nums.len();
+    // let mut prefix_sum = vec![0; n + 1];
+    let mut hm = std::collections::HashMap::from([(0, 0)]);
+    let mut cur_sum = 0;
+    let mut maximus = 0;
+    for i in 1..=n {
+        let num = if nums[i - 1] == 1 { 1 } else { -1 };
+        cur_sum = cur_sum + num;
+        println!("cur_sum={:?}", cur_sum);
+        if let Some(idx) = hm.get(&cur_sum) {
+            println!("idx={:?}", idx);
+            maximus = maximus.max(i - idx);
+        } else {
+            hm.insert(cur_sum, i);
+        };
+    }
+    println!("hm={:?}", hm);
+    maximus as _
+}

count-elements-with-maximum-frequency/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "count-elements-with-maximum-frequency"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

count-elements-with-maximum-frequency/src/main.rs

@@ -0,0 +1,23 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+pub fn max_frequency_elements(nums: Vec<i32>) -> i32 {
+    let mut hm = std::collections::HashMap::new();
+    for &num in nums.iter() {
+        *hm.entry(num).or_insert(0) += 1;
+    }
+    let (_, max) = hm.iter().max_by(|x, y| x.1.cmp(y.1)).unwrap();
+    println!("max={:?}", max);
+
+    let mut count = 0;
+    for num in nums { 
+        if let Some(s)      = hm.get(&num) {
+            if s == max {
+                count += 1;
+            }
+        }
+    }
+
+    count
+}

custom-sort-string/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "custom-sort-string"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

custom-sort-string/src/main.rs

@@ -0,0 +1,40 @@
+use std::{
+    cmp::Reverse,
+    collections::{BinaryHeap, HashMap},
+};
+
+fn main() {
+    println!("Hello, world!");
+    let order = "cba".to_string();
+    let s = "abcd".to_string();
+    let order = "kqep".to_string();
+    let s = "pekeq".to_string();
+
+    // Output:  "cbad"
+    println!("{}", custom_sort_string(order, s));
+}
+
+pub fn custom_sort_string(order: String, s: String) -> String {
+    let mut hm = HashMap::new();
+    for (i, c) in order.char_indices() {
+        hm.insert(c, i);
+    }
+    println!("{:?}", hm);
+    let mut bh = BinaryHeap::new();
+    for c in s.chars() {
+        if let Some(n) = hm.get(&c) {
+            bh.push((Reverse(*n as i32), c));
+        } else {
+            bh.push((Reverse(-1), c));
+        }
+    }
+    println!("{:?}", bh);
+    let mut f: Vec<_> = bh.iter().collect();
+    println!("f: {:?}", f);
+    f.sort_by(|&x, &y| y.0.cmp(&x.0));
+    // f.sort();
+    println!("{:?}", f);
+    let rezult: String = f.iter().map(|&x| x.1).collect();
+
+    rezult
+}

find-the-pivot-integer/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "find-the-pivot-integer"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

find-the-pivot-integer/src/main.rs

@@ -0,0 +1,24 @@
+fn main() {
+    println!("Hello, world!");
+    let n = 8;
+    println!("{}", pivot_integer(n));
+}
+
+pub fn pivot_integer(n: i32) -> i32 {
+    let n = n as usize;
+    let mut sum_vec = vec![0; n + 1];
+    for i in 1..=n {
+        sum_vec[i] = sum_vec[i - 1] + i;
+    }
+    // println!("sum_vec={:?}", sum_vec);
+    for i in 0..n {
+        let sum1 = sum_vec[i + 1];
+        // println!("sum1={:?}", sum1);
+        let sum2 = sum_vec[n] - sum_vec[i];
+        // println!("sum2={:?}", sum2);
+        if sum1 == sum2 {
+            return i as i32 + 1;
+        }
+    }
+    -1
+}

insert-interval/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "insert-interval"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

insert-interval/src/main.rs

@@ -0,0 +1,42 @@
+fn main() {
+    println!("Hello, world!");
+    let intervals = vec![
+        vec![1, 2],
+        vec![3, 5],
+        vec![6, 7],
+        vec![8, 10],
+        vec![12, 16],
+    ];
+    let new_interval = vec![4, 8];
+    // Output: [[1,2],[3,10],[12,16]]
+    println!("{:?}", insert(intervals, new_interval));
+    let intervals = vec![vec![1, 3], vec![6, 9]];
+    let new_interval = vec![2, 5];
+    println!("{:?}", insert(intervals, new_interval));
+    // Output: [[1,5],[6,9]]
+}
+pub fn insert(intervals: Vec<Vec<i32>>, new_interval: Vec<i32>) -> Vec<Vec<i32>> {
+    use std::cmp::{max, min};
+    let mut less = vec![];
+    let mut more = vec![];
+    let mut start = new_interval[0];
+    let mut end = new_interval[1];
+
+    for curr in intervals {
+        if curr[1] < new_interval[0] {
+            less.push(curr);
+        } else if curr[0] > new_interval[1] {
+            more.push(curr);
+        } else {
+            start = min(curr[0], start);
+            end = max(curr[1], end);
+        }
+        println!("less={:?}", less);
+        println!("more={:?}", more);
+        println!("start={:?}", start);
+        println!("end={:?}", end);
+    }
+    less.push(vec![start, end]);
+    less.append(&mut more);
+    less
+}

merge-in-between-linked-lists/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "merge-in-between-linked-lists"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

merge-in-between-linked-lists/src/main.rs

@@ -0,0 +1,46 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub struct ListNode {
+    pub val: i32,
+    pub next: Option<Box<ListNode>>,
+}
+
+impl ListNode {
+    #[inline]
+    fn new(val: i32) -> Self {
+        ListNode { next: None, val }
+    }
+}
+
+pub fn merge_in_between(
+    list1: Option<Box<ListNode>>,
+    a: i32,
+    b: i32,
+    mut list2: Option<Box<ListNode>>,
+) -> Option<Box<ListNode>> {
+    let mut head = list1.unwrap();
+    let mut current = head.as_mut();
+
+    for _ in 0..a - 1 {
+        current = current.next.as_mut().unwrap();
+    }
+    println!("current={:?}", current);
+
+    std::mem::swap(&mut current.next, &mut list2);
+    println!("current={:?}", current);
+    println!("list2={:?}", list2);
+
+    while current.next.is_some() {
+        current = current.next.as_mut().unwrap();
+    }
+    println!("current={:?}", current);
+    for _ in 0..b - a + 1 {
+        list2 = list2.unwrap().next;
+    }
+    println!("list2={:?}", list2);
+    current.next = list2;
+    Some(head)
+}

middle-of-the-linked-list/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "middle-of-the-linked-list"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]