mod minimum_window_substring;

use minimum_window_substring::Solution;

let s1 = "aa".to_string();

let s2 = "aa".to_string();

let result = Solution::min_window(s1, s2);

use std::collections::HashMap;

pub struct Solution {}

impl Solution {

pub fn min_window(s: String, t: String) -> String {

if t.len() == 0 || t.len() > s.len() {

return "".to_string();

}

let mut map: HashMap<char, i32> = HashMap::new();

let mut window: HashMap<char, i32> = HashMap::new();

let s_chars: Vec<char> = s.chars().collect();

for c in t.chars() {

map.entry(c).and_modify(|e| *e += 1).or_insert(1);

}

let mut have = 0;

let need = map.len();

let mut result: (i32, i32) = (-1, -1);

let mut length = i32::MAX;

let mut lp = 0;

for rp in 0..s.len() {

let c = s_chars[rp];

window.entry(c).and_modify(|e| *e += 1).or_insert(1);

if map.contains_key(&c) {

let window_count = window.get(&c).unwrap();

let map_count = map.get(&c).unwrap();

if *window_count == *map_count {

have += 1;

}

}

while have == need {

if (rp - lp) as i32 + 1 < length {

result = (lp as i32, rp as i32);

length = (rp - lp + 1) as i32;

}

window.entry(s_chars[lp]).and_modify(|e| *e -= 1);

if map.contains_key(&s_chars[lp]) {

let window_count = window.get(&s_chars[lp]).unwrap();

let map_count = map.get(&s_chars[lp]).unwrap();

if window_count < map_count {

have -= 1;

}

}

lp += 1;

}

}

if length != i32::MAX {

s[result.0 as usize..result.1 as usize + 1].to_string()

} else {

"".to_string()

}

}

use std::collections::HashMap;

pub struct Solution {}

impl Solution {

pub fn check_inclusion(s1: String, s2: String) -> bool {

let mut result: bool = true;

let mut s1_map: HashMap<char, i32> = HashMap::new();

let mut s2_map: HashMap<char, i32> = HashMap::new();

let s1_chars: Vec<char> = s1.chars().collect();

let s2_chars: Vec<char> = s2.chars().collect();

let alphabet = vec![

'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',

'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

];

for i in 0..s1.len() {

s1_map

.entry(s1_chars[i])

.and_modify(|e| *e += 1)

.or_insert(1);

s2_map

.entry(s2_chars[i])

.and_modify(|e| *e += 1)

.or_insert(1);

}

let mut matches = 0;

for val in alphabet {

if s1_map.contains_key(&val) && s2_map.contains_key(&val) {

matches += 1;

}

}

let mut lp = 0;

for rp in s1_chars.len()..s2_chars.len() {

if matches == 26 {

return true;

}

if s1_map.entry(rp as i32) == s2_map.entry(rp as i32) {

matches += 1;

} else if s1_map.entry(rp as i32) + 1 == s2_map.entry(rp as i32) {

matches -= 1;

}

}

result

}