data/rust_corpus_qwen.jsonl

{"content": "/// Write a rsthon function to identify non-prime numbers.\nfn is_not_prime(n: isize) -> bool {\n    let mut result = false;\n    for i in 2..n {\n        if n % i == 0 {\n            result = true;\n        }\n    }\n    result\n}", "retrieval_text": "/// Write a rsthon function to identify non-prime numbers.\nfn is_not_prime(n: isize) -> bool {\n", "task": "mbpp_3_is_not_prime"}
{"content": "/// Write a function to find the n largest integers from a given vector of numbers, returned in descending order.\nfn heap_queue_largest(nums: Vec<isize>, n: isize) -> Vec<isize> {\n    let mut largest_nums: Vec<isize> = nums;\n    largest_nums.sort();\n    largest_nums.reverse();\n    largest_nums[0..n as usize].to_vec()\n}", "retrieval_text": "/// Write a function to find the n largest integers from a given vector of numbers, returned in descending order.\nfn heap_queue_largest(nums: Vec<isize>, n: isize) -> Vec<isize> {\n", "task": "mbpp_4_heap_queue_largest"}
{"content": "/// Write a rsthon function to check whether the two numbers differ at one bit position only or not.\nfn differ_At_One_Bit_Pos(a: isize, b: isize) -> bool {\n    if a == b {\n        return false;\n    }\n    return (a ^ b).count_ones() == 1;\n}", "retrieval_text": "/// Write a rsthon function to check whether the two numbers differ at one bit position only or not.\nfn differ_At_One_Bit_Pos(a: isize, b: isize) -> bool {\n", "task": "mbpp_6_differ_At_One_Bit_Pos"}
{"content": "/// Write a function to find squares of individual elements in a vector.\nfn square_nums(nums: Vec<isize>) -> Vec<isize> {\n    nums.iter().map(|x| x * x).collect()\n}", "retrieval_text": "/// Write a function to find squares of individual elements in a vector.\nfn square_nums(nums: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_8_square_nums"}
{"content": "/// Write a rsthon function to remove first and last occurrence of a given character from the string.\nfn remove_Occ(s: String, ch: String) -> String {\n    let mut s = s;\n    s = s.replace(ch.as_str(), \"\");\n    s = s.replace(ch.as_str(), \"\");\n    s\n}", "retrieval_text": "/// Write a rsthon function to remove first and last occurrence of a given character from the string.\nfn remove_Occ(s: String, ch: String) -> String {\n", "task": "mbpp_11_remove_Occ"}
{"content": "/// Write a function to sort a given matrix in ascending order according to the sum of its rows.\nfn sort_matrix(M: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n    let mut m = M.clone();\n    m.sort_by(|a, b| a.iter().sum::<isize>().cmp(&b.iter().sum::<isize>()));\n    m\n}", "retrieval_text": "/// Write a function to sort a given matrix in ascending order according to the sum of its rows.\nfn sort_matrix(M: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n", "task": "mbpp_12_sort_matrix"}
{"content": "/// Write a rsthon function to find the volume of a triangular prism.\nfn find_Volume(l: isize, b: isize, h: isize) -> isize {\n    (l * b * h) / 2\n}", "retrieval_text": "/// Write a rsthon function to find the volume of a triangular prism.\nfn find_Volume(l: isize, b: isize, h: isize) -> isize {\n", "task": "mbpp_14_find_Volume"}
{"content": "/// Write a function that returns the perimeter of a square given its side length as input.\nfn square_perimeter(a: isize) -> isize {\n    4 * a\n}", "retrieval_text": "/// Write a function that returns the perimeter of a square given its side length as input.\nfn square_perimeter(a: isize) -> isize {\n", "task": "mbpp_17_square_perimeter"}
{"content": "/// Write a function to remove characters from the first string which are present in the second string.\nfn remove_dirty_chars(string: String, second_string: String) -> String {\n\tlet mut dirty_chars: Vec<char> = second_string.chars().collect();\n\tlet mut result: String = String::new();\n\tlet mut char_count: [u8; 128] = [0; 128];\n\tfor c in dirty_chars.iter() {\n\t\tchar_count[*c as usize] = 1;\n\t}\n\n\tfor c in string.chars() {\n\t\tif char_count[c as usize] == 0 {\n\t\t\tresult.push(c);\n\t\t}\n\t}\n\n\tresult\n}", "retrieval_text": "/// Write a function to remove characters from the first string which are present in the second string.\nfn remove_dirty_chars(string: String, second_string: String) -> String {\n", "task": "mbpp_18_remove_dirty_chars"}
{"content": "/// Write a function to find whether a given vector of integers contains any duplicate element.\nfn test_duplicate(arraynums: Vec<isize>) -> bool {\n    let nums_set = arraynums.clone().into_iter().collect::<std::collections::HashSet<isize>>();\n    arraynums.len() != nums_set.len()\n}", "retrieval_text": "/// Write a function to find whether a given vector of integers contains any duplicate element.\nfn test_duplicate(arraynums: Vec<isize>) -> bool {\n", "task": "mbpp_19_test_duplicate"}
{"content": "/// Write a function to check if the given number is woodball or not.\nfn is_woodall(x: isize) -> bool {\n    if x % 2 == 0 {\n        return false;\n    }\n    let mut x = x + 1;\n    let mut p = 0;\n    while x % 2 == 0 {\n        x = x / 2;\n        p = p + 1;\n        if p == x {\n            return true;\n        }\n    }\n    false\n}", "retrieval_text": "/// Write a function to check if the given number is woodball or not.\nfn is_woodall(x: isize) -> bool {\n", "task": "mbpp_20_is_woodall"}
{"content": "/// Write a rsthon function to find the largest number that can be formed with the given vector of digits.\nfn find_Max_Num(arr: Vec<isize>) -> isize {\n    let mut arr: Vec<_> = arr.iter().map(|x| *x).collect();\n    arr.sort_by(|a, b| b.cmp(a));\n    let mut num = 0;\n    for i in 0..arr.len() {\n        num = num * 10 + arr[i];\n    }\n    return num;\n}", "retrieval_text": "/// Write a rsthon function to find the largest number that can be formed with the given vector of digits.\nfn find_Max_Num(arr: Vec<isize>) -> isize {\n", "task": "mbpp_57_find_Max_Num"}
{"content": "/// Write a rsthon function to check whether the given two integers have opposite sign or not.\nfn opposite_Signs(x: isize, y: isize) -> bool {\n    (x ^ y) < 0\n}", "retrieval_text": "/// Write a rsthon function to check whether the given two integers have opposite sign or not.\nfn opposite_Signs(x: isize, y: isize) -> bool {\n", "task": "mbpp_58_opposite_Signs"}
{"content": "/// Write a function to find the nth octagonal number.\nfn is_octagonal(n: isize) -> isize {\n\t3 * n * n - 2 * n\n}", "retrieval_text": "/// Write a function to find the nth octagonal number.\nfn is_octagonal(n: isize) -> isize {\n", "task": "mbpp_59_is_octagonal"}
{"content": "/// Write a rsthon function to find smallest number in a vector.\nfn smallest_num(xs: Vec<isize>) -> isize {\n    xs.iter().fold(isize::MAX, |a, &b| a.min(b))\n}", "retrieval_text": "/// Write a rsthon function to find smallest number in a vector.\nfn smallest_num(xs: Vec<isize>) -> isize {\n", "task": "mbpp_62_smallest_num"}
{"content": "/// Write a function to find the maximum difference between available pairs in the given tuple vector.\nfn max_difference(test_list: Vec<(isize, isize)>) -> isize {\n    let mut temp: Vec<isize> = Vec::new();\n\n    for (a, b) in test_list.iter() {\n        temp.push((b - a).abs());\n    }\n\n    *temp.iter().max().unwrap()\n}", "retrieval_text": "/// Write a function to find the maximum difference between available pairs in the given tuple vector.\nfn max_difference(test_list: Vec<(isize, isize)>) -> isize {\n", "task": "mbpp_63_max_difference"}
{"content": "/// Write a function to sort a vector of tuples using the second value of each tuple.\nfn subject_marks(subjectmarks: Vec<(String, isize)>) -> Vec<(String, isize)> {\n    let mut subject_marks = subjectmarks;\n    subject_marks.sort_by_key(|k| k.1);\n    subject_marks\n}", "retrieval_text": "/// Write a function to sort a vector of tuples using the second value of each tuple.\nfn subject_marks(subjectmarks: Vec<(String, isize)>) -> Vec<(String, isize)> {\n", "task": "mbpp_64_subject_marks"}
{"content": "/// Write a rsthon function to count the number of positive numbers in a vector.\nfn pos_count(list: Vec<isize>) -> isize {\n  let mut pos_count = 0;\n  for num in list {\n    if num >= 0 {\n      pos_count += 1;\n    }\n  }\n  pos_count\n}", "retrieval_text": "/// Write a rsthon function to count the number of positive numbers in a vector.\nfn pos_count(list: Vec<isize>) -> isize {\n", "task": "mbpp_66_pos_count"}
{"content": "/// Write a rsthon function to check whether the given vector is monotonic or not.\nfn is_Monotonic(A: Vec<isize>) -> bool {\n    if A.len() == 1 {\n        return true;\n    }\n    let mut incr = true;\n    let mut decr = true;\n    for i in 0..A.len() - 1 {\n        if A[i] > A[i + 1] {\n            incr = false;\n        }\n        if A[i] < A[i + 1] {\n            decr = false;\n        }\n    }\n    (incr || decr)\n}", "retrieval_text": "/// Write a rsthon function to check whether the given vector is monotonic or not.\nfn is_Monotonic(A: Vec<isize>) -> bool {\n", "task": "mbpp_68_is_Monotonic"}
{"content": "/// Write a function to check whether a vector contains the given subvector or not.\nfn is_sublist(l: Vec<isize>, s: Vec<isize>) -> bool {\n    if s.is_empty() { return true; }\n\n    for (i, &x) in l.iter().enumerate() {\n        if s[0] == x {\n            let mut n = 1;\n            while n < s.len() && l[i+n] == s[n] {\n                n += 1;\n            }\n            if n == s.len() {\n                return true;\n            }\n        }\n    }\n    return false;\n}", "retrieval_text": "/// Write a function to check whether a vector contains the given subvector or not.\nfn is_sublist(l: Vec<isize>, s: Vec<isize>) -> bool {\n", "task": "mbpp_69_is_sublist"}
{"content": "/// Write a function to find whether all the given vectors have equal length or not.\nfn get_equal(Input: Vec<Vec<isize>>) -> bool {\n    Input.iter().fold(true, |f, tuple| f & (tuple.len() == Input[0].len()))\n}", "retrieval_text": "/// Write a function to find whether all the given vectors have equal length or not.\nfn get_equal(Input: Vec<Vec<isize>>) -> bool {\n", "task": "mbpp_70_get_equal"}
{"content": "/// Write a rsthon function to check whether the given number can be represented as the difference of two squares or not.\nfn dif_Square(n: isize) -> bool {\n    n % 4 != 2\n}", "retrieval_text": "/// Write a rsthon function to check whether the given number can be represented as the difference of two squares or not.\nfn dif_Square(n: isize) -> bool {\n", "task": "mbpp_72_dif_Square"}
{"content": "/// Write a function to check whether it follows the sequence given in the patterns vector.\nfn is_samepatterns(colors: Vec<String>, patterns: Vec<String>) -> bool {\n    if colors.len() != patterns.len() {\n        return false;\n    }\n\n    let mut sdict = std::collections::HashMap::new();\n    let mut pset: std::collections::HashSet<_> = patterns.iter().collect();\n    let mut sset: std::collections::HashSet<_> = colors.iter().collect();\n\n    if pset.len() != sset.len() {\n        return false;\n    }\n\n    for (i, pattern) in patterns.iter().enumerate() {\n        let values = sdict.entry(pattern).or_insert_with(Vec::new);\n        values.push(colors[i].clone());\n    }\n\n    for values in sdict.values() {\n        if values[0] != values[values.len() - 1] {\n            return false;\n        }\n    }\n\n    true\n}", "retrieval_text": "/// Write a function to check whether it follows the sequence given in the patterns vector.\nfn is_samepatterns(colors: Vec<String>, patterns: Vec<String>) -> bool {\n", "task": "mbpp_74_is_samepatterns"}
{"content": "/// Write a function to find tuples which have all elements divisible by k from the given vector of tuples.\nfn find_tuples(test_list: Vec<(isize, isize, isize)>, K: isize) -> Vec<(isize, isize, isize)> {\n    test_list\n        .into_iter()\n        .filter(|(x, y, z)| x % K == 0 && y % K == 0 && z % K == 0)\n        .collect()\n}", "retrieval_text": "/// Write a function to find tuples which have all elements divisible by k from the given vector of tuples.\nfn find_tuples(test_list: Vec<(isize, isize, isize)>, K: isize) -> Vec<(isize, isize, isize)> {\n", "task": "mbpp_75_find_tuples"}
{"content": "/// Write a rsthon function to find whether a number is divisible by 11.\nfn is_Diff(n: isize) -> bool {\n    n % 11 == 0\n}", "retrieval_text": "/// Write a rsthon function to find whether a number is divisible by 11.\nfn is_Diff(n: isize) -> bool {\n", "task": "mbpp_77_is_Diff"}
{"content": "/// Write a rsthon function to check whether the length of the word is odd or not.\nfn word_len(s: String) -> bool {\n    s.split(' ')\n        .any(|word| word.len() % 2 != 0)\n}", "retrieval_text": "/// Write a rsthon function to check whether the length of the word is odd or not.\nfn word_len(s: String) -> bool {\n", "task": "mbpp_79_word_len"}
{"content": "/// Write a function to find the nth tetrahedral number.\nfn tetrahedral_number(n: isize) -> isize {\n  (n * (n + 1) * (n + 2)) / 6\n}", "retrieval_text": "/// Write a function to find the nth tetrahedral number.\nfn tetrahedral_number(n: isize) -> isize {\n", "task": "mbpp_80_tetrahedral_number"}
{"content": "/// Write a function to find the nth number in the newman conway sequence.\nfn sequence(n: isize) -> isize {\n    if n == 1 || n == 2 {\n        return 1;\n    } else {\n        return sequence(sequence(n - 1)) + sequence(n - sequence(n - 1));\n    }\n}", "retrieval_text": "/// Write a function to find the nth number in the newman conway sequence.\nfn sequence(n: isize) -> isize {\n", "task": "mbpp_84_sequence"}
{"content": "/// Write a function to find nth centered hexagonal number.\nfn centered_hexagonal_number(n: isize) -> isize {\n    3 * n * (n - 1) + 1\n}", "retrieval_text": "/// Write a function to find nth centered hexagonal number.\nfn centered_hexagonal_number(n: isize) -> isize {\n", "task": "mbpp_86_centered_hexagonal_number"}
{"content": "use std::collections::HashMap;\n\n/// Write a function to get the frequency of all the elements in a vector, returned as a HashMap.\nfn freq_count(list1: Vec<isize>) -> HashMap<isize, isize> {\n    let mut freq_count = HashMap::new();\n    for i in &list1 {\n        *freq_count.entry(*i).or_insert(0) += 1;\n    }\n    freq_count\n}", "retrieval_text": "use std::collections::HashMap;\n\n/// Write a function to get the frequency of all the elements in a vector, returned as a HashMap.\nfn freq_count(list1: Vec<isize>) -> HashMap<isize, isize> {\n", "task": "mbpp_88_freq_count"}
{"content": "/// Write a function to find the closest smaller number than n.\nfn closest_num(N: isize) -> isize {\n    N - 1\n}", "retrieval_text": "/// Write a function to find the closest smaller number than n.\nfn closest_num(N: isize) -> isize {\n", "task": "mbpp_89_closest_num"}
{"content": "/// Write a rsthon function to find the length of the longest word.\nfn len_log(list1: Vec<String>) -> isize {\n    let mut max = 0;\n    for i in list1 {\n        if i.len() > max {\n            max = i.len();\n        }\n    }\n    max as isize\n}", "retrieval_text": "/// Write a rsthon function to find the length of the longest word.\nfn len_log(list1: Vec<String>) -> isize {\n", "task": "mbpp_90_len_log"}
{"content": "/// Write a function to check if a string is present as a substring in a given vector of string values.\nfn find_substring(str1: Vec<String>, sub_str: String) -> bool {\n    str1.iter().any(|s| s.contains(&sub_str))\n}", "retrieval_text": "/// Write a function to check if a string is present as a substring in a given vector of string values.\nfn find_substring(str1: Vec<String>, sub_str: String) -> bool {\n", "task": "mbpp_91_find_substring"}
{"content": "/// Write a function to check whether the given number is undulating or not.\nfn is_undulating(n: isize) -> bool {\n    if n > 0 {\n        let mut i = 2;\n        while i < n.to_string().len() {\n            if n.to_string().chars().nth(i) != n.to_string().chars().nth(i - 2) {\n                return false;\n            }\n            i += 1;\n        }\n        return true;\n    }\n    false\n}", "retrieval_text": "/// Write a function to check whether the given number is undulating or not.\nfn is_undulating(n: isize) -> bool {\n", "task": "mbpp_92_is_undulating"}
{"content": "/// Write a function to calculate the value of 'a' to the power 'b'.\nfn power(a: isize, b: isize) -> isize {\n    if b == 0 {\n        1\n    } else if a == 0 {\n        0\n    } else if b == 1 {\n        a\n    } else {\n        a * power(a, b - 1)\n    }\n}", "retrieval_text": "/// Write a function to calculate the value of 'a' to the power 'b'.\nfn power(a: isize, b: isize) -> isize {\n", "task": "mbpp_93_power"}
{"content": "/// Given a vector of tuples, write a function that returns the first value of the tuple with the smallest second value.\nfn index_minimum(test_list: Vec<(String, isize)>) -> String {\n    test_list\n        .iter()\n        .min_by_key(|&(_, value)| value)\n        .unwrap()\n        .0\n        .to_owned()\n}", "retrieval_text": "/// Given a vector of tuples, write a function that returns the first value of the tuple with the smallest second value.\nfn index_minimum(test_list: Vec<(String, isize)>) -> String {\n", "task": "mbpp_94_index_minimum"}
{"content": "/// Write a rsthon function to find the number of divisors of a given integer.\nfn divisor(n: isize) -> isize {\n  let mut divs:isize = 0;\n  for i in 1..(n+1) {\n    if n % i == 0 {\n      divs += 1;\n    }\n  }\n  return divs;\n}", "retrieval_text": "/// Write a rsthon function to find the number of divisors of a given integer.\nfn divisor(n: isize) -> isize {\n", "task": "mbpp_96_divisor"}
{"content": "use std::collections::HashMap;\n\n/// Write a function to find frequency of each element in a flattened vector of vectors, returned in a HashMap.\nfn frequency_lists(list1: Vec<Vec<isize>>) -> HashMap<isize, isize> {\n    let mut map = HashMap::new();\n    for v in list1 {\n        for item in v {\n            let count = map.entry(item).or_insert(0);\n            *count += 1;\n        }\n    }\n    map\n}", "retrieval_text": "use std::collections::HashMap;\n\n/// Write a function to find frequency of each element in a flattened vector of vectors, returned in a HashMap.\nfn frequency_lists(list1: Vec<Vec<isize>>) -> HashMap<isize, isize> {\n", "task": "mbpp_97_frequency_lists"}
{"content": "/// Write a function to convert the given decimal number to its binary equivalent, represented as a string with no leading zeros.\nfn decimal_to_binary(n: isize) -> String {\n    let mut binary_str = String::new();\n    let mut n = n;\n    loop {\n        let rem = n % 2;\n        binary_str.push_str(&rem.to_string());\n        n /= 2;\n        if n == 0 {\n            break;\n        }\n    }\n    binary_str.chars().rev().collect()\n}", "retrieval_text": "/// Write a function to convert the given decimal number to its binary equivalent, represented as a string with no leading zeros.\nfn decimal_to_binary(n: isize) -> String {\n", "task": "mbpp_99_decimal_to_binary"}
{"content": "/// Write a function to convert a snake case string to camel case string.\nfn snake_to_camel(word: String) -> String {\n    let mut res = String::new();\n    let mut first_char = true;\n    for c in word.chars() {\n        if c == '_' {\n            first_char = true;\n        } else {\n            let c = if first_char { c.to_uppercase().next().unwrap() } else { c };\n            res.push(c);\n            first_char = false;\n        }\n    }\n    res\n}", "retrieval_text": "/// Write a function to convert a snake case string to camel case string.\nfn snake_to_camel(word: String) -> String {\n", "task": "mbpp_102_snake_to_camel"}
{"content": "/// Write a function to find the Eulerian number a(n, m).\nfn eulerian_num(n: isize, m: isize) -> isize {\n    if m >= n || n == 0 {\n        return 0;\n    }\n    if m == 0 {\n        return 1;\n    }\n    (n - m) * eulerian_num(n - 1, m - 1) + (m + 1) * eulerian_num(n - 1, m)\n}", "retrieval_text": "/// Write a function to find the Eulerian number a(n, m).\nfn eulerian_num(n: isize, m: isize) -> isize {\n", "task": "mbpp_103_eulerian_num"}
{"content": "/// Write a function to sort each subvector of strings in a given vector of vectors.\nfn sort_sublists(input_list: Vec<Vec<String>>) -> Vec<Vec<String>> {\n    let mut result = vec![];\n    for sub in input_list {\n        let mut sub_result = vec![];\n        for x in sub {\n            sub_result.push(x.to_string());\n        }\n        sub_result.sort_by(|a, b| a.to_lowercase().cmp(&b.to_lowercase()));\n        result.push(sub_result);\n    }\n    return result;\n}", "retrieval_text": "/// Write a function to sort each subvector of strings in a given vector of vectors.\nfn sort_sublists(input_list: Vec<Vec<String>>) -> Vec<Vec<String>> {\n", "task": "mbpp_104_sort_sublists"}
{"content": "/// Write a rsthon function to count true booleans in the given vector.\nfn count(lst: Vec<bool>) -> isize {\n    lst.iter()\n        .filter(|&&b| b == true)\n        .count() as isize\n}", "retrieval_text": "/// Write a rsthon function to count true booleans in the given vector.\nfn count(lst: Vec<bool>) -> isize {\n", "task": "mbpp_105_count"}
{"content": "/// Write a function to check if a string represents an integer or not.\nfn check_integer(text: String) -> bool {\n    text.trim().is_empty()\n        || text.chars().all(|c| c.is_ascii_digit())\n}", "retrieval_text": "/// Write a function to check if a string represents an integer or not.\nfn check_integer(text: String) -> bool {\n", "task": "mbpp_113_check_integer"}
{"content": "/// Write a function to convert a given tuple of positive integers into a single integer.\nfn tuple_to_int(nums: (isize, isize, isize)) -> isize {\n    return (nums.0 * 100) + (nums.1 * 10) + nums.2;\n}", "retrieval_text": "/// Write a function to convert a given tuple of positive integers into a single integer.\nfn tuple_to_int(nums: (isize, isize, isize)) -> isize {\n", "task": "mbpp_116_tuple_to_int"}
{"content": "/// Write a function to convert a string to a vector of strings split on the space character.\nfn string_to_list(string: String) -> Vec<String> {\n    return string.split(\" \").map(|x| x.to_string()).collect();\n}", "retrieval_text": "/// Write a function to convert a string to a vector of strings split on the space character.\nfn string_to_list(string: String) -> Vec<String> {\n", "task": "mbpp_118_string_to_list"}
{"content": "/// Write a rsthon function to find the element that appears only once in a sorted vector.\nfn search(arr: Vec<isize>) -> isize {\n    let mut XOR: isize = 0;\n    for i in &arr {\n        XOR = XOR ^ i;\n    }\n    return XOR;\n}", "retrieval_text": "/// Write a rsthon function to find the element that appears only once in a sorted vector.\nfn search(arr: Vec<isize>) -> isize {\n", "task": "mbpp_119_search"}
{"content": "/// Write a function to find the maximum absolute product between numbers in pairs of tuples within a given vector.\nfn max_product_tuple(list1: Vec<(isize, isize)>) -> isize {\n    list1.iter().map(|(x, y)| x * y).map(|y| y.abs()).max().unwrap()\n}", "retrieval_text": "/// Write a function to find the maximum absolute product between numbers in pairs of tuples within a given vector.\nfn max_product_tuple(list1: Vec<(isize, isize)>) -> isize {\n", "task": "mbpp_120_max_product_tuple"}
{"content": "/// Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.\nfn find_length(string: String) -> isize {\n\tlet n = string.len();\n\tlet mut current_sum = 0;\n\tlet mut max_sum = 0;\n\n\tfor i in 0..n {\n\t\tcurrent_sum += if string.as_bytes()[i] == b'0' { 1 } else { -1 };\n\n\t\tif current_sum < 0 {\n\t\t\tcurrent_sum = 0;\n\t\t}\n\t\tmax_sum = max_sum.max(current_sum);\n\t}\n\n\tif max_sum == 0 {\n\t\t0\n\t} else {\n\t\tmax_sum as isize\n\t}\n}", "retrieval_text": "/// Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.\nfn find_length(string: String) -> isize {\n", "task": "mbpp_125_find_length"}
{"content": "/// Write a rsthon function to find the sum of common divisors of two given numbers.\nfn sum(a: isize, b: isize) -> isize {\n    let mut sum: isize = 0;\n    for i in 1..a.min(b) {\n        if a % i == 0 && b % i == 0 {\n            sum += i\n        }\n    }\n    sum\n}", "retrieval_text": "/// Write a rsthon function to find the sum of common divisors of two given numbers.\nfn sum(a: isize, b: isize) -> isize {\n", "task": "mbpp_126_sum"}
{"content": "/// Write a function to multiply two integers.\nfn multiply_int(x: isize, y: isize) -> isize {\n    if y < 0 {\n        -multiply_int(x, -y)\n    } else if y == 0 {\n        0\n    } else if y == 1 {\n        x\n    } else {\n        x + multiply_int(x, y - 1)\n    }\n}", "retrieval_text": "/// Write a function to multiply two integers.\nfn multiply_int(x: isize, y: isize) -> isize {\n", "task": "mbpp_127_multiply_int"}
{"content": "/// Write a function to find words that are longer than n characters from a given vector of words.\nfn long_words(n: isize, str: String) -> Vec<String> {\n    let mut result = Vec::new();\n    for word in str.split_whitespace() {\n        if word.len() > n as usize {\n            result.push(word.to_string());\n        }\n    }\n    result\n}", "retrieval_text": "/// Write a function to find words that are longer than n characters from a given vector of words.\nfn long_words(n: isize, str: String) -> Vec<String> {\n", "task": "mbpp_128_long_words"}
{"content": "/// Write a function to calculate whether the matrix is a magic square.\nfn magic_square_test(my_matrix: Vec<Vec<isize>>) -> bool {\n    // First, we get the dimension of the matrix.\n    let i_size = my_matrix[0].len();\n\n    // Then we calculate the sum of each row and add it to a list.\n    let mut sum_list = vec![];\n    for lines in my_matrix.iter() {\n        sum_list.push(lines.iter().sum::<isize>());\n    }\n\n    // We iterate through the columns of the matrix and add the elements of each column to the list.\n    for col in 0..i_size {\n        let mut sum_col = 0;\n        for row in 0..i_size {\n            sum_col += my_matrix[row][col];\n        }\n        sum_list.push(sum_col);\n    }\n\n    // We add the main diagonal to the list.\n    let mut sum_main_diag = 0;\n    for i in 0..i_size {\n        sum_main_diag += my_matrix[i][i];\n    }\n    sum_list.push(sum_main_diag);\n\n    // We add the anti-diagonal to the list.\n    let mut sum_anti_diag = 0;\n    for i in 0..i_size {\n        sum_anti_diag += my_matrix[i][i_size - 1 - i];\n    }\n    sum_list.push(sum_anti_diag);\n\n    // We remove the duplicate sums and check whether the list is empty.\n    let sum_list_without_duplicates = sum_list.iter().cloned().collect::<std::collections::HashSet<_>>();\n    if sum_list_without_duplicates.len() > 1 {\n        return false;\n    }\n\n    return true;\n}", "retrieval_text": "/// Write a function to calculate whether the matrix is a magic square.\nfn magic_square_test(my_matrix: Vec<Vec<isize>>) -> bool {\n", "task": "mbpp_129_magic_square_test"}
{"content": "/// Write a function to find the item with maximum frequency in a given vector.\nfn max_occurrences(nums: Vec<isize>) -> isize {\n    let mut dict = std::collections::HashMap::new();\n    for i in nums {\n        let count = dict.entry(i).or_insert(0);\n        *count += 1;\n    }\n    let mut max_key = None;\n    let mut max_value = 0;\n    for (key, value) in dict.iter() {\n        if *value > max_value {\n            max_key = Some(*key);\n            max_value = *value;\n        }\n    }\n    match max_key {\n        Some(key) => key,\n        None => panic!(\"No elements in array\"),\n    }\n}", "retrieval_text": "/// Write a function to find the item with maximum frequency in a given vector.\nfn max_occurrences(nums: Vec<isize>) -> isize {\n", "task": "mbpp_130_max_occurrences"}
{"content": "/// Write a function to convert a vector to a string.\nfn tup_string(tup1: Vec<String>) -> String {\n    let mut str = \"\".to_string();\n    for s in tup1 {\n        str = str + &s;\n    }\n    str\n}", "retrieval_text": "/// Write a function to convert a vector to a string.\nfn tup_string(tup1: Vec<String>) -> String {\n", "task": "mbpp_132_tup_string"}
{"content": "/// Write a function to calculate the sum of the negative numbers of a given vector of numbers.\nfn sum_negativenum(nums: Vec<isize>) -> isize {\n    nums.iter().filter(|&&x| x < 0).sum()\n}", "retrieval_text": "/// Write a function to calculate the sum of the negative numbers of a given vector of numbers.\nfn sum_negativenum(nums: Vec<isize>) -> isize {\n", "task": "mbpp_133_sum_negativenum"}
{"content": "/// Write a function to find the nth hexagonal number.\nfn hexagonal_num(n: isize) -> isize {\n\tn * (2 * n - 1)\n}", "retrieval_text": "/// Write a function to find the nth hexagonal number.\nfn hexagonal_num(n: isize) -> isize {\n", "task": "mbpp_135_hexagonal_num"}
{"content": "/// Write a rsthon function to check whether the given number can be represented as sum of non-zero powers of 2 or not.\nfn is_Sum_Of_Powers_Of_Two(n: isize) -> bool {\n    if n % 2 == 1 {\n        return false;\n    } else {\n        return true;\n    }\n}", "retrieval_text": "/// Write a rsthon function to check whether the given number can be represented as sum of non-zero powers of 2 or not.\nfn is_Sum_Of_Powers_Of_Two(n: isize) -> bool {\n", "task": "mbpp_138_is_Sum_Of_Powers_Of_Two"}
{"content": "/// Write a function to count number items that are identical in the same position of three given vectors.\nfn count_samepair(list1: Vec<isize>, list2: Vec<isize>, list3: Vec<isize>) -> isize {\n    let mut result = 0;\n    for i in 0..list1.len() {\n        if list1[i] == list2[i] && list1[i] == list3[i] {\n            result += 1;\n        }\n    }\n    result\n}", "retrieval_text": "/// Write a function to count number items that are identical in the same position of three given vectors.\nfn count_samepair(list1: Vec<isize>, list2: Vec<isize>, list3: Vec<isize>) -> isize {\n", "task": "mbpp_142_count_samepair"}
{"content": "/// Write a rsthon function to find the maximum difference between any two elements in a given vector.\nfn max_Abs_Diff(arr: Vec<isize>) -> isize {\n    let mut min = arr[0];\n    let mut max = arr[0];\n\n    for i in 1..arr.len() {\n        min = min.min(arr[i]);\n        max = max.max(arr[i]);\n    }\n    max - min\n}", "retrieval_text": "/// Write a rsthon function to find the maximum difference between any two elements in a given vector.\nfn max_Abs_Diff(arr: Vec<isize>) -> isize {\n", "task": "mbpp_145_max_Abs_Diff"}
{"content": "/// Write a function that returns integers x and y that satisfy ax + by = n as a tuple, or return None if no solution exists.\nfn find_solution(a: isize, b: isize, n: isize) -> Option<(isize, isize)> {\n\tlet mut i = 0;\n\twhile i * a <= n {\n\t\tif (n - (i * a)) % b == 0 {\n\t\t\treturn Some((i, (n - (i * a)) / b));\n\t\t}\n\t\ti += 1;\n\t}\n\tNone\n}", "retrieval_text": "/// Write a function that returns integers x and y that satisfy ax + by = n as a tuple, or return None if no solution exists.\nfn find_solution(a: isize, b: isize, n: isize) -> Option<(isize, isize)> {\n", "task": "mbpp_160_find_solution"}
{"content": "/// Write a function to remove all elements from a given vector present in another vector.\nfn remove_elements(list1: Vec<isize>, list2: Vec<isize>) -> Vec<isize> {\n    list1.into_iter().filter(|x| !list2.contains(x)).collect()\n}", "retrieval_text": "/// Write a function to remove all elements from a given vector present in another vector.\nfn remove_elements(list1: Vec<isize>, list2: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_161_remove_elements"}
{"content": "/// Write a function to calculate the sum (n - 2*i) from i=0 to n // 2, for instance n + (n-2) + (n-4)... (until n-x =< 0).\nfn sum_series(n: isize) -> isize {\n  if n < 1 {\n    return 0;\n  } else {\n    return n + sum_series(n - 2);\n  }\n}", "retrieval_text": "/// Write a function to calculate the sum (n - 2*i) from i=0 to n // 2, for instance n + (n-2) + (n-4)... (until n-x =< 0).\nfn sum_series(n: isize) -> isize {\n", "task": "mbpp_162_sum_series"}
{"content": "/// Write a function to count the number of characters in a string that occur at the same position in the string as in the English alphabet (case insensitive).\nfn count_char_position(str1: String) -> isize {\n    let mut count_chars = 0;\n    let str1 = str1.to_lowercase();\n    for (index, c) in str1.chars().enumerate() {\n        if (c as u32 - 'a' as u32) as isize == index as isize {\n            count_chars += 1\n        }\n    }\n    count_chars\n}", "retrieval_text": "/// Write a function to count the number of characters in a string that occur at the same position in the string as in the English alphabet (case insensitive).\nfn count_char_position(str1: String) -> isize {\n", "task": "mbpp_165_count_char_position"}
{"content": "/// Write a function that counts the number of pairs of integers in a vector that xor to an even number.\nfn find_even_pair(A: Vec<isize>) -> isize {\n    A.iter().enumerate()\n        .flat_map(|(i, &a)| A.iter().enumerate().skip(i + 1).map(move |(j, &b)| (i, j, a, b)))\n        .filter(|&(_, _, a, b)| (a ^ b) % 2 == 0)\n        .count() as isize\n}", "retrieval_text": "/// Write a function that counts the number of pairs of integers in a vector that xor to an even number.\nfn find_even_pair(A: Vec<isize>) -> isize {\n", "task": "mbpp_166_find_even_pair"}
{"content": "/// Write a function to count the number of occurrences of a number in a given vector.\nfn frequency(a: Vec<isize>, x: isize) -> isize {\n    let mut count = 0;\n    for i in a {\n        if i == x {\n            count += 1\n        }\n    }\n    count\n}", "retrieval_text": "/// Write a function to count the number of occurrences of a number in a given vector.\nfn frequency(a: Vec<isize>, x: isize) -> isize {\n", "task": "mbpp_168_frequency"}
{"content": "/// Write a function to find the sum of numbers in a vector within a range specified by two indices.\nfn sum_range_list(list1: Vec<isize>, m: isize, n: isize) -> isize {\n    let mut sum_range = 0;\n    for i in m..=n {\n        sum_range += list1[i as usize];\n    }\n    sum_range\n}", "retrieval_text": "/// Write a function to find the sum of numbers in a vector within a range specified by two indices.\nfn sum_range_list(list1: Vec<isize>, m: isize, n: isize) -> isize {\n", "task": "mbpp_170_sum_range_list"}
{"content": "/// Write a function to find the perimeter of a regular pentagon from the length of its sides.\nfn perimeter_pentagon(a: isize) -> isize {\n    a * 5\n}", "retrieval_text": "/// Write a function to find the perimeter of a regular pentagon from the length of its sides.\nfn perimeter_pentagon(a: isize) -> isize {\n", "task": "mbpp_171_perimeter_pentagon"}
{"content": "/// Write a function to count the number of occurence of the string 'std' in a given string.\nfn count_occurance(s: String) -> isize {\n    let count: isize = s.match_indices(\"std\").count() as isize;\n    return count;\n}", "retrieval_text": "/// Write a function to count the number of occurence of the string 'std' in a given string.\nfn count_occurance(s: String) -> isize {\n", "task": "mbpp_172_count_occurance"}
{"content": "/// Write a rsthon function to remove the characters which have odd index values of a given string.\nfn odd_values_string(str: String) -> String {\n    let mut result = String::new();\n    for i in 0..str.len() {\n        if i % 2 == 0 {\n            result.push_str(&str[i..i + 1]);\n        }\n    }\n    result\n}", "retrieval_text": "/// Write a rsthon function to remove the characters which have odd index values of a given string.\nfn odd_values_string(str: String) -> String {\n", "task": "mbpp_226_odd_values_string"}
{"content": "/// Write a function to find minimum of three numbers.\nfn min_of_three(a: isize, b: isize, c: isize) -> isize {\n    if (a <= b) && (a <= c) {\n        a\n    } else if (b <= a) && (b <= c) {\n        b\n    } else {\n        c\n    }\n}", "retrieval_text": "/// Write a function to find minimum of three numbers.\nfn min_of_three(a: isize, b: isize, c: isize) -> isize {\n", "task": "mbpp_227_min_of_three"}
{"content": "/// Write a rsthon function to check whether all the bits are unset in the given range or not.\nfn all_Bits_Set_In_The_Given_Range(n: isize, l: isize, r: isize) -> bool {\n    let mut num = (((1 << r) - 1) ^ ((1 << (l - 1)) - 1)) & n;\n    if num == 0 {\n        return true;\n    }\n    return false;\n}", "retrieval_text": "/// Write a rsthon function to check whether all the bits are unset in the given range or not.\nfn all_Bits_Set_In_The_Given_Range(n: isize, l: isize, r: isize) -> bool {\n", "task": "mbpp_228_all_Bits_Set_In_The_Given_Range"}
{"content": "/// Write a function that takes in a string and character, replaces blank spaces in the string with the character, and returns the string.\nfn replace_blank(str1: String, char: String) -> String {\n    let mut res = String::new();\n    for i in str1.chars() {\n        if i == ' ' {\n            res.push_str(char.as_str());\n        } else {\n            res.push(i);\n        }\n    }\n    return res;\n}", "retrieval_text": "/// Write a function that takes in a string and character, replaces blank spaces in the string with the character, and returns the string.\nfn replace_blank(str1: String, char: String) -> String {\n", "task": "mbpp_230_replace_blank"}
{"content": "/// Write a function to find the volume of a cube given its side length.\nfn volume_cube(l: isize) -> isize {\n    l * l * l\n}", "retrieval_text": "/// Write a function to find the volume of a cube given its side length.\nfn volume_cube(l: isize) -> isize {\n", "task": "mbpp_234_volume_cube"}
{"content": "/// Write a rsthon function to count the number of non-empty substrings of a given string.\nfn number_of_substrings(str: String) -> isize {\n    let mut str_len = 0;\n    let mut res = 0;\n    for s in str.chars() {\n        str_len += 1;\n        res += str_len;\n    }\n    res\n}", "retrieval_text": "/// Write a rsthon function to count the number of non-empty substrings of a given string.\nfn number_of_substrings(str: String) -> isize {\n", "task": "mbpp_238_number_of_substrings"}
{"content": "/// Write a function to count the total number of characters in a string.\nfn count_charac(str1: String) -> isize {\n    let mut count = 0;\n    for _ in str1.chars() {\n        count += 1;\n    }\n    count\n}", "retrieval_text": "/// Write a function to count the total number of characters in a string.\nfn count_charac(str1: String) -> isize {\n", "task": "mbpp_242_count_charac"}
{"content": "/// Write a function to find the length of the longest palindromic subsequence in the given string.\nfn lps(str: String) -> isize {\n    let n = str.len();\n    let mut L = vec![vec![0; n]; n];\n    for i in 0..n {\n        L[i][i] = 1;\n    }\n    for cl in 2..=n {\n        for i in 0..n-cl+1 {\n            let j = i + cl - 1;\n            if str.as_bytes()[i] == str.as_bytes()[j] {\n                L[i][j] = L[i + 1][j - 1] + 2;\n            } else {\n                L[i][j] = L[i][j - 1].max(L[i + 1][j]);\n            }\n        }\n    }\n    L[0][n - 1]\n}", "retrieval_text": "/// Write a function to find the length of the longest palindromic subsequence in the given string.\nfn lps(str: String) -> isize {\n", "task": "mbpp_247_lps"}
{"content": "/// Write a function to find the intersection of two vectors.\nfn intersection_array(array_nums1: Vec<isize>, array_nums2: Vec<isize>) -> Vec<isize> {\n    let mut result = Vec::new();\n\n    for n in array_nums1 {\n        if array_nums2.contains(&n) {\n            result.push(n);\n        }\n    }\n\n    result\n}", "retrieval_text": "/// Write a function to find the intersection of two vectors.\nfn intersection_array(array_nums1: Vec<isize>, array_nums2: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_249_intersection_array"}
{"content": "/// Write a rsthon function that takes in a tuple and an element and counts the occcurences of the element in the vector.\nfn count_X(tup: Vec<isize>, x: isize) -> isize {\n    let mut count = 0;\n    for ele in tup {\n        if ele == x {\n            count += 1;\n        }\n    }\n    count\n}", "retrieval_text": "/// Write a rsthon function that takes in a tuple and an element and counts the occcurences of the element in the vector.\nfn count_X(tup: Vec<isize>, x: isize) -> isize {\n", "task": "mbpp_250_count_X"}
{"content": "/// Write a function that takes in a vector and an element and inserts the element before each element in the vector, and returns the resulting vector.\nfn insert_element(list: Vec<String>, element: String) -> Vec<String> {\n    let mut ret = Vec::new();\n    for i in list {\n        ret.push(element.clone());\n        ret.push(i);\n    }\n    ret\n}", "retrieval_text": "/// Write a function that takes in a vector and an element and inserts the element before each element in the vector, and returns the resulting vector.\nfn insert_element(list: Vec<String>, element: String) -> Vec<String> {\n", "task": "mbpp_251_insert_element"}
{"content": "/// Write a rsthon function that takes in a non-negative number and returns the number of prime numbers less than the given non-negative number.\nfn count_Primes_nums(n: isize) -> isize {\n    let mut ctr: isize = 0;\n    for num in 2..n {\n        let mut isPrime = true;\n        for i in 2..num {\n            if (num % i) == 0 {\n                isPrime = false;\n                break;\n            }\n        }\n        if isPrime {\n            ctr += 1;\n        }\n    }\n    return ctr\n}", "retrieval_text": "/// Write a rsthon function that takes in a non-negative number and returns the number of prime numbers less than the given non-negative number.\nfn count_Primes_nums(n: isize) -> isize {\n", "task": "mbpp_256_count_Primes_nums"}
{"content": "/// Write a function that takes in two numbers and returns a vector with the second number and then the first number.\nfn swap_numbers(a: isize, b: isize) -> Vec<isize> {\n    vec![b, a]\n}", "retrieval_text": "/// Write a function that takes in two numbers and returns a vector with the second number and then the first number.\nfn swap_numbers(a: isize, b: isize) -> Vec<isize> {\n", "task": "mbpp_257_swap_numbers"}
{"content": "/// Write a function to maximize the given two vectors.\nfn maximize_elements(test_tup1: Vec<Vec<isize>>, test_tup2: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n    let mut res = Vec::new();\n    for (a, b) in test_tup1.iter().zip(test_tup2.iter()) {\n        let c = a.iter().zip(b.iter()).map(|(&a, &b)| a.max(b)).collect();\n        res.push(c);\n    }\n    res\n}", "retrieval_text": "/// Write a function to maximize the given two vectors.\nfn maximize_elements(test_tup1: Vec<Vec<isize>>, test_tup2: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n", "task": "mbpp_259_maximize_elements"}
{"content": "/// Write a function to find the nth newman\u2013shanks\u2013williams prime number.\nfn newman_prime(n: isize) -> isize {\n    if n == 0 || n == 1 {\n        return 1\n    }\n    2 * newman_prime(n - 1) + newman_prime(n - 2)\n}", "retrieval_text": "/// Write a function to find the nth newman\u2013shanks\u2013williams prime number.\nfn newman_prime(n: isize) -> isize {\n", "task": "mbpp_260_newman_prime"}
{"content": "/// Write a function that takes in two tuples and performs mathematical division operation element-wise across the given tuples.\nfn division_elements(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n    (test_tup1.0 / test_tup2.0, test_tup1.1 / test_tup2.1, test_tup1.2 / test_tup2.2, test_tup1.3 / test_tup2.3)\n}", "retrieval_text": "/// Write a function that takes in two tuples and performs mathematical division operation element-wise across the given tuples.\nfn division_elements(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n", "task": "mbpp_261_division_elements"}
{"content": "/// Write a function to find the lateral surface area of a cube given its side length.\nfn lateralsurface_cube(l: isize) -> isize {\n  l * l * 4\n}", "retrieval_text": "/// Write a function to find the lateral surface area of a cube given its side length.\nfn lateralsurface_cube(l: isize) -> isize {\n", "task": "mbpp_266_lateralsurface_cube"}
{"content": "/// Write a rsthon function that takes in an integer n and returns the sum of the squares of the first n odd natural numbers.\nfn square_Sum(n: isize) -> isize {\n    return n*(4*n*n-1)/3;\n}", "retrieval_text": "/// Write a rsthon function that takes in an integer n and returns the sum of the squares of the first n odd natural numbers.\nfn square_Sum(n: isize) -> isize {\n", "task": "mbpp_267_square_Sum"}
{"content": "/// Write a function to find the n'th star number.\nfn find_star_num(n: isize) -> isize {\n\t6 * n * (n - 1) + 1\n}", "retrieval_text": "/// Write a function to find the n'th star number.\nfn find_star_num(n: isize) -> isize {\n", "task": "mbpp_268_find_star_num"}
{"content": "/// Write a function to find the ascii value of a character.\nfn ascii_value(k: String) -> isize {\n    let ch = k.chars().nth(0).unwrap();\n    ch as isize\n}", "retrieval_text": "/// Write a function to find the ascii value of a character.\nfn ascii_value(k: String) -> isize {\n", "task": "mbpp_269_ascii_value"}
{"content": "/// Write a rsthon function to find the sum of even numbers at even positions of a vector.\nfn sum_even_and_even_index(arr: Vec<isize>) -> isize {\n    let mut sum = 0;\n    for i in (0..arr.len()).step_by(2) {\n        if arr[i] % 2 == 0 {\n            sum += arr[i];\n        }\n    }\n    sum\n}", "retrieval_text": "/// Write a rsthon function to find the sum of even numbers at even positions of a vector.\nfn sum_even_and_even_index(arr: Vec<isize>) -> isize {\n", "task": "mbpp_270_sum_even_and_even_index"}
{"content": "/// Write a rsthon function that takes in an integer n and finds the sum of the first n even natural numbers that are raised to the fifth power.\nfn even_Power_Sum(n: isize) -> isize {\n    let mut sum = 0;\n    for i in 1..n+1 {\n        let j = 2*i;\n        sum += j.pow(5)\n    }\n    sum\n}", "retrieval_text": "/// Write a rsthon function that takes in an integer n and finds the sum of the first n even natural numbers that are raised to the fifth power.\nfn even_Power_Sum(n: isize) -> isize {\n", "task": "mbpp_271_even_Power_Sum"}
{"content": "/// Write a function that takes in a vector of tuples and returns a vector containing the rear element of each tuple.\nfn rear_extract(test_list: Vec<(isize, String, isize)>) -> Vec<isize> {\n    let res = test_list.iter().map(|x| x.2).collect();\n    res\n}", "retrieval_text": "/// Write a function that takes in a vector of tuples and returns a vector containing the rear element of each tuple.\nfn rear_extract(test_list: Vec<(isize, String, isize)>) -> Vec<isize> {\n", "task": "mbpp_272_rear_extract"}
{"content": "/// Write a function that takes in two tuples and subtracts the elements of the first tuple by the elements of the second tuple with the same index.\nfn substract_elements(test_tup1: (isize, isize, isize), test_tup2: (isize, isize, isize)) -> (isize, isize, isize) {\n    let (a, b, c) = test_tup1;\n    let (d, e, f) = test_tup2;\n    (a - d, b - e, c - f)\n}", "retrieval_text": "/// Write a function that takes in two tuples and subtracts the elements of the first tuple by the elements of the second tuple with the same index.\nfn substract_elements(test_tup1: (isize, isize, isize), test_tup2: (isize, isize, isize)) -> (isize, isize, isize) {\n", "task": "mbpp_273_substract_elements"}
{"content": "/// Write a rsthon function that takes in a positive integer n and finds the sum of even index binomial coefficients.\nfn even_binomial_Coeff_Sum(n: isize) -> isize {\n    1 << (n - 1)\n}", "retrieval_text": "/// Write a rsthon function that takes in a positive integer n and finds the sum of even index binomial coefficients.\nfn even_binomial_Coeff_Sum(n: isize) -> isize {\n", "task": "mbpp_274_even_binomial_Coeff_Sum"}
{"content": "use std::collections::HashMap;\n\n/// Write a function that takes in a HashMap and integer n and filters the HashMap to only include entries with values greater than or equal to n.\nfn dict_filter(dict: HashMap<String, isize>, n: isize) -> HashMap<String, isize> {\n    dict.into_iter().filter(|(k, v)| *v >= n).collect()\n}", "retrieval_text": "use std::collections::HashMap;\n\n/// Write a function that takes in a HashMap and integer n and filters the HashMap to only include entries with values greater than or equal to n.\nfn dict_filter(dict: HashMap<String, isize>, n: isize) -> HashMap<String, isize> {\n", "task": "mbpp_277_dict_filter"}
{"content": "/// Write a function to find the nth decagonal number.\nfn is_num_decagonal(n: isize) -> isize {\n\t4 * n * n - 3 * n\n}", "retrieval_text": "/// Write a function to find the nth decagonal number.\nfn is_num_decagonal(n: isize) -> isize {\n", "task": "mbpp_279_is_num_decagonal"}
{"content": "/// Write a rsthon function to check if the elements of a given vector are unique or not.\nfn all_unique(test_list: Vec<isize>) -> bool {\n    if test_list.len() > test_list.iter().collect::<std::collections::HashSet<_>>().len() {\n        return false;\n    }\n    return true;\n}", "retrieval_text": "/// Write a rsthon function to check if the elements of a given vector are unique or not.\nfn all_unique(test_list: Vec<isize>) -> bool {\n", "task": "mbpp_281_all_unique"}
{"content": "/// Write a function to subtract two vectors element-wise.\nfn sub_list(nums1: Vec<isize>, nums2: Vec<isize>) -> Vec<isize> {\n    nums1\n        .iter()\n        .zip(nums2.iter())\n        .map(|(x, y)| *x - *y)\n        .collect::<Vec<isize>>()\n}", "retrieval_text": "/// Write a function to subtract two vectors element-wise.\nfn sub_list(nums1: Vec<isize>, nums2: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_282_sub_list"}
{"content": "/// Write a rsthon function takes in an integer and check whether the frequency of each digit in the integer is less than or equal to the digit itself.\nfn validate(n: isize) -> bool {\n    let mut digit_count = [0; 10];\n    let mut temp = n;\n    while temp > 0 {\n        let digit = (temp % 10) as usize;\n        digit_count[digit] += 1;\n        temp /= 10;\n    }\n    digit_count\n        .iter()\n        .enumerate()\n        .all(|(i, &count)| count <= i)\n}", "retrieval_text": "/// Write a rsthon function takes in an integer and check whether the frequency of each digit in the integer is less than or equal to the digit itself.\nfn validate(n: isize) -> bool {\n", "task": "mbpp_283_validate"}
{"content": "/// Write a rsthon function takes in an integer n and returns the sum of squares of first n even natural numbers.\nfn square_Sum(n: isize) -> isize {\n    return 2*n*(n+1)*(2*n+1)/3\n}", "retrieval_text": "/// Write a rsthon function takes in an integer n and returns the sum of squares of first n even natural numbers.\nfn square_Sum(n: isize) -> isize {\n", "task": "mbpp_287_square_Sum"}
{"content": "/// Write a rsthon function to find quotient of two numbers (rounded down to the nearest integer).\nfn find(n: isize, m: isize) -> isize {\n    n / m\n}", "retrieval_text": "/// Write a rsthon function to find quotient of two numbers (rounded down to the nearest integer).\nfn find(n: isize, m: isize) -> isize {\n", "task": "mbpp_292_find"}
{"content": "/// Write a function to find the third side of a right angled triangle.\nfn otherside_rightangle(w: isize, h: isize) -> f64 {\n    let s = (w as f64).powf(2.0) + (h as f64).powf(2.0);\n    s.sqrt() as f64\n}", "retrieval_text": "/// Write a function to find the third side of a right angled triangle.\nfn otherside_rightangle(w: isize, h: isize) -> f64 {\n", "task": "mbpp_293_otherside_rightangle"}
{"content": "/// Write a function to return the sum of all divisors of a number.\nfn sum_div(number: isize) -> isize {\n    let mut sum = 1;\n    for i in 2..number {\n        if number % i == 0 {\n            sum += i;\n        }\n    }\n    return sum;\n}", "retrieval_text": "/// Write a function to return the sum of all divisors of a number.\nfn sum_div(number: isize) -> isize {\n", "task": "mbpp_295_sum_div"}
{"content": "/// Write a rsthon function to count inversions in a vector.\nfn get_Inv_Count(arr: Vec<isize>) -> isize {\n    let n = arr.len();\n    let mut inv_count = 0;\n\n    for i in 0..n {\n        for j in i + 1..n {\n            if arr[i] > arr[j] {\n                inv_count += 1;\n            }\n        }\n    }\n    inv_count\n}", "retrieval_text": "/// Write a rsthon function to count inversions in a vector.\nfn get_Inv_Count(arr: Vec<isize>) -> isize {\n", "task": "mbpp_296_get_Inv_Count"}
{"content": "/// Write a function to calculate the maximum aggregate from the vector of tuples.\nfn max_aggregate(stdata: Vec<(String, isize)>) -> (String, isize) {\n    let mut temp = std::collections::HashMap::new();\n    for (name, marks) in stdata {\n        *temp.entry(name).or_insert(0) += marks;\n    }\n    temp.into_iter().max_by_key(|x| x.1).unwrap()\n}", "retrieval_text": "/// Write a function to calculate the maximum aggregate from the vector of tuples.\nfn max_aggregate(stdata: Vec<(String, isize)>) -> (String, isize) {\n", "task": "mbpp_299_max_aggregate"}
{"content": "/// Write a function to return two words from a vector of words starting with letter 'p'.\nfn start_withp(words: Vec<String>) -> (String, String) {\n    for w in words {\n        if w.starts_with(\"P\") {\n            let mut m = w.split(' ');\n            let w1 = m.next().unwrap();\n            let w2 = m.next().unwrap();\n            return (w1.to_string(), w2.to_string());\n        }\n    }\n    panic!(\"No words start with 'P'\");\n}", "retrieval_text": "/// Write a function to return two words from a vector of words starting with letter 'p'.\nfn start_withp(words: Vec<String>) -> (String, String) {\n", "task": "mbpp_305_start_withp"}
{"content": "/// Write a function to find the specified number of largest products from two given vectors, selecting one factor from each vector.\nfn large_product(nums1: Vec<isize>, nums2: Vec<isize>, N: isize) -> Vec<isize> {\n    // 1. Create an empty vector to store the products.\n    let mut products = Vec::new();\n    // 2. Loop through each element in the first vector.\n    for &num1 in nums1.iter() {\n        // 3. Loop through each element in the second vector.\n        for &num2 in nums2.iter() {\n            // 4. Append the product of the two elements to the products vector.\n            products.push(num1 * num2);\n        }\n    }\n    // 5. Sort the products vector in descending order.\n    products.sort_by(|a, b| b.cmp(a));\n    // 6. Return a new vector containing the first N products.\n    products[..N as usize].to_vec()\n}", "retrieval_text": "/// Write a function to find the specified number of largest products from two given vectors, selecting one factor from each vector.\nfn large_product(nums1: Vec<isize>, nums2: Vec<isize>, N: isize) -> Vec<isize> {\n", "task": "mbpp_308_large_product"}
{"content": "/// Write a rsthon function to find the maximum of two numbers.\nfn maximum(a: isize, b: isize) -> isize {\n    if a > b {\n        a\n    } else {\n        b\n    }\n}", "retrieval_text": "/// Write a rsthon function to find the maximum of two numbers.\nfn maximum(a: isize, b: isize) -> isize {\n", "task": "mbpp_309_maximum"}
{"content": "/// Write a function to convert a given string to a vector of characters.\nfn string_to_tuple(str1: String) -> Vec<String> {\n    let mut result = Vec::new();\n    for c in str1.chars() {\n        if !c.is_whitespace() {\n            result.push(c.to_string());\n        }\n    }\n    result\n}", "retrieval_text": "/// Write a function to convert a given string to a vector of characters.\nfn string_to_tuple(str1: String) -> Vec<String> {\n", "task": "mbpp_310_string_to_tuple"}
{"content": "/// Write a rsthon function to find the highest power of 2 that is less than or equal to n.\nfn highest_Power_of_2(n: isize) -> isize {\n    if n < 1 {\n        return 0;\n    } else if n == 1 {\n        return 1;\n    }\n    let mut res = 1;\n    while res * 2 <= n {\n        res *= 2;\n    }\n    res\n}", "retrieval_text": "/// Write a rsthon function to find the highest power of 2 that is less than or equal to n.\nfn highest_Power_of_2(n: isize) -> isize {\n", "task": "mbpp_388_highest_Power_of_2"}
{"content": "/// Write a function to find the n'th lucas number.\nfn find_lucas(n: isize) -> isize {\n    if n == 0 {\n        return 2;\n    }\n    if n == 1 {\n        return 1;\n    }\n    find_lucas(n - 1) + find_lucas(n - 2)\n}", "retrieval_text": "/// Write a function to find the n'th lucas number.\nfn find_lucas(n: isize) -> isize {\n", "task": "mbpp_389_find_lucas"}
{"content": "/// Write a function to check if given vector contains no duplicates.\nfn check_distinct(test_tup: Vec<isize>) -> bool {\n    let mut temp: Vec<isize> = test_tup.clone();\n    temp.sort();\n    let result: bool = temp.windows(2).all(|x| x[0] != x[1]);\n    result\n}", "retrieval_text": "/// Write a function to check if given vector contains no duplicates.\nfn check_distinct(test_tup: Vec<isize>) -> bool {\n", "task": "mbpp_394_check_distinct"}
{"content": "/// Write a rsthon function to find the first non-repeated character in a given string.\nfn first_non_repeating_character(str1: String) -> Option<String> {\n    let mut ctr = std::collections::HashMap::new();\n\n    for ch in str1.chars() {\n        let count = ctr.entry(ch).or_insert(0);\n        *count += 1;\n    }\n\n    for ch in str1.chars() {\n        if ctr.get(&ch) == Some(&1) {\n            return Some(ch.to_string());\n        }\n    }\n    None\n}", "retrieval_text": "/// Write a rsthon function to find the first non-repeated character in a given string.\nfn first_non_repeating_character(str1: String) -> Option<String> {\n", "task": "mbpp_395_first_non_repeating_character"}
{"content": "/// Write a function to check whether the given string starts and ends with the same character or not.\nfn check_char(string: String) -> String {\n    let string_char: Vec<char> = string.chars().collect();\n    let first_char: char = string_char[0];\n    let last_char: char = string_char[string_char.len() - 1];\n    if first_char == last_char {\n        \"Valid\".to_string()\n    } else {\n        \"Invalid\".to_string()\n    }\n}", "retrieval_text": "/// Write a function to check whether the given string starts and ends with the same character or not.\nfn check_char(string: String) -> String {\n", "task": "mbpp_396_check_char"}
{"content": "/// Write a function to find the median of three numbers.\nfn median_numbers(a: isize, b: isize, c: isize) -> f64 {\n    if a > b {\n        if a < c {\n            return a as f64;\n        } else if b > c {\n            return b as f64;\n        } else {\n            return c as f64;\n        }\n    } else {\n        if a > c {\n            return a as f64;\n        } else if b < c {\n            return b as f64;\n        } else {\n            return c as f64;\n        }\n    }\n}", "retrieval_text": "/// Write a function to find the median of three numbers.\nfn median_numbers(a: isize, b: isize, c: isize) -> f64 {\n", "task": "mbpp_397_median_numbers"}
{"content": "/// Write a function to perform the mathematical bitwise xor operation across the given tuples.\nfn bitwise_xor(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n  (test_tup1.0 ^ test_tup2.0, test_tup1.1 ^ test_tup2.1, test_tup1.2 ^ test_tup2.2, test_tup1.3 ^ test_tup2.3)\n}", "retrieval_text": "/// Write a function to perform the mathematical bitwise xor operation across the given tuples.\nfn bitwise_xor(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n", "task": "mbpp_399_bitwise_xor"}
{"content": "/// Write a function to perform index wise addition of vector elements in the given two nested vectors.\nfn add_nested_tuples(test_tup1: Vec<Vec<isize>>, test_tup2: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n    test_tup1.into_iter()\n        .zip(test_tup2.into_iter())\n        .map(|(tup1, tup2)| tup1.into_iter().zip(tup2.into_iter()).map(|(a, b)| a + b).collect())\n        .collect()\n}", "retrieval_text": "/// Write a function to perform index wise addition of vector elements in the given two nested vectors.\nfn add_nested_tuples(test_tup1: Vec<Vec<isize>>, test_tup2: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n", "task": "mbpp_401_add_nested_tuples"}
{"content": "/// Write a rsthon function to find the minimum of two numbers.\nfn minimum(a: isize, b: isize) -> isize {\n    if a <= b {\n        a\n    } else {\n        b\n    }\n}", "retrieval_text": "/// Write a rsthon function to find the minimum of two numbers.\nfn minimum(a: isize, b: isize) -> isize {\n", "task": "mbpp_404_minimum"}
{"content": "/// Write a rsthon function to find whether the parity of a given number is odd.\nfn find_Parity(x: isize) -> bool {\n    let mut y: isize = x ^ (x >> 1);\n    y = y ^ (y >> 2);\n    y = y ^ (y >> 4);\n    y = y ^ (y >> 8);\n    y = y ^ (y >> 16);\n    y & 1 == 1\n}", "retrieval_text": "/// Write a rsthon function to find whether the parity of a given number is odd.\nfn find_Parity(x: isize) -> bool {\n", "task": "mbpp_406_find_Parity"}
{"content": "/// Write a function to find the minimum product from the pairs of tuples within a given vector.\nfn min_product_tuple(list1: Vec<(isize, isize)>) -> isize {\n    list1.into_iter().map(|(x, y)| x * y).min().unwrap()\n}", "retrieval_text": "/// Write a function to find the minimum product from the pairs of tuples within a given vector.\nfn min_product_tuple(list1: Vec<(isize, isize)>) -> isize {\n", "task": "mbpp_409_min_product_tuple"}
{"content": "/// Write a function to convert the given snake case string to camel case string.\nfn snake_to_camel(word: String) -> String {\n    let mut result = String::new();\n    let mut is_first_char = true;\n\n    for c in word.chars() {\n        if c == '_' {\n            is_first_char = true;\n        } else if is_first_char {\n            result.push(c.to_uppercase().next().unwrap());\n            is_first_char = false;\n        } else {\n            result.push(c);\n        }\n    }\n\n    result\n}", "retrieval_text": "/// Write a function to convert the given snake case string to camel case string.\nfn snake_to_camel(word: String) -> String {\n", "task": "mbpp_411_snake_to_camel"}
{"content": "/// Write a rsthon function to remove odd numbers from a given vector.\nfn remove_odd(l: Vec<isize>) -> Vec<isize> {\n    let mut v: Vec<isize> = l;\n    v.retain(|&x| x % 2 == 0);\n    v\n}", "retrieval_text": "/// Write a rsthon function to remove odd numbers from a given vector.\nfn remove_odd(l: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_412_remove_odd"}
{"content": "/// Write a rsthon function to check whether any value in a sequence exists in a sequence or not.\nfn overlapping(list1: Vec<isize>, list2: Vec<isize>) -> bool {\n    let c = list1.len();\n    let d = list2.len();\n    for i in 0..c {\n        for j in 0..d {\n            if list1[i] == list2[j] {\n                return true;\n            }\n        }\n    }\n    false\n}", "retrieval_text": "/// Write a rsthon function to check whether any value in a sequence exists in a sequence or not.\nfn overlapping(list1: Vec<isize>, list2: Vec<isize>) -> bool {\n", "task": "mbpp_414_overlapping"}
{"content": "/// Write a rsthon function to find a pair with highest product from a given vector of integers.\nfn max_Product(arr: Vec<isize>) -> (isize, isize) {\n    if arr.len() < 2 {\n        panic!(\"No pairs exists\");\n    }\n\n    let mut x = arr[0];\n    let mut y = arr[1];\n\n    for i in 0..arr.len() {\n        for j in i + 1..arr.len() {\n            if arr[i] * arr[j] > x * y {\n                x = arr[i];\n                y = arr[j];\n            }\n        }\n    }\n\n    (x, y)\n}", "retrieval_text": "/// Write a rsthon function to find a pair with highest product from a given vector of integers.\nfn max_Product(arr: Vec<isize>) -> (isize, isize) {\n", "task": "mbpp_415_max_Product"}
{"content": "/// Write a rsthon function to find the cube sum of first n even natural numbers.\nfn cube_Sum(n: isize) -> isize {\n    let mut sum = 0;\n    for i in 1..n + 1 {\n        sum += (2 * i) * (2 * i) * (2 * i);\n    }\n    sum\n}", "retrieval_text": "/// Write a rsthon function to find the cube sum of first n even natural numbers.\nfn cube_Sum(n: isize) -> isize {\n", "task": "mbpp_420_cube_Sum"}
{"content": "/// Write a function to filter odd numbers.\nfn filter_oddnumbers(nums: Vec<isize>) -> Vec<isize> {\n    nums.into_iter().filter(|&x| x % 2 != 0).collect()\n}", "retrieval_text": "/// Write a function to filter odd numbers.\nfn filter_oddnumbers(nums: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_426_filter_oddnumbers"}
{"content": "/// Write a function to sort the given vector by using shell sort.\nfn shell_sort(my_list: Vec<isize>) -> Vec<isize> {\n    let mut my_list = my_list;\n    let length = my_list.len();\n\n    let mut gap = length / 2;\n\n    while gap > 0 {\n        for i in (gap..length).step_by(gap) {\n            let current_item = my_list[i];\n            let mut j = i;\n            while j >= gap && my_list[j - gap] > current_item {\n                my_list[j] = my_list[j - gap];\n                j -= gap;\n            }\n            my_list[j] = current_item;\n        }\n        gap = gap / 2;\n    }\n\n    my_list\n}", "retrieval_text": "/// Write a function to sort the given vector by using shell sort.\nfn shell_sort(my_list: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_428_shell_sort"}
{"content": "/// Write a function to extract the elementwise and tuples from the given two tuples.\nfn and_tuples(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n    let res = (test_tup1.0 & test_tup2.0, test_tup1.1 & test_tup2.1, test_tup1.2 & test_tup2.2, test_tup1.3 & test_tup2.3);\n    res\n}", "retrieval_text": "/// Write a function to extract the elementwise and tuples from the given two tuples.\nfn and_tuples(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n", "task": "mbpp_429_and_tuples"}
{"content": "/// Write a function to find the directrix of a parabola.\nfn parabola_directrix(a: isize, b: isize, c: isize) -> isize {\n    (c - (b * b + 1) * 4 * a) as isize\n}", "retrieval_text": "/// Write a function to find the directrix of a parabola.\nfn parabola_directrix(a: isize, b: isize, c: isize) -> isize {\n", "task": "mbpp_430_parabola_directrix"}
{"content": "/// Write a function to find the median length of a trapezium.\nfn median_trapezium(base1: isize, base2: isize, height: isize) -> f64 {\n    let median = 0.5 * (base1 + base2) as f64;\n    median\n}", "retrieval_text": "/// Write a function to find the median length of a trapezium.\nfn median_trapezium(base1: isize, base2: isize, height: isize) -> f64 {\n", "task": "mbpp_432_median_trapezium"}
{"content": "/// Write a function to check whether the entered number is greater than the elements of the given vector.\nfn check_greater(arr: Vec<isize>, number: isize) -> bool {\n    let mut arr = arr;\n    arr.sort();\n    let index = arr.len() - 1;\n    if number > arr[index] {\n        return true;\n    } else {\n        return false;\n    }\n}", "retrieval_text": "/// Write a function to check whether the entered number is greater than the elements of the given vector.\nfn check_greater(arr: Vec<isize>, number: isize) -> bool {\n", "task": "mbpp_433_check_greater"}
{"content": "/// Write a rsthon function to find the last digit of a given number.\nfn last_Digit(n: isize) -> isize {\n    n % 10\n}", "retrieval_text": "/// Write a rsthon function to find the last digit of a given number.\nfn last_Digit(n: isize) -> isize {\n", "task": "mbpp_435_last_Digit"}
{"content": "/// Write a rsthon function to return the negative numbers in a vector.\nfn neg_nos(list1: Vec<isize>) -> Vec<isize> {\n  let mut result: Vec<isize> = Vec::new();\n  for num in list1 {\n    if num < 0 {\n      result.push(num);\n    }\n  }\n  result\n}", "retrieval_text": "/// Write a rsthon function to return the negative numbers in a vector.\nfn neg_nos(list1: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_436_neg_nos"}
{"content": "/// Write a function to count bidirectional tuple pairs.\nfn count_bidirectional(test_list: Vec<(isize, isize)>) -> isize {\n    let mut res = 0;\n    for idx in 0..test_list.len() {\n        for iidx in idx + 1..test_list.len() {\n            if test_list[iidx].0 == test_list[idx].1 && test_list[idx].1 == test_list[iidx].0 {\n                res += 1;\n            }\n        }\n    }\n    res\n}", "retrieval_text": "/// Write a function to count bidirectional tuple pairs.\nfn count_bidirectional(test_list: Vec<(isize, isize)>) -> isize {\n", "task": "mbpp_438_count_bidirectional"}
{"content": "/// Write a function to join a vector of multiple integers into a single integer.\nfn multiple_to_single(L: Vec<isize>) -> isize {\n    let s = L.into_iter().map(|x| x.to_string()).collect::<String>();\n    isize::from_str_radix(&s, 10).unwrap()\n}", "retrieval_text": "/// Write a function to join a vector of multiple integers into a single integer.\nfn multiple_to_single(L: Vec<isize>) -> isize {\n", "task": "mbpp_439_multiple_to_single"}
{"content": "/// Write a function to find the surface area of a cube of a given size.\nfn surfacearea_cube(l: isize) -> isize {\n    6 * l * l\n}", "retrieval_text": "/// Write a function to find the surface area of a cube of a given size.\nfn surfacearea_cube(l: isize) -> isize {\n", "task": "mbpp_441_surfacearea_cube"}
{"content": "/// Write a rsthon function to find the largest negative number from the given vector.\nfn largest_neg(list1: Vec<isize>) -> isize {\n    let mut max = list1[0];\n    for x in list1 {\n        if x < max {\n            max = x\n        }\n    }\n    max\n}", "retrieval_text": "/// Write a rsthon function to find the largest negative number from the given vector.\nfn largest_neg(list1: Vec<isize>) -> isize {\n", "task": "mbpp_443_largest_neg"}
{"content": "/// Write a function to trim each vector by k in the given vectors.\nfn trim_tuple(test_list: Vec<Vec<isize>>, K: isize) -> Vec<Vec<isize>> {\n    let mut res = vec![];\n    for ele in test_list {\n        let N = ele.len();\n        let ele = ele[K as usize..N as usize - K as usize].to_vec();\n        res.push(ele);\n    }\n    res\n}", "retrieval_text": "/// Write a function to trim each vector by k in the given vectors.\nfn trim_tuple(test_list: Vec<Vec<isize>>, K: isize) -> Vec<Vec<isize>> {\n", "task": "mbpp_444_trim_tuple"}
{"content": "/// Write a function to perform index wise multiplication of vector elements in the given two vectors.\nfn index_multiplication(test_tup1: Vec<Vec<isize>>, test_tup2: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n    test_tup1\n        .iter()\n        .zip(test_tup2.iter())\n        .map(|(a, b)| {\n            a.iter()\n                .zip(b.iter())\n                .map(|(x, y)| x * y)\n                .collect()\n        })\n        .collect()\n}", "retrieval_text": "/// Write a function to perform index wise multiplication of vector elements in the given two vectors.\nfn index_multiplication(test_tup1: Vec<Vec<isize>>, test_tup2: Vec<Vec<isize>>) -> Vec<Vec<isize>> {\n", "task": "mbpp_445_index_multiplication"}
{"content": "/// Write a function to find cubes of individual elements in a vector.\nfn cube_nums(nums: Vec<isize>) -> Vec<isize> {\n    nums.iter()\n        .map(|&x| x.pow(3))\n        .collect()\n}", "retrieval_text": "/// Write a function to find cubes of individual elements in a vector.\nfn cube_nums(nums: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_447_cube_nums"}
{"content": "/// Write a function to extract specified size of strings from a given vector of string values.\nfn extract_string(str: Vec<String>, l: isize) -> Vec<String> {\n    str.into_iter().filter(|e| e.len() == l as usize).collect()\n}", "retrieval_text": "/// Write a function to extract specified size of strings from a given vector of string values.\nfn extract_string(str: Vec<String>, l: isize) -> Vec<String> {\n", "task": "mbpp_450_extract_string"}
{"content": "/// Write a function to remove all whitespaces from the given string.\nfn remove_whitespaces(text1: String) -> String {\n    text1.replace(\" \", \"\")\n}", "retrieval_text": "/// Write a function to remove all whitespaces from the given string.\nfn remove_whitespaces(text1: String) -> String {\n", "task": "mbpp_451_remove_whitespaces"}
{"content": "/// Write a function that gives loss amount on a sale if the given amount has loss else return 0.\nfn loss_amount(actual_cost: isize, sale_amount: isize) -> isize {\n    if sale_amount > actual_cost {\n        sale_amount - actual_cost\n    } else {\n        0\n    }\n}", "retrieval_text": "/// Write a function that gives loss amount on a sale if the given amount has loss else return 0.\nfn loss_amount(actual_cost: isize, sale_amount: isize) -> isize {\n", "task": "mbpp_452_loss_amount"}
{"content": "/// Write a function to check whether the given month number contains 31 days or not.\nfn check_monthnumb_number(monthnum2: isize) -> bool {\n    match monthnum2 {\n        1 | 3 | 5 | 7 | 8 | 10 | 12 => true,\n        _ => false\n    }\n}", "retrieval_text": "/// Write a function to check whether the given month number contains 31 days or not.\nfn check_monthnumb_number(monthnum2: isize) -> bool {\n", "task": "mbpp_455_check_monthnumb_number"}
{"content": "/// Write a function to reverse each string in a given vector of string values.\nfn reverse_string_list(stringlist: Vec<String>) -> Vec<String> {\n    stringlist.into_iter().map(|string| string.chars().rev().collect()).collect()\n}", "retrieval_text": "/// Write a function to reverse each string in a given vector of string values.\nfn reverse_string_list(stringlist: Vec<String>) -> Vec<String> {\n", "task": "mbpp_456_reverse_string_list"}
{"content": "/// Write a function to find the area of a rectangle.\nfn rectangle_area(l: isize, b: isize) -> isize {\n    l * b\n}", "retrieval_text": "/// Write a function to find the area of a rectangle.\nfn rectangle_area(l: isize, b: isize) -> isize {\n", "task": "mbpp_458_rectangle_area"}
{"content": "/// Write a rsthon function to get the first element of each subvector.\nfn Extract(lst: Vec<Vec<isize>>) -> Vec<isize> {\n    let mut result = Vec::new();\n    for v in lst {\n        result.push(v[0]);\n    }\n    result\n}", "retrieval_text": "/// Write a rsthon function to get the first element of each subvector.\nfn Extract(lst: Vec<Vec<isize>>) -> Vec<isize> {\n", "task": "mbpp_460_Extract"}
{"content": "use std::collections::HashMap;\n\n/// Write a function to check if all values are same in a HashMap.\nfn check_value(dict: HashMap<String, isize>, n: isize) -> bool {\n    dict.values().all(|&x| x == n)\n}", "retrieval_text": "use std::collections::HashMap;\n\n/// Write a function to check if all values are same in a HashMap.\nfn check_value(dict: HashMap<String, isize>, n: isize) -> bool {\n", "task": "mbpp_464_check_value"}
{"content": "/// Write a function to find the pairwise addition of the neighboring elements of the given tuple.\nfn add_pairwise(test_tup: (isize, isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n    let add = (test_tup.0 + test_tup.1, test_tup.1 + test_tup.2, test_tup.2 + test_tup.3, test_tup.3 + test_tup.4);\n    return add;\n}", "retrieval_text": "/// Write a function to find the pairwise addition of the neighboring elements of the given tuple.\nfn add_pairwise(test_tup: (isize, isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n", "task": "mbpp_470_add_pairwise"}
{"content": "/// Write a rsthon function to find the product of the vector multiplication modulo n.\nfn find_remainder(arr: Vec<isize>, n: isize) -> isize {\n    let mut mul = 1;\n    for &i in &arr {\n        mul = (mul * (i % n)) % n;\n    }\n    return mul % n;\n}", "retrieval_text": "/// Write a rsthon function to find the product of the vector multiplication modulo n.\nfn find_remainder(arr: Vec<isize>, n: isize) -> isize {\n", "task": "mbpp_471_find_remainder"}
{"content": "/// Write a rsthon function to check whether the given vector contains consecutive numbers or not.\nfn check_Consecutive(l: Vec<isize>) -> bool {\n    let mut s = l.to_owned();\n    s.sort();\n    for i in 0..s.len() - 1 {\n        if s[i] + 1 != s[i + 1] {\n            return false;\n        }\n    }\n    true\n}", "retrieval_text": "/// Write a rsthon function to check whether the given vector contains consecutive numbers or not.\nfn check_Consecutive(l: Vec<isize>) -> bool {\n", "task": "mbpp_472_check_Consecutive"}
{"content": "/// Write a function to replace characters in a string.\nfn replace_char(str1: String, ch: String, newch: String) -> String {\n    let mut str2 = str1.replace(&ch, &newch);\n    str2\n}", "retrieval_text": "/// Write a function to replace characters in a string.\nfn replace_char(str1: String, ch: String, newch: String) -> String {\n", "task": "mbpp_474_replace_char"}
{"content": "use std::collections::HashMap;\n\n/// Write a function to sort a HashMap by value.\nfn sort_counter(dict1: HashMap<String, isize>) -> Vec<(String, isize)> {\n    let mut x: Vec<(String, isize)> = vec![];\n    for (key, value) in dict1 {\n        x.push((key, value));\n    }\n    x.sort_by(|a, b| b.1.cmp(&a.1));\n    x\n}", "retrieval_text": "use std::collections::HashMap;\n\n/// Write a function to sort a HashMap by value.\nfn sort_counter(dict1: HashMap<String, isize>) -> Vec<(String, isize)> {\n", "task": "mbpp_475_sort_counter"}
{"content": "/// Write a rsthon function to find the sum of the largest and smallest value in a given vector.\nfn big_sum(nums: Vec<isize>) -> isize {\n    let sum = nums[0] + nums[nums.len() - 1];\n    sum\n}", "retrieval_text": "/// Write a rsthon function to find the sum of the largest and smallest value in a given vector.\nfn big_sum(nums: Vec<isize>) -> isize {\n", "task": "mbpp_476_big_sum"}
{"content": "/// Write a rsthon function to convert the given string to lower case.\nfn is_lower(string: String) -> String {\n    string.to_lowercase()\n}", "retrieval_text": "/// Write a rsthon function to convert the given string to lower case.\nfn is_lower(string: String) -> String {\n", "task": "mbpp_477_is_lower"}
{"content": "/// Write a function to remove lowercase substrings from a given string.\nfn remove_lowercase(str1: String) -> String {\n    let mut new_str = String::new();\n    for c in str1.chars() {\n        if c.is_ascii_uppercase() {\n            new_str.push(c);\n        }\n    }\n    return new_str;\n}", "retrieval_text": "/// Write a function to remove lowercase substrings from a given string.\nfn remove_lowercase(str1: String) -> String {\n", "task": "mbpp_478_remove_lowercase"}
{"content": "/// Write a rsthon function to find the first digit of a given number.\nfn first_Digit(n: isize) -> isize {\n    let mut n = n;\n    while n >= 10 {\n        n = n / 10;\n    }\n    n\n}", "retrieval_text": "/// Write a rsthon function to find the first digit of a given number.\nfn first_Digit(n: isize) -> isize {\n", "task": "mbpp_479_first_Digit"}
{"content": "/// Write a rsthon function which takes a vector of integers and only returns the odd ones.\nfn Split(list: Vec<isize>) -> Vec<isize> {\n    list.into_iter().filter(|&x| x % 2 != 0).collect()\n}", "retrieval_text": "/// Write a rsthon function which takes a vector of integers and only returns the odd ones.\nfn Split(list: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_554_Split"}
{"content": "/// Write a rsthon function to find the difference between the sum of cubes of the first n natural numbers and the sum of the first n natural numbers.\nfn difference(n: isize) -> isize {\n    let mut s = (n * (n + 1)) / 2;\n    let res = s * (s - 1);\n    return res;\n}", "retrieval_text": "/// Write a rsthon function to find the difference between the sum of cubes of the first n natural numbers and the sum of the first n natural numbers.\nfn difference(n: isize) -> isize {\n", "task": "mbpp_555_difference"}
{"content": "/// Write a function to toggle the case of all characters in a string.\nfn toggle_string(string: String) -> String {\n    string.chars().map(|c| if c.is_uppercase() { c.to_lowercase().to_string() } else { c.to_uppercase().to_string() }).collect::<String>()\n}", "retrieval_text": "/// Write a function to toggle the case of all characters in a string.\nfn toggle_string(string: String) -> String {\n", "task": "mbpp_557_toggle_string"}
{"content": "/// Write a rsthon function to find the sum of the per-digit difference between two integers.\nfn digit_distance_nums(n1: isize, n2: isize) -> isize {\n    let diff = n1.abs_diff(n2);\n    diff.to_string().chars().map(|c| c.to_digit(10).unwrap()).sum::<u32>() as isize\n}", "retrieval_text": "/// Write a rsthon function to find the sum of the per-digit difference between two integers.\nfn digit_distance_nums(n1: isize, n2: isize) -> isize {\n", "task": "mbpp_558_digit_distance_nums"}
{"content": "/// Write a function to find the sum of the largest contiguous subvector in the given vector.\nfn max_sub_array_sum(a: Vec<isize>, size: isize) -> isize {\n  let mut max_so_far = 0;\n  let mut max_ending_here = 0;\n\n  for i in 0..size {\n    max_ending_here = max_ending_here + a[i as usize];\n\n    if max_ending_here < 0 {\n      max_ending_here = 0;\n    } else if max_so_far < max_ending_here {\n      max_so_far = max_ending_here;\n    }\n  }\n  max_so_far\n}", "retrieval_text": "/// Write a function to find the sum of the largest contiguous subvector in the given vector.\nfn max_sub_array_sum(a: Vec<isize>, size: isize) -> isize {\n", "task": "mbpp_559_max_sub_array_sum"}
{"content": "/// Write a function to find the union of the elements of two given vectors and output them in sorted order.\nfn union_elements(test_tup1: Vec<isize>, test_tup2: Vec<isize>) -> Vec<isize> {\n    let mut vec: Vec<isize> = vec![];\n    for elem in test_tup1.iter() {\n        vec.push(*elem);\n    }\n    for elem in test_tup2.iter() {\n        vec.push(*elem);\n    }\n    vec.sort();\n    vec.dedup();\n    vec\n}", "retrieval_text": "/// Write a function to find the union of the elements of two given vectors and output them in sorted order.\nfn union_elements(test_tup1: Vec<isize>, test_tup2: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_560_union_elements"}
{"content": "/// Write a rsthon function to find the length of the longest subvectors.\nfn Find_Max_Length(lst: Vec<Vec<isize>>) -> isize {\n    lst.iter().fold(0, |max, x| {\n        let length = x.len() as isize;\n        max.max(length)\n    })\n}", "retrieval_text": "/// Write a rsthon function to find the length of the longest subvectors.\nfn Find_Max_Length(lst: Vec<Vec<isize>>) -> isize {\n", "task": "mbpp_562_Find_Max_Length"}
{"content": "/// Write a rsthon function which takes a vector of integers and counts the number of possible unordered pairs where both elements are unequal.\nfn count_Pairs(arr: Vec<isize>, n: isize) -> isize {\n    let mut cnt = 0;\n    for i in 0..n as usize {\n        for j in i + 1..n as usize {\n            if arr[i] != arr[j] {\n                cnt += 1;\n            }\n        }\n    }\n    cnt\n}", "retrieval_text": "/// Write a rsthon function which takes a vector of integers and counts the number of possible unordered pairs where both elements are unequal.\nfn count_Pairs(arr: Vec<isize>, n: isize) -> isize {\n", "task": "mbpp_564_count_Pairs"}
{"content": "/// Write a rsthon function to split a string into characters.\nfn split(word: String) -> Vec<String> {\n    word.chars().map(|x| x.to_string()).collect()\n}", "retrieval_text": "/// Write a rsthon function to split a string into characters.\nfn split(word: String) -> Vec<String> {\n", "task": "mbpp_565_split"}
{"content": "/// Write a function to get the sum of the digits of a non-negative integer.\nfn sum_digits(n: isize) -> isize {\n    match n {\n        0 => 0,\n        _ => n % 10 + sum_digits(n / 10),\n    }\n}", "retrieval_text": "/// Write a function to get the sum of the digits of a non-negative integer.\nfn sum_digits(n: isize) -> isize {\n", "task": "mbpp_566_sum_digits"}
{"content": "/// Write a function to check whether a specified vector is sorted or not.\nfn issort_list(list1: Vec<isize>) -> bool {\n    let result = list1\n        .iter()\n        .zip(list1.iter().skip(1))\n        .all(|(a, b)| *a <= *b);\n    result\n}", "retrieval_text": "/// Write a function to check whether a specified vector is sorted or not.\nfn issort_list(list1: Vec<isize>) -> bool {\n", "task": "mbpp_567_issort_list"}
{"content": "/// Write a rsthon function to calculate the product of the unique numbers in a given vector.\nfn unique_product(list_data: Vec<isize>) -> isize {\n    let mut temp: Vec<isize> = vec![];\n    let mut p: isize = 1;\n    for i in list_data {\n        if !temp.contains(&i) {\n            temp.push(i);\n        }\n    }\n    for i in temp {\n        p *= i;\n    }\n    p\n}", "retrieval_text": "/// Write a rsthon function to calculate the product of the unique numbers in a given vector.\nfn unique_product(list_data: Vec<isize>) -> isize {\n", "task": "mbpp_573_unique_product"}
{"content": "/// Write a function to find the surface area of a cylinder.\nfn surfacearea_cylinder(r: isize, h: isize) -> f64 {\n    let surfacearea: f64 = (2.0 * 3.1415 * r as f64 * r as f64) + (2.0 * 3.1415 * r as f64 * h as f64);\n    return surfacearea;\n}", "retrieval_text": "/// Write a function to find the surface area of a cylinder.\nfn surfacearea_cylinder(r: isize, h: isize) -> f64 {\n", "task": "mbpp_574_surfacearea_cylinder"}
{"content": "/// Write a rsthon function to check whether a vector is subvector of another or not.\nfn is_Sub_Array(A: Vec<isize>, B: Vec<isize>) -> bool {\n    let mut i = 0;\n    let mut j = 0;\n\n    while i < A.len() && j < B.len() {\n        if A[i] == B[j] {\n            i += 1;\n            j += 1;\n        } else {\n            i = i - j + 1;\n            j = 0;\n        }\n    }\n\n    j == B.len()\n}", "retrieval_text": "/// Write a rsthon function to check whether a vector is subvector of another or not.\nfn is_Sub_Array(A: Vec<isize>, B: Vec<isize>) -> bool {\n", "task": "mbpp_576_is_Sub_Array"}
{"content": "/// Write a rsthon function to find the last digit in factorial of a given number.\nfn last_Digit_Factorial(n: isize) -> isize {\n    if (n == 0) { return 1; }\n    else if (n <= 2) { return n; }\n    else if (n == 3) { return 6; }\n    else if (n == 4) { return 4; }\n    else { return 0; }\n}", "retrieval_text": "/// Write a rsthon function to find the last digit in factorial of a given number.\nfn last_Digit_Factorial(n: isize) -> isize {\n", "task": "mbpp_577_last_Digit_Factorial"}
{"content": "/// Write a function to interleave 3 vectors of the same length into a single flat vector.\nfn interleave_lists(list1: Vec<isize>, list2: Vec<isize>, list3: Vec<isize>) -> Vec<isize> {\n    // return [el for pair in zip(list1, list2, list3) for el in pair]\n    let mut result: Vec<isize> = Vec::new();\n    for i in 0..list1.len() {\n        result.push(list1[i]);\n        result.push(list2[i]);\n        result.push(list3[i]);\n    }\n    result\n}", "retrieval_text": "/// Write a function to interleave 3 vectors of the same length into a single flat vector.\nfn interleave_lists(list1: Vec<isize>, list2: Vec<isize>, list3: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_578_interleave_lists"}
{"content": "/// Write a rsthon function to find the surface area of a square rsramid with a given base edge and height.\nfn surface_Area(b: isize, s: isize) -> isize {\n    2 * b * s + b.pow(2)\n}", "retrieval_text": "/// Write a rsthon function to find the surface area of a square rsramid with a given base edge and height.\nfn surface_Area(b: isize, s: isize) -> isize {\n", "task": "mbpp_581_surface_Area"}
{"content": "/// Write a function which returns nth catalan number.\nfn catalan_number(num: isize) -> isize {\n    if num <= 1 {\n        return 1;\n    }\n    let mut res_num = 0;\n    for i in 0..num {\n        res_num += catalan_number(i) * catalan_number(num - i - 1);\n    }\n    res_num\n}", "retrieval_text": "/// Write a function which returns nth catalan number.\nfn catalan_number(num: isize) -> isize {\n", "task": "mbpp_583_catalan_number"}
{"content": "/// Write a rsthon function to split a vector at the nth eelment and add the first part to the end.\nfn split_Arr(l: Vec<isize>, n: isize) -> Vec<isize> {\n    let v1 = &l[0..n as usize];\n    let v2 = &l[n as usize..];\n    let mut result: Vec<isize> = v2.iter().chain(v1.iter()).cloned().collect();\n    return result;\n}", "retrieval_text": "/// Write a rsthon function to split a vector at the nth eelment and add the first part to the end.\nfn split_Arr(l: Vec<isize>, n: isize) -> Vec<isize> {\n", "task": "mbpp_586_split_Arr"}
{"content": "/// Write a rsthon function to find the difference between largest and smallest value in a given vector.\nfn big_diff(nums: Vec<isize>) -> isize {\n    let mut max = 0;\n    let mut min = 1000; // set to max possible value\n\n    for n in nums.iter() {\n        if *n > max {\n            max = *n;\n        }\n        if *n < min {\n            min = *n;\n        }\n    }\n\n    max - min\n}", "retrieval_text": "/// Write a rsthon function to find the difference between largest and smallest value in a given vector.\nfn big_diff(nums: Vec<isize>) -> isize {\n", "task": "mbpp_588_big_diff"}
{"content": "/// Write a function to find perfect squares between two given numbers.\nfn perfect_squares(a: isize, b: isize) -> Vec<isize> {\n    let mut res = Vec::new();\n    let mut i = a;\n    while i <= b {\n        let mut j = 1;\n        while j * j <= i {\n            if j * j == i {\n                res.push(i);\n            }\n            j += 1;\n        }\n        i += 1;\n    }\n    res\n}", "retrieval_text": "/// Write a function to find perfect squares between two given numbers.\nfn perfect_squares(a: isize, b: isize) -> Vec<isize> {\n", "task": "mbpp_589_perfect_squares"}
{"content": "/// Write a function to remove leading zeroes from an ip address.\nfn removezero_ip(ip: String) -> String {\n    let string = ip.replace(\".0\", \".\");\n    string\n}", "retrieval_text": "/// Write a function to remove leading zeroes from an ip address.\nfn removezero_ip(ip: String) -> String {\n", "task": "mbpp_593_removezero_ip"}
{"content": "/// Write a function to find the difference of the first even and first odd number of a given vector.\nfn diff_even_odd(list1: Vec<isize>) -> isize {\n    let first_even = list1.iter().find(|&&x| x % 2 == 0).cloned().unwrap_or(-1);\n    let first_odd = list1.iter().find(|&&x| x % 2 != 0).cloned().unwrap_or(-1);\n\n    first_even - first_odd\n}", "retrieval_text": "/// Write a function to find the difference of the first even and first odd number of a given vector.\nfn diff_even_odd(list1: Vec<isize>) -> isize {\n", "task": "mbpp_594_diff_even_odd"}
{"content": "/// Write a function to find kth element from the given two sorted vectors.\nfn find_kth(arr1: Vec<isize>, arr2: Vec<isize>, k: isize) -> isize {\n    let mut i = 0;\n    let mut j = 0;\n    let mut d = 0;\n\n    while i < arr1.len() && j < arr2.len() {\n        if arr1[i] < arr2[j] {\n            d += 1;\n            if d == k {\n                return arr1[i];\n            }\n            i += 1;\n        } else {\n            d += 1;\n            if d == k {\n                return arr2[j];\n            }\n            j += 1;\n        }\n    }\n\n    while i < arr1.len() {\n        d += 1;\n        if d == k {\n            return arr1[i];\n        }\n        i += 1;\n    }\n\n    while j < arr2.len() {\n        d += 1;\n        if d == k {\n            return arr2[j];\n        }\n        j += 1;\n    }\n\n    0\n}", "retrieval_text": "/// Write a function to find kth element from the given two sorted vectors.\nfn find_kth(arr1: Vec<isize>, arr2: Vec<isize>, k: isize) -> isize {\n", "task": "mbpp_597_find_kth"}
{"content": "/// Write a function to check whether the given number is armstrong or not.\nfn armstrong_number(number: isize) -> bool {\n    let mut sum = 0;\n    let mut times = 0;\n    let mut temp = number;\n    while temp > 0 {\n        times = times + 1;\n        temp = temp / 10;\n    }\n    temp = number;\n    while temp > 0 {\n        let mut reminder = temp % 10;\n        sum = sum + (reminder as isize).pow(times);\n        temp = temp / 10;\n    }\n    number == sum\n}", "retrieval_text": "/// Write a function to check whether the given number is armstrong or not.\nfn armstrong_number(number: isize) -> bool {\n", "task": "mbpp_598_armstrong_number"}
{"content": "/// Write a function to find sum and average of first n natural numbers.\nfn sum_average(number: isize) -> (isize, f64) {\n    let mut total = 0;\n    for value in 1..number+1 {\n        total += value;\n    }\n    let average = total as f64 / number as f64;\n    (total, average)\n}", "retrieval_text": "/// Write a function to find sum and average of first n natural numbers.\nfn sum_average(number: isize) -> (isize, f64) {\n", "task": "mbpp_599_sum_average"}
{"content": "/// Write a rsthon function to check whether the given number is even or not.\nfn is_Even(n: isize) -> bool {\n    if n ^ 1 == n + 1 {\n        true\n    } else {\n        false\n    }\n}", "retrieval_text": "/// Write a rsthon function to check whether the given number is even or not.\nfn is_Even(n: isize) -> bool {\n", "task": "mbpp_600_is_Even"}
{"content": "/// Write a rsthon function to find the first repeated character in a given string.\nfn first_repeated_char(str1: String) -> Option<String> {\n    let mut chars = Vec::new();\n    for c in str1.chars() {\n        if chars.contains(&c) {\n            return Some(c.to_string());\n        }\n        chars.push(c);\n    }\n    None\n}", "retrieval_text": "/// Write a rsthon function to find the first repeated character in a given string.\nfn first_repeated_char(str1: String) -> Option<String> {\n", "task": "mbpp_602_first_repeated_char"}
{"content": "/// Write a function to reverse words seperated by spaces in a given string.\nfn reverse_words(s: String) -> String {\n    s.split_whitespace().rev().collect::<Vec<&str>>().join(\" \")\n}", "retrieval_text": "/// Write a function to reverse words seperated by spaces in a given string.\nfn reverse_words(s: String) -> String {\n", "task": "mbpp_604_reverse_words"}
{"content": "/// Write a function to check if the given integer is a prime number.\nfn prime_num(num: isize) -> bool {\n    if num >= 1 {\n        for i in 2..num / 2 {\n            if num % i == 0 {\n                return false;\n            }\n        }\n        true\n    } else {\n        false\n    }\n}", "retrieval_text": "/// Write a function to check if the given integer is a prime number.\nfn prime_num(num: isize) -> bool {\n", "task": "mbpp_605_prime_num"}
{"content": "/// Write a function to convert degrees to radians.\nfn radian_degree(degree: isize) -> f64 {\n    let pi: f64 = std::f64::consts::PI;\n    return degree as f64 * pi / 180.;\n}", "retrieval_text": "/// Write a function to convert degrees to radians.\nfn radian_degree(degree: isize) -> f64 {\n", "task": "mbpp_606_radian_degree"}
{"content": "/// Write a rsthon function which takes a vector and returns a vector with the same elements, but the k'th element removed.\nfn remove_kth_element(list1: Vec<isize>, L: isize) -> Vec<isize> {\n    let mut new_vector = vec![];\n    for i in 0..list1.len() {\n        if i != L as usize - 1 {\n            new_vector.push(list1[i]);\n        }\n    }\n    new_vector\n}", "retrieval_text": "/// Write a rsthon function which takes a vector and returns a vector with the same elements, but the k'th element removed.\nfn remove_kth_element(list1: Vec<isize>, L: isize) -> Vec<isize> {\n", "task": "mbpp_610_remove_kth_element"}
{"content": "/// Write a function which given a matrix represented as a vector of vectors returns the max of the n'th column.\nfn max_of_nth(test_list: Vec<Vec<isize>>, N: isize) -> isize {\n    let res = test_list.iter().map(|x| x[N as usize]).max().unwrap();\n    return res;\n}", "retrieval_text": "/// Write a function which given a matrix represented as a vector of vectors returns the max of the n'th column.\nfn max_of_nth(test_list: Vec<Vec<isize>>, N: isize) -> isize {\n", "task": "mbpp_611_max_of_nth"}
{"content": "/// Write a function to find the cumulative sum of all the values that are present in the given vector of vectors.\nfn cummulative_sum(test_list: Vec<Vec<isize>>) -> isize {\n    let result: isize = test_list.iter().fold(0, |acc, x| acc + x.iter().sum::<isize>());\n    result\n}", "retrieval_text": "/// Write a function to find the cumulative sum of all the values that are present in the given vector of vectors.\nfn cummulative_sum(test_list: Vec<Vec<isize>>) -> isize {\n", "task": "mbpp_614_cummulative_sum"}
{"content": "/// Write a function which takes two tuples of the same length and performs the element wise modulo.\nfn tuple_modulo(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n    let (x1, y1, z1, w1) = test_tup1;\n    let (x2, y2, z2, w2) = test_tup2;\n    let res = (x1 % x2, y1 % y2, z1 % z2, w1 % w2);\n    res\n}", "retrieval_text": "/// Write a function which takes two tuples of the same length and performs the element wise modulo.\nfn tuple_modulo(test_tup1: (isize, isize, isize, isize), test_tup2: (isize, isize, isize, isize)) -> (isize, isize, isize, isize) {\n", "task": "mbpp_616_tuple_modulo"}
{"content": "/// Write a function to check for the number of jumps required of given length to reach a point of form (d, 0) from origin in a 2d plane.\nfn min_Jumps(steps: (isize, isize), d: isize) -> f64 {\n    let a = steps.0;\n    let b = steps.1;\n    if d >= b {\n        return (d + b - 1) as f64 / b as f64;\n    }\n    if d == 0 {\n        return 0.0;\n    }\n    if d == a {\n        return 1.0;\n    }\n    2.0\n}", "retrieval_text": "/// Write a function to check for the number of jumps required of given length to reach a point of form (d, 0) from origin in a 2d plane.\nfn min_Jumps(steps: (isize, isize), d: isize) -> f64 {\n", "task": "mbpp_617_min_Jumps"}
{"content": "/// Write a function to divide two vectors element wise.\nfn div_list(nums1: Vec<isize>, nums2: Vec<isize>) -> Vec<f64> {\n    nums1\n        .into_iter()\n        .zip(nums2.into_iter())\n        .map(|(num1, num2)| num1 as f64 / num2 as f64)\n        .collect()\n}", "retrieval_text": "/// Write a function to divide two vectors element wise.\nfn div_list(nums1: Vec<isize>, nums2: Vec<isize>) -> Vec<f64> {\n", "task": "mbpp_618_div_list"}
{"content": "/// Write a function to move all the numbers to the end of the given string.\nfn move_num(test_str: String) -> String {\n  let mut res = \"\".to_string();\n  let mut dig = \"\".to_string();\n  for ele in test_str.chars() {\n    if ele.is_digit(10) {\n      dig += &ele.to_string();\n    } else {\n      res += &ele.to_string();\n    }\n  }\n  res += &dig;\n  res\n}", "retrieval_text": "/// Write a function to move all the numbers to the end of the given string.\nfn move_num(test_str: String) -> String {\n", "task": "mbpp_619_move_num"}
{"content": "/// Write a function to compute the n-th power of each number in a vector.\nfn nth_nums(nums: Vec<isize>, n: isize) -> Vec<isize> {\n    let mut output = Vec::new();\n    for num in nums {\n        output.push(num.pow(n as u32));\n    }\n    output\n}", "retrieval_text": "/// Write a function to compute the n-th power of each number in a vector.\nfn nth_nums(nums: Vec<isize>, n: isize) -> Vec<isize> {\n", "task": "mbpp_623_nth_nums"}
{"content": "/// Write a rsthon function to convert a given string to uppercase.\nfn is_upper(string: String) -> String {\n    string.to_uppercase()\n}", "retrieval_text": "/// Write a rsthon function to convert a given string to uppercase.\nfn is_upper(string: String) -> String {\n", "task": "mbpp_624_is_upper"}
{"content": "/// Write a rsthon function to find the area of the largest triangle that can be inscribed in a semicircle with a given radius.\nfn triangle_area(r: isize) -> Option<isize> {\n    if r < 0 {\n        return None;\n    }\n    Some(r * r)\n}", "retrieval_text": "/// Write a rsthon function to find the area of the largest triangle that can be inscribed in a semicircle with a given radius.\nfn triangle_area(r: isize) -> Option<isize> {\n", "task": "mbpp_626_triangle_area"}
{"content": "/// Write a rsthon function to find the smallest missing number from a sorted vector of natural numbers.\nfn find_First_Missing(array: Vec<isize>) -> isize {\n    if (array[0] != 0) {\n        return 0\n    }\n    let mut start = 0;\n    let mut end = array.len() - 1;\n    while start <= end {\n        let mid = (start + end) / 2;\n        if (array[mid] != mid as isize) {\n            if mid > 0 && array[mid - 1] == (mid - 1) as isize {\n                return mid as isize;\n            } else {\n                end = mid - 1;\n            }\n        } else {\n            start = mid + 1;\n        }\n    }\n    return end as isize + 1;\n}", "retrieval_text": "/// Write a rsthon function to find the smallest missing number from a sorted vector of natural numbers.\nfn find_First_Missing(array: Vec<isize>) -> isize {\n", "task": "mbpp_627_find_First_Missing"}
{"content": "/// Write a rsthon function to find even numbers from a vector of numbers.\nfn Split(list: Vec<isize>) -> Vec<isize> {\n    let mut ev_li = Vec::new();\n    for i in list {\n        if i % 2 == 0 {\n            ev_li.push(i);\n        }\n    }\n    ev_li\n}", "retrieval_text": "/// Write a rsthon function to find even numbers from a vector of numbers.\nfn Split(list: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_629_Split"}
{"content": "/// Write a function to extract all the adjacent coordinates of the given coordinate tuple.\nfn get_coordinates(test_tup: (isize, isize)) -> Vec<Vec<isize>> {\n    let mut coordinates: Vec<Vec<isize>> = vec![];\n    let mut i = test_tup.0 - 1;\n    let mut j = test_tup.1 - 1;\n    while i <= test_tup.0 + 1 {\n        j = test_tup.1 - 1;\n        while j <= test_tup.1 + 1 {\n            coordinates.push(vec![i, j]);\n            j += 1;\n        }\n        i += 1;\n    }\n    coordinates\n}", "retrieval_text": "/// Write a function to extract all the adjacent coordinates of the given coordinate tuple.\nfn get_coordinates(test_tup: (isize, isize)) -> Vec<Vec<isize>> {\n", "task": "mbpp_630_get_coordinates"}
{"content": "/// Write a function to replace whitespaces with an underscore and vice versa in a given string.\nfn replace_spaces(text: String) -> String {\n  let mut result = String::new();\n  for c in text.chars() {\n    if c == ' ' {\n      result.push('_');\n    } else if c == '_' {\n      result.push(' ');\n    } else {\n      result.push(c);\n    }\n  }\n  result\n}", "retrieval_text": "/// Write a function to replace whitespaces with an underscore and vice versa in a given string.\nfn replace_spaces(text: String) -> String {\n", "task": "mbpp_631_replace_spaces"}
{"content": "/// Write a rsthon function to move all zeroes to the end of the given vector.\nfn move_zero(num_list: Vec<isize>) -> Vec<isize> {\n    let mut a = Vec::new();\n    let mut x = Vec::new();\n    for i in 0..num_list.len() {\n        if num_list[i] == 0 {\n            a.push(0);\n        } else {\n            x.push(num_list[i]);\n        }\n    }\n    x.extend(a);\n    x\n}", "retrieval_text": "/// Write a rsthon function to move all zeroes to the end of the given vector.\nfn move_zero(num_list: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_632_move_zero"}
{"content": "/// Write a rsthon function to find the sum of xor of all pairs of numbers in the given vector.\nfn pair_xor_Sum(arr: Vec<isize>, n: isize) -> isize {\n    let mut ans: isize = 0;\n\n    for i in 0..n as usize {\n        for j in i + 1..n as usize {\n            ans = ans + (arr[i] ^ arr[j]);\n        }\n    }\n    ans\n}", "retrieval_text": "/// Write a rsthon function to find the sum of xor of all pairs of numbers in the given vector.\nfn pair_xor_Sum(arr: Vec<isize>, n: isize) -> isize {\n", "task": "mbpp_633_pair_xor_Sum"}
{"content": "/// Write a function to sort the given vector.\nfn heap_sort(iterable: Vec<isize>) -> Vec<isize> {\n    let mut h = Vec::new();\n    for value in iterable {\n        h.push(value);\n    }\n    h.sort();\n    h\n}", "retrieval_text": "/// Write a function to sort the given vector.\nfn heap_sort(iterable: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_635_heap_sort"}
{"content": "/// Write a function to check whether the given amount has no profit and no loss\nfn noprofit_noloss(actual_cost: isize, sale_amount: isize) -> bool {\n  sale_amount == actual_cost\n}", "retrieval_text": "/// Write a function to check whether the given amount has no profit and no loss\nfn noprofit_noloss(actual_cost: isize, sale_amount: isize) -> bool {\n", "task": "mbpp_637_noprofit_noloss"}
{"content": "/// Write a function to sum the length of the names of a given vector of names after removing the names that start with a lowercase letter.\nfn sample_nam(sample_names: Vec<String>) -> isize {\n    let mut len: isize = 0;\n    let names = sample_names\n        .iter()\n        .filter(|el| el.chars().next().unwrap().is_uppercase())\n        .collect::<Vec<&String>>();\n    for name in names {\n        len += name.len() as isize;\n    }\n    return len;\n}", "retrieval_text": "/// Write a function to sum the length of the names of a given vector of names after removing the names that start with a lowercase letter.\nfn sample_nam(sample_names: Vec<String>) -> isize {\n", "task": "mbpp_639_sample_nam"}
{"content": "/// Write a function to find the nth nonagonal number.\nfn is_nonagonal(n: isize) -> isize {\n    (n * (7 * n - 5)) / 2\n}", "retrieval_text": "/// Write a function to find the nth nonagonal number.\nfn is_nonagonal(n: isize) -> isize {\n", "task": "mbpp_641_is_nonagonal"}
{"content": "/// Write a rsthon function to reverse a vector upto a given position.\nfn reverse_Array_Upto_K(input: Vec<isize>, k: isize) -> Vec<isize> {\n    let mut temp = Vec::new();\n    for i in (0..(k as usize)).rev() {\n        temp.push(input[i]);\n    }\n    for i in (k as usize..input.len()) {\n        temp.push(input[i]);\n    }\n    temp\n}", "retrieval_text": "/// Write a rsthon function to reverse a vector upto a given position.\nfn reverse_Array_Upto_K(input: Vec<isize>, k: isize) -> Vec<isize> {\n", "task": "mbpp_644_reverse_Array_Upto_K"}
{"content": "/// Given a square matrix of size N*N given as a vector of vectors, where each cell is associated with a specific cost. A path is defined as a specific sequence of cells that starts from the top-left cell move only right or down and ends on bottom right cell. We want to find a path with the maximum average over all existing paths. Average is computed as total cost divided by the number of cells visited in the path.\nfn maxAverageOfPath(cost: Vec<Vec<isize>>) -> f64 {\n    let n = cost.len();\n    let mut dp = vec![vec![0; n]; n];\n    dp[0][0] = cost[0][0];\n    for i in 1..n {\n        dp[i][0] = dp[i - 1][0] + cost[i][0];\n    }\n    for j in 1..n {\n        dp[0][j] = dp[0][j - 1] + cost[0][j];\n    }\n    for i in 1..n {\n        for j in 1..n {\n            dp[i][j] = std::cmp::max(dp[i - 1][j], dp[i][j - 1]) + cost[i][j];\n        }\n    }\n    let sum = dp[n - 1][n - 1];\n    let num_cells = (2 * n) - 1;\n    (sum as f64) / (num_cells as f64)\n}", "retrieval_text": "/// Given a square matrix of size N*N given as a vector of vectors, where each cell is associated with a specific cost. A path is defined as a specific sequence of cells that starts from the top-left cell move only right or down and ends on bottom right cell. We want to find a path with the maximum average over all existing paths. Average is computed as total cost divided by the number of cells visited in the path.\nfn maxAverageOfPath(cost: Vec<Vec<isize>>) -> f64 {\n", "task": "mbpp_721_maxAverageOfPath"}
{"content": "/// The input is defined as two vectors of the same length. Write a function to count indices where the vectors have the same values.\nfn count_same_pair(nums1: Vec<isize>, nums2: Vec<isize>) -> isize {\n    let mut result = 0;\n\n    for i in 0..nums1.len() {\n        if nums1[i] == nums2[i] {\n            result += 1;\n        }\n    }\n\n    result\n}", "retrieval_text": "/// The input is defined as two vectors of the same length. Write a function to count indices where the vectors have the same values.\nfn count_same_pair(nums1: Vec<isize>, nums2: Vec<isize>) -> isize {\n", "task": "mbpp_723_count_same_pair"}
{"content": "/// Write a function takes as input two vectors [a_1,...,a_n], [b_1,...,b_n] and returns [a_1+b_1,...,a_n+b_n].\nfn sum_list(lst1: Vec<isize>, lst2: Vec<isize>) -> Vec<isize> {\n    return lst1.iter().zip(lst2.iter()).map(|(x, y)| x + y).collect();\n}", "retrieval_text": "/// Write a function takes as input two vectors [a_1,...,a_n], [b_1,...,b_n] and returns [a_1+b_1,...,a_n+b_n].\nfn sum_list(lst1: Vec<isize>, lst2: Vec<isize>) -> Vec<isize> {\n", "task": "mbpp_728_sum_list"}
{"content": "/// Write a function to find the lateral surface area of a cone given radius r and the height h.\nfn lateralsurface_cone(r: isize, h: isize) -> f64 {\n    // Calculate the lateral surface area using the provided formula\n    // and return the result\n    let l = f64::sqrt(r as f64 * r as f64 + h as f64 * h as f64);\n    let LSA = std::f64::consts::PI * r as f64 * l;\n    return LSA\n}", "retrieval_text": "/// Write a function to find the lateral surface area of a cone given radius r and the height h.\nfn lateralsurface_cone(r: isize, h: isize) -> f64 {\n", "task": "mbpp_731_lateralsurface_cone"}
{"content": "/// Write a function to replace all occurrences of spaces, commas, or dots with a colon.\nfn replace_specialchar(text: String) -> String {\n    let mut new_string = String::new();\n    for ch in text.chars() {\n        match ch {\n            ' ' => new_string.push(':'),\n            ',' => new_string.push(':'),\n            '.' => new_string.push(':'),\n            _ => new_string.push(ch),\n        }\n    }\n    new_string\n}", "retrieval_text": "/// Write a function to replace all occurrences of spaces, commas, or dots with a colon.\nfn replace_specialchar(text: String) -> String {\n", "task": "mbpp_732_replace_specialchar"}
{"content": "/// Write a function to find the index of the first occurrence of a given number in a sorted vector.\nfn find_first_occurrence(A: Vec<isize>, x: isize) -> isize {\n    let mut left = 0;\n    let mut right = A.len() - 1;\n    let mut result = -1;\n    while left <= right {\n        let mid = (left + right) / 2;\n        if A[mid] == x {\n            result = mid as isize;\n            right = mid - 1;\n        } else if x < A[mid] {\n            right = mid - 1;\n        } else {\n            left = mid + 1;\n        }\n    }\n    result\n}", "retrieval_text": "/// Write a function to find the index of the first occurrence of a given number in a sorted vector.\nfn find_first_occurrence(A: Vec<isize>, x: isize) -> isize {\n", "task": "mbpp_733_find_first_occurrence"}
{"content": "/// Write a function to calculate the geometric sum of n-1. https://www.w3resource.com/rsthon-exercises/data-structures-and-algorithms/rsthon-recursion-exercise-9.php\nfn geometric_sum(n: isize) -> f64 {\n    if n < 0 {\n        0.0\n    } else {\n        1.0 / (2.0f64.powf(n as f64)) + geometric_sum(n - 1)\n    }\n}", "retrieval_text": "/// Write a function to calculate the geometric sum of n-1. https://www.w3resource.com/rsthon-exercises/data-structures-and-algorithms/rsthon-recursion-exercise-9.php\nfn geometric_sum(n: isize) -> f64 {\n", "task": "mbpp_738_geometric_sum"}
{"content": "/// Write a rsthon function to check whether all the characters are same or not.\nfn all_Characters_Same(s: String) -> bool {\n    let n = s.len();\n    for i in 1..n {\n        if s.chars().nth(i).unwrap() != s.chars().nth(0).unwrap() {\n            return false;\n        }\n    }\n    true\n}", "retrieval_text": "/// Write a rsthon function to check whether all the characters are same or not.\nfn all_Characters_Same(s: String) -> bool {\n", "task": "mbpp_741_all_Characters_Same"}
{"content": "/// Write a function to rotate a given vector by specified number of items to the right direction. https://www.geeksforgeeks.org/rsthon-program-right-rotate-vector-n/\nfn rotate_right(list: Vec<isize>, m: isize) -> Vec<isize> {\n    let mut result = list.clone();\n    let m = (list.len() as isize + m) % list.len() as isize;\n    result.rotate_right(m as usize);\n    result\n}", "retrieval_text": "/// Write a function to rotate a given vector by specified number of items to the right direction. https://www.geeksforgeeks.org/rsthon-program-right-rotate-vector-n/\nfn rotate_right(list: Vec<isize>, m: isize) -> Vec<isize> {\n", "task": "mbpp_743_rotate_right"}
{"content": "/// Write a function to find the longest common subsequence for the given three string sequence. https://www.geeksforgeeks.org/lcs-longest-common-subsequence-three-strings/\nfn lcs_of_three(X: String, Y: String, Z: String) -> isize {\n    let m = X.len();\n    let n = Y.len();\n    let o = Z.len();\n    let mut L = vec![vec![vec![0; o + 1]; n + 1]; m + 1];\n    for i in 0..m + 1 {\n        for j in 0..n + 1 {\n            for k in 0..o + 1 {\n                if i == 0 || j == 0 || k == 0 {\n                    L[i][j][k] = 0;\n                } else if X.chars().nth(i - 1) == Y.chars().nth(j - 1) && X.chars().nth(i - 1) == Z.chars().nth(k - 1) {\n                    L[i][j][k] = L[i - 1][j - 1][k - 1] + 1;\n                } else {\n                    L[i][j][k] = std::cmp::max(\n                        std::cmp::max(L[i - 1][j][k], L[i][j - 1][k]),\n                        L[i][j][k - 1],\n                    );\n                }\n            }\n        }\n    }\n    L[m][n][o]\n}", "retrieval_text": "/// Write a function to find the longest common subsequence for the given three string sequence. https://www.geeksforgeeks.org/lcs-longest-common-subsequence-three-strings/\nfn lcs_of_three(X: String, Y: String, Z: String) -> isize {\n", "task": "mbpp_747_lcs_of_three"}
{"content": "/// Write a function to check if the given vector represents min heap or not. https://www.geeksforgeeks.org/how-to-check-if-a-given-vector-represents-a-binary-heap/\nfn check_min_heap(arr: Vec<isize>) -> bool {\n    let n = arr.len();\n    for i in 0..n / 2 {\n        let left_child = 2 * i + 1;\n        let right_child = 2 * i + 2;\n        if left_child < n && arr[i] > arr[left_child] {\n            return false;\n        }\n        if right_child < n && arr[i] > arr[right_child] {\n            return false;\n        }\n    }\n    true\n}", "retrieval_text": "/// Write a function to check if the given vector represents min heap or not. https://www.geeksforgeeks.org/how-to-check-if-a-given-vector-represents-a-binary-heap/\nfn check_min_heap(arr: Vec<isize>) -> bool {\n", "task": "mbpp_751_check_min_heap"}
{"content": "/// Write a function to find the nth jacobsthal number. https://www.geeksforgeeks.org/jacobsthal-and-jacobsthal-lucas-numbers/ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341, 683, 1365, 2731, ...\nfn jacobsthal_num(n: isize) -> isize {\n    let mut dp = vec![0; (n + 1) as usize];\n    dp[0] = 0;\n    dp[1] = 1;\n    for i in 2..=n {\n        dp[i as usize] = dp[i as usize - 1] + 2 * dp[i as usize - 2];\n    }\n    dp[n as usize]\n}", "retrieval_text": "/// Write a function to find the nth jacobsthal number. https://www.geeksforgeeks.org/jacobsthal-and-jacobsthal-lucas-numbers/ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341, 683, 1365, 2731, ...\nfn jacobsthal_num(n: isize) -> isize {\n", "task": "mbpp_752_jacobsthal_num"}
{"content": "/// Write a function to find minimum k records from tuple vector. https://www.geeksforgeeks.org/rsthon-find-minimum-k-records-from-tuple-vector/ - in this case a verbatim cors of test cases\nfn min_k(test_list: Vec<(String, isize)>, K: isize) -> Vec<(String, isize)> {\n    // sort the vector by the second value (the time) in ascending order\n    let mut sorted_vec = test_list;\n    sorted_vec.sort_by(|a, b| a.1.cmp(&b.1));\n\n    // return the first K records\n    sorted_vec[..K as usize].to_vec()\n}", "retrieval_text": "/// Write a function to find minimum k records from tuple vector. https://www.geeksforgeeks.org/rsthon-find-minimum-k-records-from-tuple-vector/ - in this case a verbatim cors of test cases\nfn min_k(test_list: Vec<(String, isize)>, K: isize) -> Vec<(String, isize)> {\n", "task": "mbpp_753_min_k"}
{"content": "/// Write a function to count the pairs of reverse strings in the given string vector. https://www.geeksforgeeks.org/rsthon-program-to-count-the-pairs-of-reverse-strings/\nfn count_reverse_pairs(test_list: Vec<String>) -> isize {\n    let mut res = 0;\n    for i in 0..test_list.len() {\n        for j in i..test_list.len() {\n            if test_list[j] == test_list[i].chars().rev().collect::<String>() {\n                res += 1;\n            }\n        }\n    }\n    res\n}", "retrieval_text": "/// Write a function to count the pairs of reverse strings in the given string vector. https://www.geeksforgeeks.org/rsthon-program-to-count-the-pairs-of-reverse-strings/\nfn count_reverse_pairs(test_list: Vec<String>) -> isize {\n", "task": "mbpp_757_count_reverse_pairs"}
{"content": "/// Write a rsthon function to check whether a vector of numbers contains only one distinct element or not.\nfn unique_Element(arr: Vec<isize>) -> bool {\n    let s = arr.iter().collect::<std::collections::HashSet<_>>();\n    if (s.len() == 1) {\n        return true;\n    } else {\n        return false;\n    }\n}", "retrieval_text": "/// Write a rsthon function to check whether a vector of numbers contains only one distinct element or not.\nfn unique_Element(arr: Vec<isize>) -> bool {\n", "task": "mbpp_760_unique_Element"}
{"content": "/// Write a function to check whether the given month number contains 30 days or not. Months are given as number from 1 to 12.\nfn check_monthnumber_number(monthnum3: isize) -> bool {\n    if monthnum3 == 4 || monthnum3 == 6 || monthnum3 == 9 || monthnum3 == 11 {\n        true\n    } else {\n        false\n    }\n}", "retrieval_text": "/// Write a function to check whether the given month number contains 30 days or not. Months are given as number from 1 to 12.\nfn check_monthnumber_number(monthnum3: isize) -> bool {\n", "task": "mbpp_762_check_monthnumber_number"}
{"content": "/// Write a rsthon function to count number of digits in a given string.\nfn number_ctr(str: String) -> isize {\n    let mut ctr = 0;\n    for i in str.chars() {\n        if i.is_ascii_digit() {\n            ctr += 1;\n        }\n    }\n    ctr\n}", "retrieval_text": "/// Write a rsthon function to count number of digits in a given string.\nfn number_ctr(str: String) -> isize {\n", "task": "mbpp_764_number_ctr"}
{"content": "/// Write a function to return a vector of all pairs of consecutive items in a given vector.\nfn pair_wise(l1: Vec<isize>) -> Vec<(isize, isize)> {\n    let mut temp = vec![];\n\n    for i in 0..l1.len() - 1 {\n        let current_element = l1[i];\n        let next_element = l1[i + 1];\n        temp.push((current_element, next_element));\n    }\n\n    temp\n}", "retrieval_text": "/// Write a function to return a vector of all pairs of consecutive items in a given vector.\nfn pair_wise(l1: Vec<isize>) -> Vec<(isize, isize)> {\n", "task": "mbpp_766_pair_wise"}
{"content": "/// Write a rsthon function to count the number of pairs whose sum is equal to \u2018sum\u2019. The funtion gets as input a vector of numbers and the sum,\nfn get_pairs_count(arr: Vec<isize>, sum: isize) -> isize {\n    let mut count = 0;\n    for i in 0..arr.len() {\n        for j in i + 1..arr.len() {\n            if arr[i] + arr[j] == sum {\n                count += 1;\n            }\n        }\n    }\n    count\n}", "retrieval_text": "/// Write a rsthon function to count the number of pairs whose sum is equal to \u2018sum\u2019. The funtion gets as input a vector of numbers and the sum,\nfn get_pairs_count(arr: Vec<isize>, sum: isize) -> isize {\n", "task": "mbpp_767_get_pairs_count"}
{"content": "/// Write a rsthon function to find the sum of fourth power of first n odd natural numbers.\nfn odd_num_sum(n: isize) -> isize {\n    let mut sm: isize = 0;\n    for i in 1..=n {\n        let j: isize = (2 * i - 1);\n        sm = sm + (j * j * j * j);\n    }\n    sm\n}", "retrieval_text": "/// Write a rsthon function to find the sum of fourth power of first n odd natural numbers.\nfn odd_num_sum(n: isize) -> isize {\n", "task": "mbpp_770_odd_num_sum"}
{"content": "/// Write a function to check if the given expression is balanced or not. https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/\nfn check_expression(exp: String) -> bool {\n    let mut stack = Vec::new();\n    for ch in exp.chars() {\n        match ch {\n            '(' | '{' | '[' => stack.push(ch),\n            ')' | '}' | ']' => {\n                if stack.is_empty() {\n                    return false;\n                }\n                let top = stack.pop().unwrap();\n                if (top == '(' && ch != ')') || (top == '{' && ch != '}') || (top == '[' && ch != ']') {\n                    return false;\n                }\n            }\n            _ => panic!(\"Unexpected character {}\", ch),\n        }\n    }\n    stack.is_empty()\n}", "retrieval_text": "/// Write a function to check if the given expression is balanced or not. https://www.geeksforgeeks.org/check-for-balanced-parentheses-in-an-expression/\nfn check_expression(exp: String) -> bool {\n", "task": "mbpp_771_check_expression"}
{"content": "/// Write a function to remove all the words with k length in the given string.\nfn remove_length(test_str: String, K: isize) -> String {\n    let temp: Vec<&str> = test_str.split(' ').collect();\n    let res: Vec<&str> = temp.into_iter().filter(|&w| w.len() != K as usize).collect();\n    res.join(\" \")\n}", "retrieval_text": "/// Write a function to remove all the words with k length in the given string.\nfn remove_length(test_str: String, K: isize) -> String {\n", "task": "mbpp_772_remove_length"}
{"content": "/// Write a function to count those characters which have vowels as their neighbors in the given string.\nfn count_vowels(test_str: String) -> isize {\n    let mut res: isize = 0;\n    let vow_list: Vec<char> = ['a', 'e', 'i', 'o', 'u'].iter().map(|&x| x).collect();\n    for i in 1..test_str.len() - 1 {\n        if !vow_list.contains(&test_str.chars().nth(i).unwrap())\n            && (vow_list.contains(&test_str.chars().nth(i - 1).unwrap())\n                || vow_list.contains(&test_str.chars().nth(i + 1).unwrap()))\n        {\n            res += 1;\n        }\n    }\n    if !vow_list.contains(&test_str.chars().nth(0).unwrap())\n        && test_str.chars().nth(1).unwrap() == 'a' || test_str.chars().nth(1).unwrap() == 'e'\n            || test_str.chars().nth(1).unwrap() == 'i'\n            || test_str.chars().nth(1).unwrap() == 'o'\n            || test_str.chars().nth(1).unwrap() == 'u'\n    {\n        res += 1;\n    }\n    if !vow_list.contains(&test_str.chars().nth(test_str.len() - 1).unwrap())\n        && test_str.chars().nth(test_str.len() - 2).unwrap() == 'a'\n            || test_str.chars().nth(test_str.len() - 2).unwrap() == 'e'\n            || test_str.chars().nth(test_str.len() - 2).unwrap() == 'i'\n            || test_str.chars().nth(test_str.len() - 2).unwrap() == 'o'\n            || test_str.chars().nth(test_str.len() - 2).unwrap() == 'u'\n    {\n        res += 1;\n    }\n    res\n}", "retrieval_text": "/// Write a function to count those characters which have vowels as their neighbors in the given string.\nfn count_vowels(test_str: String) -> isize {\n", "task": "mbpp_776_count_vowels"}
{"content": "/// Write a rsthon function to find the sum of non-repeated elements in a given vector.\nfn find_sum(arr: Vec<isize>) -> isize {\n    let mut arr = arr.clone();\n    arr.sort();\n    let mut sum = arr[0];\n    for i in 0..arr.len()-1 {\n        if arr[i] != arr[i+1] {\n            sum += arr[i+1];\n        }\n    }\n    sum\n}", "retrieval_text": "/// Write a rsthon function to find the sum of non-repeated elements in a given vector.\nfn find_sum(arr: Vec<isize>) -> isize {\n", "task": "mbpp_777_find_sum"}
{"content": "/// Write a rsthon function to check whether the count of divisors is even. https://www.w3resource.com/rsthon-exercises/basic/rsthon-basic-1-exercise-24.php\nfn count_divisors(n: isize) -> bool {\n    let mut count = 0;\n    for i in 1..=((n as f32).sqrt() as isize) + 2 {\n        if n % i == 0 {\n            if n / i == i {\n                count = count + 1\n            } else {\n                count = count + 2\n            }\n        }\n    }\n    count % 2 == 0\n}", "retrieval_text": "/// Write a rsthon function to check whether the count of divisors is even. https://www.w3resource.com/rsthon-exercises/basic/rsthon-basic-1-exercise-24.php\nfn count_divisors(n: isize) -> bool {\n", "task": "mbpp_781_count_divisors"}
{"content": "/// Write a function to find the product of first even and odd number of a given vector.\nfn mul_even_odd(list1: Vec<isize>) -> isize {\n    match (list1.iter().filter(|&&x| x % 2 == 0).next(), list1.iter().filter(|&&x| x % 2 != 0).next()) {\n        (Some(x), Some(y)) => x * y,\n        _ => -1,\n    }\n}", "retrieval_text": "/// Write a function to find the product of first even and odd number of a given vector.\nfn mul_even_odd(list1: Vec<isize>) -> isize {\n", "task": "mbpp_784_mul_even_odd"}
{"content": "/// Write a function to locate the right insertion point for a specified value in sorted order.\nfn right_insertion(a: Vec<isize>, x: isize) -> isize {\n    let index = a.binary_search(&x).unwrap_or_else(|x| x);\n    index as isize\n}", "retrieval_text": "/// Write a function to locate the right insertion point for a specified value in sorted order.\nfn right_insertion(a: Vec<isize>, x: isize) -> isize {\n", "task": "mbpp_786_right_insertion"}
{"content": "/// Write a rsthon function to check whether every even index contains even numbers of a given vector.\nfn even_position(nums: Vec<isize>) -> bool {\n    // Loop through the vector and check if every even index contains even numbers.\n    for i in 0..nums.len() {\n        if i % 2 == 0 && nums[i] % 2 != 0 {\n            return false;\n        }\n    }\n\n    true\n}", "retrieval_text": "/// Write a rsthon function to check whether every even index contains even numbers of a given vector.\nfn even_position(nums: Vec<isize>) -> bool {\n", "task": "mbpp_790_even_position"}
{"content": "/// Write a rsthon function to count the number of vectors in a given number of vectors.\nfn count_list(input_list: Vec<Vec<isize>>) -> isize {\n    input_list.len() as isize\n}", "retrieval_text": "/// Write a rsthon function to count the number of vectors in a given number of vectors.\nfn count_list(input_list: Vec<Vec<isize>>) -> isize {\n", "task": "mbpp_792_count_list"}
{"content": "use std::collections::HashMap;\n\n/// Write function to find the sum of all items in the given HashMap.\nfn return_sum(dict: HashMap<String, isize>) -> isize {\n    let mut sum = 0;\n    for v in dict.values() {\n        sum += v;\n    }\n    sum\n}", "retrieval_text": "use std::collections::HashMap;\n\n/// Write function to find the sum of all items in the given HashMap.\nfn return_sum(dict: HashMap<String, isize>) -> isize {\n", "task": "mbpp_796_return_sum"}
{"content": "/// Write a rsthon function to find the sum of a vector.\nfn _sum(arr: Vec<isize>) -> isize {\n    let mut sum = 0;\n    for i in arr {\n        sum += i;\n    }\n    sum\n}", "retrieval_text": "/// Write a rsthon function to find the sum of a vector.\nfn _sum(arr: Vec<isize>) -> isize {\n", "task": "mbpp_798__sum"}
{"content": "/// Write a function to that rotate left bits by d bits a given number. We assume that the number is 32 bit.\nfn left_rotate(n: isize, d: isize) -> isize {\n    // let bits = 32 as isize;\n    (n << d) | (n >> (32 - d))\n}", "retrieval_text": "/// Write a function to that rotate left bits by d bits a given number. We assume that the number is 32 bit.\nfn left_rotate(n: isize, d: isize) -> isize {\n", "task": "mbpp_799_left_rotate"}
{"content": "/// Write a function to remove all whitespaces from a string.\nfn remove_all_spaces(text: String) -> String {\n    text.replace(\" \", \"\")\n}", "retrieval_text": "/// Write a function to remove all whitespaces from a string.\nfn remove_all_spaces(text: String) -> String {\n", "task": "mbpp_800_remove_all_spaces"}
{"content": "/// Write a rsthon function to count the number of equal numbers from three given integers.\nfn test_three_equal(x: isize, y: isize, z: isize) -> isize {\n    match [x, y, z].iter().collect::<std::collections::HashSet<_>>().len() {\n        3 => 0,\n        2 => 4 - 2,\n        1 => 4 - 1,\n        _ => panic!(\"unexpected number of numbers\")\n    }\n}", "retrieval_text": "/// Write a rsthon function to count the number of equal numbers from three given integers.\nfn test_three_equal(x: isize, y: isize, z: isize) -> isize {\n", "task": "mbpp_801_test_three_equal"}
{"content": "/// Write a rsthon function to count the number of rotations required to generate a sorted vector. https://www.geeksforgeeks.org/count-of-rotations-required-to-generate-a-sorted-vector/\nfn count_rotation(arr: Vec<isize>) -> isize {\n    // loop over the vector\n    for i in 1..arr.len() {\n        // if arr[i] < arr[i - 1] then return i\n        if arr[i] < arr[i - 1] {\n            return i as isize;\n        }\n    }\n    // if no rotations then return 0\n    return 0;\n}", "retrieval_text": "/// Write a rsthon function to count the number of rotations required to generate a sorted vector. https://www.geeksforgeeks.org/count-of-rotations-required-to-generate-a-sorted-vector/\nfn count_rotation(arr: Vec<isize>) -> isize {\n", "task": "mbpp_802_count_rotation"}
{"content": "/// Write a function to check whether the given number is a perfect square or not. https://www.geeksforgeeks.org/check-if-given-number-is-perfect-square-in-cpp/\nfn is_perfect_square(n: isize) -> bool {\n    let mut i = 1;\n    while i * i <= n {\n        if n % i == 0 && n / i == i {\n            return true;\n        }\n        i += 1;\n    }\n    false\n}", "retrieval_text": "/// Write a function to check whether the given number is a perfect square or not. https://www.geeksforgeeks.org/check-if-given-number-is-perfect-square-in-cpp/\nfn is_perfect_square(n: isize) -> bool {\n", "task": "mbpp_803_is_perfect_square"}
{"content": "/// Write a function to check whether the product of numbers in a vector is even or not.\nfn is_product_even(arr: Vec<isize>) -> bool {\n    for i in arr {\n        if i % 2 == 0 {\n            return true;\n        }\n    }\n    false\n}", "retrieval_text": "/// Write a function to check whether the product of numbers in a vector is even or not.\nfn is_product_even(arr: Vec<isize>) -> bool {\n", "task": "mbpp_804_is_product_even"}
{"content": "/// Write a function that returns the vector in a vector of vectors whose sum of elements is the highest.\nfn max_sum_list(lists: Vec<Vec<isize>>) -> Vec<isize> {\n    let mut max_sum_vec = vec![];\n    let mut max_sum = 0;\n\n    for v in lists.iter() {\n        let sum: isize = v.iter().sum();\n        if sum > max_sum {\n            max_sum = sum;\n            max_sum_vec = v.clone();\n        }\n    }\n\n    max_sum_vec\n}", "retrieval_text": "/// Write a function that returns the vector in a vector of vectors whose sum of elements is the highest.\nfn max_sum_list(lists: Vec<Vec<isize>>) -> Vec<isize> {\n", "task": "mbpp_805_max_sum_list"}
{"content": "/// Write a function to find maximum run of uppercase characters in the given string.\nfn max_run_uppercase(test_str: String) -> isize {\n    let mut cnt = 0;\n    let mut res = 0;\n    for c in test_str.chars() {\n        if c.is_uppercase() {\n            cnt += 1;\n        } else {\n            res = cnt;\n            cnt = 0;\n        }\n    }\n    if test_str.chars().last().unwrap().is_uppercase() {\n        res = cnt;\n    }\n    res as isize\n}", "retrieval_text": "/// Write a function to find maximum run of uppercase characters in the given string.\nfn max_run_uppercase(test_str: String) -> isize {\n", "task": "mbpp_806_max_run_uppercase"}
{"content": "/// Write a rsthon function to find the first odd number in a given vector of numbers.\nfn first_odd(nums: Vec<isize>) -> isize {\n    match nums.iter().find(|&&el| el % 2 != 0) {\n        Some(x) => *x,\n        None => -1,\n    }\n}", "retrieval_text": "/// Write a rsthon function to find the first odd number in a given vector of numbers.\nfn first_odd(nums: Vec<isize>) -> isize {\n", "task": "mbpp_807_first_odd"}
{"content": "/// Write a function to check if the given tuples contain the k or not.\nfn check_K(test_tup: Vec<isize>, K: isize) -> bool {\n    test_tup.contains(&K)\n}", "retrieval_text": "/// Write a function to check if the given tuples contain the k or not.\nfn check_K(test_tup: Vec<isize>, K: isize) -> bool {\n", "task": "mbpp_808_check_K"}
{"content": "/// Write a function to check if each element of second tuple is smaller than its corresponding element in the first tuple.\nfn check_smaller(test_tup1: (isize, isize, isize), test_tup2: (isize, isize, isize)) -> bool {\n  test_tup1.0 > test_tup2.0 && test_tup1.1 > test_tup2.1 && test_tup1.2 > test_tup2.2\n}", "retrieval_text": "/// Write a function to check if each element of second tuple is smaller than its corresponding element in the first tuple.\nfn check_smaller(test_tup1: (isize, isize, isize), test_tup2: (isize, isize, isize)) -> bool {\n", "task": "mbpp_809_check_smaller"}