Median and mode

Vectors

Vectors in Rust are a collection type that can store multiple values of the same type. They are similar to arrays in JavaScript and lists in Python but with some additional features, they are stored on the heap and they can grow or shrink in size.

In this challenge you're asked to implement two functions that calculate the median and mode of a list of integers.

Read the definitions of each Median and Mode below to understand what you need to implement.

Median

The median is the middle value of a list when it is ordered by size. If the list has an even number of elements, the median is the average of the two middle numbers.

Here's an example:

let mut numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
let median = median(&mut numbers);
assert_eq!(median, 5.0);

Or if the number of elements is even:

let mut numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let median = median(&mut numbers);
assert_eq!(median, 5.5);

You can implement the function in the following steps:

Sort the list of numbers.
If the number of elements is odd, return the middle element.
If the number of elements is even, return the average of the two middle elements.

Mode

The mode is the number that appears most frequently in a list, if there are multiple numbers that appear the same number of times, return all of them in a vector.

Here's an example:

let numbers = vec![1, 1, 1, 1, 2]
let mode = mode(&numbers);
assert_eq!(mode, vec![1]);

The number 1 appears four times, which is more than any other number in the list.

Important: You must sort the list of numbers before returning the modes list.

Hints

You can use the sort method to sort a vector.
You can use the entry method to insert a value into a hash map if it doesn't exist or update it if it does.
When looping through a vector, you can dereference the value using & to get the value instead of a reference to it. For example:

let numbers = vec![1, 2, 3, 4, 5];
for &number in &numbers {
    println!("{}", number);
}

Store the maximum frequency and the number that appears most frequently in a HashMap<i32, i32> and update it as you iterate through the list of numbers, and finally return the list of numbers that appears most frequently.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

GunGraveCpp

5 days ago

3.51ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    // let mid = (numbers.len() - 1).midpoint(0);
    let mid = (numbers.len() - 1) / 2;
    if numbers.len() % 2 != 0 {
        return numbers[mid] as f32;
    } else {
        // return (numbers[mid] as f32).midpoint(numbers[mid + 1] as f32);
        return ((numbers[mid] as f32) + (numbers[mid + 1] as f32)) / 2.0;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counter_col: HashMap<i32, i32> = HashMap::new();
    for val in numbers {
        counter_col.entry(*val).and_modify(|v| *v += 1).or_default();
    }
    let (_, &max) = counter_col.iter().max_by_key(|x| *x.1).unwrap();
    counter_col
        .iter()
        .filter(|x| *x.1 == max)
        .map(|x| x.0)
        .copied()
        .collect()
}

amdfxlucas

6 days ago

2.81ms

87.05kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let half = numbers.len() / 2;
    if numbers.len()%2==0
    {   
        return ( numbers.get(half).copied().unwrap() as f32
        + numbers.get(half-1).copied().unwrap() as f32 )/2.0;
    }else
    {
        return numbers.get(half).copied().unwrap() as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut highest_freq: u32 = 0;
    // maps elements to their frequency
    let mut freq: HashMap<i32, u32> = HashMap::new();
    // maps frequencies to elements having at least this freq
    let mut trans_modes: HashMap<u32, Vec<i32>> = HashMap::new();
    for i in numbers {
        let new_freq = *freq.entry(*i).and_modify(|counter| *counter += 1).or_insert(1);
        if new_freq >= highest_freq
        {
            highest_freq = new_freq;
            trans_modes.entry(highest_freq).and_modify(|v| v.push(*i)).or_insert(vec![*i]);
        }
    }
    return trans_modes.get(&highest_freq).cloned().unwrap();
}

manu3618

10 days ago

2.95ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    if numbers.len() % 2 == 1 {
        numbers[(numbers.len() as f32 / 2. - 0.5) as usize] as f32
    } else {
        ((numbers[numbers.len() / 2] + numbers[numbers.len() / 2 - 1]) as f32) / 2.
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counts: HashMap<i32, i32> = HashMap::new();
    // numbers.sort();
    for &n in numbers {
        *counts.entry(n).or_default() += 1;
    }
    let mode = counts.values().max().unwrap();
    let mut modes = counts.iter().filter_map(|(&k, &v)| { if v == *mode { Some(k) } else {None}}).collect::<Vec<i32>>();
    modes.sort();
    modes
}

aghia98

10 days ago

3.97ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let len= numbers.len();
    if len%2==1 {
        numbers[len/2] as f32
    }else {
        (numbers[len/2]+numbers[len/2-1]) as f32 / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut map: HashMap<i32,i32> = HashMap::new();
    for val in numbers{
        let freq = map.entry(*val).or_insert(0);
        *freq+=1;
    }
    let mut vec = map.into_iter().collect::<Vec<_>>();
    vec.sort_by_key(|&(_, v)| -v);
    //println!("vec: {:?}", vec);
    
    let highest_freq = vec[0].1;
    let mut i=0;
    let mut to_return: Vec<i32> = vec![];
    while i<vec.len() && vec[i].1 == highest_freq {
        to_return.push(vec[i].0);
        i+=1;
    }
    to_return.sort();
    //println!("toret: {:?}", to_return);
    to_return
}

Heino Mortensen

hmortensen83

12 days ago

2.77ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let mid = numbers.len() / 2;
    if numbers.len() % 2 == 0 {
        (numbers[mid] as f32 + numbers[mid - 1] as f32) / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut freq_map = HashMap::new();
    for &n in numbers {
        *freq_map.entry(n).or_insert(0) += 1;
    }
    let max_frequency = freq_map.values().cloned().max().unwrap_or(0);
    let mut modes: Vec<i32> = freq_map
        .into_iter()
        .filter(|&(_, count)| count == max_frequency)
        .map(|(num, _)| num)
        .collect();
    modes.sort();
    modes
}

bzdula

17 days ago

2.69ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let even_amount = numbers.len() % 2 == 0;
    numbers.sort();
    if !even_amount {
        numbers[numbers.len() / 2] as f32
    } else {
        let (lhs, rhs) = (numbers[numbers.len() / 2 - 1] as f32, numbers[numbers.len() / 2] as f32);
        (lhs + rhs) / 2.
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut modes = HashMap::new();
    for number in numbers {
        *modes.entry(number).or_insert(0) += 1;
    }
    let max_number = *modes.values().max().unwrap_or(&0);
    let mut max_frequent = modes.into_iter().filter_map(|(num, amount)| (amount == max_number).then_some(*num)).collect::<Vec<_>>();
    max_frequent.sort();
    max_frequent
}

Christophe Pronier

chrpron

19 days ago

2.62ms

86.93kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let l = numbers.len();
    if l%2 ==0 {
        return (numbers[l/2-1] + numbers[l/2]) as f32 / 2.0
    } else {
        return numbers[(l/2)-0.5 as usize] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut c: HashMap<i32, u32> = HashMap::new();
    for i in 0..numbers.len() {
        c.entry(numbers[i]).and_modify(|counter| *counter += 1).or_insert(1);
    }
    println!("{:?}", c);
    let mut t: Vec<i32> = vec!();
    let mut max: u32 = 0; 
    for (k, v) in c {
        if v == max {
            t.push(k);
        }
        if v > max {
            max = v;
            t = vec!(k)
        }
    }
    t.sort();
    return t
}

Ranjith Thangavel

RanjithECE24

24 days ago

3.08ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let size = numbers.len();
    if size % 2 != 0 {
        numbers[(size/2) as usize] as f32
    } else {
        let index = (size/2) as usize;
        (numbers[index -1] + numbers[index]) as f32 / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {    let mut freq_map: HashMap<i32, usize> = HashMap::new();
    for &num in numbers {
        *freq_map.entry(num).or_insert(0) += 1;
    }
    let max_freq = freq_map.values().copied().max().unwrap_or(0);
    let mut modes: Vec<i32> = freq_map
        .into_iter()
        .filter(|&(_, count)| count == max_freq)
        .map(|(num, _)| num)
        .collect();
    modes.sort();
    modes
}

Wouter

WouterMartens

24 days ago

3.66ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let len = numbers.len();
    let mid = len / 2;
    
    if len % 2 == 0 {
        (numbers[mid - 1] + numbers[mid]) as f32 / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut counter = HashMap::new();
    for &number in numbers {
        counter.entry(number).and_modify(|c| *c += 1).or_insert(1);
    }
    let max_value = counter.values().max().unwrap();
    let mut result = counter
        .iter()
        .filter(|(_, v)| *v == max_value)
        .map(|(k, _)| k.clone())
        .collect::<Vec<i32>>();
    result.sort();
    result
}

whhc

a month ago

2.72ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let len = numbers.len();
    if len % 2 == 1 {
        numbers[(len - 1) / 2] as f32
    } else {
        ((numbers[len / 2] + numbers[len / 2 + 1]) as f32) / 2f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut hash_map = HashMap::new();
    numbers.iter().for_each(|num| {
        hash_map
            .entry(num)
            .and_modify(|counter| *counter += 1)
            .or_insert(1);
    });
    let max = hash_map.values().map(|i| *i).max().unwrap_or(0);
    let mut vec = hash_map
        .into_iter()
        .filter(|(_, y)| y == &max)
        .map(|(x, _)| *x)
        .collect::<Vec<i32>>();
    vec.sort();
    vec
}

Andy Randrianirina

andyslash

a month ago

2.76ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let len = numbers.len();
    if len == 0 {
        return 0.0;
    }
    if len % 2 == 1 {
        // Impair : retourne l'élément du milieu
        numbers[len / 2] as f32
    } else {
        (numbers[len / 2 - 1] + numbers[len / 2]) as f32 / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let counter = numbers
        .iter()
        .fold(HashMap::new(), |mut acc, n| {
            *acc.entry(*n).or_insert(0) += 1;
            acc
        });
    let Some(max_count) = counter.values().max() else {
        return Vec::new();
    };
    
    let mut modes = Vec::new();
    for (key, value) in counter.iter() {
        if value == max_count {
            modes.push(*key);
        }
    }
    modes.sort();
    modes
}

medzernik

a month ago

3.36ms

86.95kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    match numbers.len() % 2 {
        0 => {
            let index_1 = ((numbers.len() as f32/2.)) as usize;
            let index_2 = ((numbers.len() as f32/2.) - 1.) as usize;
            println!("{index_1} {index_2}");
            (numbers[index_1] as f32 + numbers[index_2] as f32) / 2.
        }
        _ => numbers[numbers.len()/2] as f32,
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut counts: HashMap<i32, i32> = HashMap::new();
    
    numbers.iter().for_each(|x| {counts.entry(*x).and_modify(|y| *y += 1).or_insert(1);});
    
    println!("{counts:#?}");
    let mut max = 0;
    let mut sorted = counts.into_iter().filter_map(|(x, y)| {
        if y >= max {
            max = y;
            Some((x,y))
        } else {
            None
        }
    }).collect::<Vec<(i32,i32)>>();
    sorted.retain(|(x, y)| *y >= max);
    let mut result = sorted.iter().map(|x| x.0).collect::<Vec<i32>>();
    result.sort();
    println!("{result:#?}");
    result
}

Baron Curtin

baroncurtin2

a month ago

3.29ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let len = numbers.len();
    let mid = len / 2;
    if len % 2 == 1 {
        // odd length - find middle element
        numbers.select_nth_unstable(mid);
        numbers[mid] as f32
    } else {
        numbers.select_nth_unstable(mid - 1);
        let lower = numbers[mid - 1] as f32;
        let upper = numbers[mid..].iter().min().unwrap();
        (lower + *upper as f32) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    if numbers.is_empty() {
        return Vec::new();
    }
    let mut counter = HashMap::new();
    let mut max_count = 0;
    for &num in numbers {
        let count = counter.entry(num).and_modify(|e| *e += 1).or_insert(1);
        if *count > max_count {
            max_count = *count;
        }
    }
    let mut modes: Vec<i32> = counter
        .into_iter()
        .filter_map(|(num, count)| {
            if count == max_count {
                Some(num)
            } else {
                None
            }
        })
        .collect();
        modes.sort_unstable();
        modes
}

Evrins Hu

evrins

a month ago

3.69ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let n = numbers.len();
    if n % 2 == 0 {
        (numbers[n / 2 - 1] + numbers[n / 2]) as f32 / 2.0
    } else {
        numbers[n / 2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut freq: HashMap<i32, i32> = HashMap::new();
    for &num in numbers.iter() {
        *freq.entry(num).or_insert(0) += 1;
    }
    let max_ = freq.values().max().unwrap();
    let mut ans = Vec::new();
    for (k, v) in freq.iter() {
        if v == max_ {
            ans.push(*k);
        }
    }
    ans.sort();
    ans
}

johndoe30bc

a month ago

2.80ms

87.00kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    if numbers.is_empty() {
        return 0.0;
    }
    numbers.sort();
    let mid_idx = numbers.len() / 2;
    if numbers.len() % 2 == 0 {
        (numbers[mid_idx - 1] + numbers[mid_idx]) as f32 / 2.0
    } else {
        numbers[mid_idx] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    if numbers.is_empty() {
        return vec![];
    }
    if numbers.len() == 1 {
        return vec![numbers[0]];
    }
    let mut map = HashMap::<i32, usize>::new();
    for n in numbers {
        *map.entry(*n).or_default() += 1;
    }
    let mut pairs = Vec::from_iter(map.iter());
    pairs.sort_by(|a, b| b.1.cmp(a.1));
    let max = pairs[0].1;
    let mut result: Vec<i32> = pairs
        .iter()
        .take_while(|x| x.1 == max)
        .map(|x| *x.0)
        .collect();
    result.sort();
    result
}
/* LINE */

orao-pao

a month ago

3.46ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    if (numbers.len() % 2) == 0 {
        return (numbers[(numbers.len() / 2) - 1] + numbers[numbers.len() / 2]) as f32 / 2.0;
        
    } else {
        return numbers[numbers.len() / 2] as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut mode_info: HashMap<i32, i32> = HashMap::new();
    for i in numbers {
        mode_info
            .entry(*i)
            .and_modify(|counter| *counter += 1)
            .or_insert(1);
    }
    let mut return_value = mode_info
        .iter()
        .filter_map(|(key, &val)| {
            if val == *mode_info.values().max().unwrap() {
                Some(*key)
            } else {
                None
            }
        })
        .collect::<Vec<i32>>();
    return_value.sort();
    return_value
}

xxxxsk

a month ago

2.69ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let mid = numbers.len() / 2 as usize;
    if numbers.len() % 2 == 0 {
        (numbers[mid] as f32 + numbers[mid - 1] as f32) / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let counter = numbers
        .iter()
        .fold(HashMap::new(), |mut acc, n| {
            *acc.entry(*n).or_insert(0) += 1;
            acc
        });
    let Some(max_count) = counter.values().max() else {
        return Vec::new();
    };
    
    let mut modes = Vec::new();
    for (key, value) in counter.iter() {
        if value == max_count {
            modes.push(*key);
        }
    }
    modes.sort();
    modes
}

Evgenii Grigorenko

grevgeny

a month ago

3.02ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let mid = numbers.len() / 2 as usize;
    if numbers.len() % 2 == 0 {
        (numbers[mid] as f32 + numbers[mid - 1] as f32) / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let counter = numbers
        .iter()
        .fold(HashMap::new(), |mut acc, n| {
            *acc.entry(*n).or_insert(0) += 1;
            acc
        });
    let Some(max_count) = counter.values().max() else {
        return Vec::new();
    };
    
    let mut modes = Vec::new();
    for (key, value) in counter.iter() {
        if value == max_count {
            modes.push(*key);
        }
    }
    modes.sort();
    modes
}

brucecox01

a month ago

5.13ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let l = numbers.len();
    if l % 2 == 1 {
        numbers[l/2] as f32
    } else {
        (numbers[l/2-1] + numbers[l/2]) as f32/2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counter = HashMap::new();
    for x in numbers {
        counter.entry(*x).and_modify(|y| *y += 1).or_insert(1);
    }
    let mut max = 0;
    let mut mode = vec![];
    for (key, val) in counter.iter() {
        if *val > max {
            mode = vec![*key];
            max = *val;
        } else if *val == max {
            mode.push(*key);
        }
    }
    mode.sort();
    mode
}

Elliott Draper

ejdraper

a month ago

3.29ms

87.00kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    println!("median: {:?}", numbers);
    numbers.sort();
    if numbers.len() % 2 == 0 {
        let i = numbers.len() / 2;
        let n1 = numbers.get(i-1).unwrap();
        let n2 = numbers.get(i).unwrap();
        return (n1 + n2) as f32 / 2.0;
    } else {
        return *numbers.get(numbers.len() / 2).unwrap() as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    println!("mode: {:?}", numbers);
    let mut counts: HashMap<i32, i32> = HashMap::new();
    for number in numbers.iter() {
        counts.entry(*number).and_modify(|i| *i += 1).or_insert(1);
    }
    let mut modes: Vec<i32> = vec![];
    let mut most = 0;
    for number in numbers.iter() {
        let count = counts.get(number).unwrap();
        if *count >= most {
            most = *count;
        }
    }
    for number in numbers.iter() {
        let count = counts.get(number).unwrap();
        if *count == most && !modes.contains(number) {
            modes.push(*number);
        }
    }
    return modes;
}

Krzysztof Atłasik

katlasik

2 months ago

3.50ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let middle = numbers.len()/2;
    if numbers.len() % 2 == 0 {
        (numbers[middle-1] as f32 + numbers[middle] as f32)/2_f32
    } else {
        numbers[middle] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut entries = HashMap::new();
    for number in numbers {
        *entries.entry(number).or_insert(0) += 1;
    }
    let max_value = *entries.values().max().unwrap();
    let mut result = vec![];
    for (entry, value) in entries.into_iter() {
        if value == max_value {
            result.push(entry.clone())
        }
    }
    result.sort();
    result
}

Alexander Y

unixander

2 months ago

2.73ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    match numbers.len() % 2 {
        0 => {
            if numbers.len() == 0 {
                0.0
            } else {
                let left = numbers[numbers.len() / 2 - 1];
                let right = numbers[numbers.len() / 2];
                ((left + right) as f32) / 2.0
            }
        },
        _ => numbers[numbers.len() / 2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map: HashMap<i32, i32> = HashMap::new();
    numbers.iter().for_each(|x| {
        *map.entry(*x).or_insert(0) += 1;
    });
    let max = map.values().cloned().max().unwrap_or(0);
    map.into_iter().filter_map(|(k, v)| {
        if v == max {Some(k)} else {None}
    }).collect::<Vec<i32>>()
}

Philippe Massicotte

PMassicotte

2 months ago

3.69ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort_unstable();
    let len = numbers.len();
    if len == 0 {
        return 0.0;
    }
    if len % 2 == 1 {
        numbers[len / 2] as f32
    } else {
        (numbers[len / 2 - 1] as f32 + numbers[len / 2] as f32) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut hm: HashMap<i32, u32> = HashMap::new();
    for &n in numbers {
        *hm.entry(n).or_insert(0) += 1;
    }
    let max_count = hm.values().cloned().max().unwrap_or(0);
    let mut modes: Vec<i32> = hm
        .into_iter()
        .filter(|&(_, count)| count == max_count)
        .map(|(num, _)| num)
        .collect();
    modes.sort_unstable();
    modes
}

Harsh Ranjan

harshRn

2 months ago

2.66ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let x = numbers.len();
    if x % 2 == 0 {
        return (numbers[x/2-1] + numbers[x/2]) as f32 * 0.5;
    }
    numbers[x/2] as f32
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut x = HashMap::new();
    numbers.iter().for_each(|n| { x.entry(*n).and_modify(|e| *e += 1 ).or_insert(1); });
    let mut k_res = vec![];
    let mut v_res = 0;
    x.keys().for_each(|k| {
        let val = x.get(k).unwrap();
        if *val > v_res {
            v_res = *val;
            k_res.clear();
            k_res.push(*k);
        } else if *val == v_res {
            k_res.push(*k);
        }
    });
    k_res.sort();
    k_res
}

Luigi Terrone

LuigiTer

2 months ago

3.43ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let med = numbers.len() / 2;
    let medeven = numbers.len() % 2 == 0;
    if medeven {
        ((numbers[med - 1] as f32 + numbers[med] as f32) / 2.00) as f32
    } else {
        numbers[med] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut res: HashMap<i32, i32> = HashMap::new();
    for &num in numbers {
        *res.entry(num).or_insert(0) += 1;
    }
    let max_count = res.values().cloned().max().unwrap_or(0);
    res.into_iter()
        .filter_map(|(num, count)| if count == max_count { Some(num) } else { None })
        .collect()
}

Enes

enesscevik

2 months ago

3.15ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let med = numbers.len() / 2;
    let medeven = numbers.len() % 2 == 0;
    if medeven {
        ((numbers[med - 1] as f32 + numbers[med] as f32) / 2.00) as f32
    } else {
        numbers[med] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counter = HashMap::new();
    for n in numbers { counter.entry(n).and_modify(|e| *e += 1).or_insert(1); }
    let mut modes = vec![];
    let max = *counter.values().max().unwrap();
    for (n, count) in counter { if count == max { modes.push(*n); } }
    modes.sort();
    modes
}

ikatlinsky

2 months ago

3.19ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let mid = (numbers.len() / 2) as usize;
    if numbers.len() % 2 == 0 {
        ((numbers[mid - 1] + numbers[mid]) as f32) / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut counter = HashMap::new();
    for n in numbers {
        counter.entry(n).and_modify(|e| *e += 1).or_insert(1);
    }
    let mut modes = vec![];
    let max = *counter.values().max().unwrap();
    for (n, count) in counter {
        if count == max {
            modes.push(*n);
        }
    }
    return modes;
}

Anthony

Ashaman00

2 months ago

2.71ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let len = numbers.len();
    if len  % 2 == 1 {
        numbers[len / 2] as f32
    } else {
        ((numbers[len / 2 - 1] + numbers[len / 2]) as f32) / 2.
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map = HashMap::new();
    for n in numbers {
        map.entry(n).and_modify(|counter| *counter += 1).or_insert(1);
    }
    let max = *map.values().max().unwrap();
    let mut result: Vec<i32> = map.into_iter().filter(|(_, v)| *v == max).map(|(k, _)| *k).collect();
    result.sort();
    result
}

LeonardoPinheiro23

2 months ago

3.16ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let len = numbers.len();
    let mid = len / 2;
    if len % 2 == 1 {
        // Odd number of elements
        *numbers.select_nth_unstable(mid).1 as f32
    } else {
        // Even number: average of two middle elements
        let (_, mid_value, high) = numbers.select_nth_unstable(mid - 1);
        let a = *mid_value;
        let b = *high.select_nth_unstable(0).1;
        (a + b) as f32 / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut freq_map: HashMap<i32, usize> = HashMap::new();
    // Count frequencies
    for &num in numbers {
        *freq_map.entry(num).or_insert(0) += 1;
    }
    // Find max frequency
    let max_freq = *freq_map.values().max().unwrap_or(&0);
    // Collect all numbers with max frequency
    let mut modes: Vec<_> = freq_map.into_iter()
        .filter(|&(_, count)| count == max_freq)
        .map(|(num, _)| num)
        .collect();
    // Sort Modes
    modes.sort_unstable();
    modes
}

annececiledunand

2 months ago

2.74ms

86.91kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    
    let l: u32 = numbers.len() as u32;
    if l % 2 == 0 {
        return (numbers[(l/2) as usize] + numbers[(l/2) as usize - 1]) as f32 / 2.0;
    }
    else {
        return numbers[(l/2) as usize] as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counter: HashMap<i32, u32> = HashMap::new();
    for n in numbers {
        counter.entry(*n).and_modify(|e| { *e += 1 }).or_insert(1);
    }
    let mut output: Vec<i32> = Vec::new();
    let max_value = counter.clone().into_values().max().expect("Issue with max");
    for (key, value) in counter.iter() {
        if *value == max_value {
            output.push(*key);
        }
    }
    output.sort();
    output
}

ggnne

3 months ago

2.85ms

87.01kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let n = numbers.len();
    if n % 2 == 0 {
        ((numbers[n/2] + numbers[n/2 - 1]) as f32) * 0.5 
    } else {
        numbers[n / 2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut H: HashMap<i32, u32> = HashMap::new();
    for n in numbers {
        H.entry(*n).and_modify(|e| *e += 1).or_insert(1);
    }
    let mut O: HashMap<u32, Vec<i32>> = HashMap::new();
    let mut max = 0;
    for (k, v) in H.iter() {
        O.entry(*v).and_modify(|e| e.push(*k)).or_insert(vec![*k]);
        if max < *v {
            max = *v;
        }
    }
    let mut out = O.remove(&max).unwrap();
    out.sort();
    out
}

Tommytto

3 months ago

3.65ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    // TODO: Implement logic here to return the median of the list
    if numbers.len() % 2 == 0 {
        let right = numbers.len() / 2;
        let left = right - 1;
        (numbers[left] as f32 + numbers[right] as f32) / 2.
    } else {
        let middle = numbers.len() / 2;
        numbers[middle] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut dict = HashMap::new();
    for &num in numbers {
        *dict.entry(num).or_insert(0) += 1;
    }
    let max = dict.values().copied().max().unwrap_or(0);
    // Collect all numbers with max frequency
    let mut result: Vec<i32> = dict
        .iter()
        .filter_map(|(&k, &v)| if v == max { Some(k) } else { None })
        .collect();
    result.sort();
    result
}

Viktor Merkurev

fennr

3 months ago

3.11ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    match numbers.len() % 2 == 0 {
        true => (numbers[numbers.len() / 2] + numbers[numbers.len() / 2 - 1]) as f32 / 2.0,
        false => numbers[numbers.len() / 2] as f32,
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut mode: HashMap<i32, i32> = HashMap::new();
    for &num in numbers {
        *mode.entry(num).or_insert(0) += 1;
    }
    let max_count = mode.values().cloned().max().unwrap_or(0);
    let mut v: Vec<_> = mode
        .into_iter()
        .filter(|&(_, count)| count == max_count)
        .map(|(num, _)| num)
        .collect();
    v.sort();
    v
}

arilet

3 months ago

3.05ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    if numbers.len() % 2 == 0 {
        return (numbers.iter().skip(numbers.len() / 2).take(2).sum::<i32>() as f32) / 2.0;
    }
    *numbers.iter().nth(numbers.len() / 2).unwrap() as f32
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut frequency = HashMap::<i32, i32>::new();
    numbers.iter().for_each(|n| { frequency.entry(*n).and_modify(|count| *count += 1).or_insert(1); } );
    let max_freq = frequency.values().max().unwrap();
    let mut v = frequency.iter().filter(|(_, v)| *v == max_freq).map(|(a, _)| *a).collect::<Vec<i32>>();
    v.sort();
    v
}

Liyqq

4 months ago

3.64ms

87.41kb

pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort_unstable();
    let mid = numbers.len() / 2;
    if numbers.len() % 2 == 0 {
        (numbers[mid-1] + numbers[mid]) as f32 / 2.0
    } else {
        numbers[mid] as f32
    }
}
use std::collections::HashMap;
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counter = HashMap::with_capacity(numbers.len() * 2);
    numbers.iter()
        .for_each(|&num| {
            counter.entry(num).and_modify(|e| *e += 1).or_insert(1);
        });
    let &count = counter.values().max().unwrap();
    counter.iter().filter_map(|(&k, &v)| (v == count).then_some(k)).collect()
}

wertion555

4 months ago

3.32ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let l = numbers.len();
    if l % 2 == 0{
        return (numbers[l / 2 - 1]+numbers[l / 2])as f32 / 2 as f32
    }
    numbers[l / 2] as f32
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut counter: HashMap<i32, i32> = HashMap::new();
    for &num in numbers {
        *counter.entry(num).or_insert(0) += 1;
    }
    let max = counter.values().max().unwrap();
    let mut res = counter.iter().filter(|&(_, v)| v == max).map(|(&k, _)| k).collect::<Vec<i32>>();
    res.sort();
    return res;
}

Hung Dinh

nhdinh

4 months ago

4.63ms

86.94kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let mid = numbers.len() / 2;
    if numbers.len() % 2 == 0 {
        (numbers[mid] + numbers[mid + 1]) as f32 / 2_f32
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut m: HashMap<i32, i32> = HashMap::new();
    let mut max = 0_i32;
    for n in numbers {
        m.entry(*n).and_modify(|x| *x += 1).or_insert(1);
        max = max.max(*m.get(n).unwrap());
    }
    let mut sorted = m.iter().collect::<Vec<_>>();
    sorted.sort_unstable_by(|a,b| b.1.cmp(&a.1));
    let mut ans = sorted.iter().filter(|x| *x.1 == max).map(|x| *x.0).collect::<Vec<_>>();
    ans.sort_unstable();
    ans
}

roboquaternion

4 months ago

2.85ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    if numbers.len() % 2 == 0 {
        // There is an even number of elements.
        let mid = numbers.len()/2;
        (numbers[mid-1] as f32 + numbers[mid] as f32)/2.
    } else {
        // There is an odd number of elements.
        let mid = (numbers.len() - 1)/2;
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    // Create a map, and fill it with the counts of the entries in numbers. Each element 
    // of numbers will be a key.
    let mut map = HashMap::new();
    for num in numbers {
        map.entry(*num).and_modify(|x| *x += 1).or_insert(1);
    }
    
    // Get the max.
    let max = map.values().max().unwrap();
    
    // Iterate over the map, find all entries that have max.
    let mut out_vec: Vec<i32> = Vec::new();
    for (key, value) in &map {
        if value == max {
            out_vec.push(*key);
        }
    }
    out_vec.sort();
    out_vec
}

Jakub Wiśniewski

wisniewskij

4 months ago

3.25ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    if numbers.len() % 2 == 1 {
        return numbers[numbers.len()/2] as f32;
    }
    return (numbers[numbers.len()/2] + numbers[numbers.len()/2 - 1]) as f32 / 2.0; 
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut num_cnt: HashMap<i32, i32> = HashMap::new(); 
    numbers.iter()
        .for_each(|x| *num_cnt.entry(*x).or_insert(0) += 1);
    let maxi = num_cnt.iter()
        .max_by(|a, b| a.1.cmp(b.1))
        .map(|x| *x.1)
        .unwrap();
        
    let mut ans: Vec<i32> = num_cnt.iter()
                            .filter(|x| *x.1 == maxi)
                            .map(|x| *x.0)
                            .collect::<Vec<i32>>();
    ans.sort();
    return ans;
}

Jason

Jason-fy-wang

4 months ago

3.12ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let length =  numbers.len();
    if length % 2 == 0 {
        let mid = length / 2;
        (numbers[mid-1] as f32 + numbers[mid] as f32) / 2.0
    }else {
        let mid = length / 2;
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counts = HashMap::<i32,i32>::new();
    for num in numbers {
        counts.entry(*num).and_modify(|v| *v += 1).or_insert(1);
    }
    let mut vec = Vec::<i32>::new();
    let max = counts.values().max().unwrap();
    for (k,v) in counts.iter() {
        if v == max {
            vec.push(*k);
        }
    }
    vec.sort();
    vec
}

Aurimas Kuniutis

auriku

5 months ago

2.77ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let len = numbers.len();
    if len % 2 != 0 {
        numbers[len / 2] as f32
    } else {
        (numbers[len / 2 - 1] as f32 + numbers[len / 2] as f32) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut counter: HashMap<i32, usize> = HashMap::new();
    numbers.iter().for_each(|number|{
        *counter.entry(*number).or_insert(1)+=1;
    });
    let max_frequency = counter.values().copied().max().unwrap_or(0);
    let mut modes: Vec<i32> = counter.iter()
        .filter_map(|(&number, &frequency)| {
            if frequency == max_frequency {
                Some(number)
            } else {
                None
            }
        })
        .collect();
        modes.sort();
        modes
}

Marcel Schiffel

mschiffel

5 months ago

3.83ms

87.37kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let len = numbers.len();
    if numbers.len() % 2 == 0 {
        let sum = numbers.get(len / 2).unwrap().to_owned()
            + numbers.get(len / 2 + 1).unwrap().to_owned();
        sum as f32 / 2.
    } else {
        numbers.get(len / 2).unwrap().to_owned() as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut counter: HashMap<i32, i32> = HashMap::<i32, i32>::new();
    numbers.iter().for_each(|&num| {
        let entry = counter.entry(num).or_insert(0);
        *entry += 1
    });
    let counts: Vec<i32> = counter.iter().map(|(_, &b)| b).collect();
    let max = counts.iter().max().unwrap();
    counter
        .iter()
        .filter_map(|(&a, b)| if b == max { Some(a) } else { None })
        .collect()
}

Dhananjay Pandit

djpandit007

5 months ago

3.57ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let length = numbers.len();
    numbers.sort();
    if length % 2 == 1 {
        return numbers[length / 2] as f32;
    }
    return (numbers[length/2] + numbers[(length/2) - 1]) as f32 / 2.0
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut mode: Vec<i32> = Vec::new();
    let mut frequency = HashMap::new();
    for num in numbers {
        frequency.entry(num).and_modify(|counter| *counter += 1).or_insert(1);
    }
    let max_value = frequency.values().max().unwrap();
    for (key, val) in frequency.iter() {
        if val == max_value {
            mode.push(**key);
        }
    }
    mode.sort();
    mode
}

syberianbull

5 months ago

3.69ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let n = numbers.len();
    if n % 2 ==0 {
        (numbers[n/ 2] + numbers[n/ 2 - 1]) as f32 / 2.
    } else {
        numbers[n/ 2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut nums: HashMap<i32, i32> = HashMap::new();
    for i in numbers {
        nums.entry(*i).and_modify(|i| *i += 1).or_insert(1);
    }
    let mut occurences = 0;
    let mut mode = Vec::new();
    for (num, occ) in nums.iter() {
        if *occ == occurences {
            mode.push(*num);
        } else if *occ >= occurences {
            mode.clear();
            mode.push(*num);
            occurences = *occ;
        }
    }
    mode.sort();
    mode
}

Robbie K

va1ha11a

5 months ago

2.88ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    let len = numbers.len();
    match len % 2 {
        0 => (numbers[len / 2] as f32 + numbers[len / 2 + 1] as f32) / 2.0,
        _ => numbers[len / 2] as f32,
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut number_counts: HashMap<i32, i32> = HashMap::new();
    for &n in numbers {
        *number_counts.entry(n).or_insert(0) += 1;
    }
    if let Some(&max_count) = number_counts.values().max() {
        let mut result: Vec<i32> = number_counts
            .iter()
            .filter(|&(_, &count)| count == max_count)
            .map(|(&key, _)| key)
            .collect::<Vec<i32>>();
        // Sort the keys in ascending order
        result.sort();
        result
    } else {
        vec![]
    }
}

VerweyFr

5 months ago

2.94ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
   let c = numbers.len();
   numbers.sort();
   match c {
    0 => 0.0,
    x if x % 2 == 0 => {
        let mid = c / 2;
        let mid2 = mid - 1;
        (numbers[mid] + numbers[mid2]) as f32 / 2.0
    },
    _ => {
        let mid = c / 2;
        numbers[mid] as f32
    }
   }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map: HashMap< i32, i32> = HashMap::new();
    let mut max: i32 = 0;
    for n in numbers {
        *map.entry(*n).or_insert(0) += 1 ;
        if max < map[n] {
            max = map[n];
        }
    }
    let mut result: Vec<i32> = Vec::new();
    for m in map {
        if m.1 == max{
            result.push(m.0);
        }           
    }
    result
}

Yixian Du

duyixian1234

5 months ago

7.23ms

86.91kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let l = numbers.len();
    if l % 2 == 0 {
        let v1 =  numbers.get(l/2).unwrap();
        let v2 =  numbers.get(l/2-1).unwrap();
        (*v1 + *v2) as f32 / 2.
    } else {
        let v1 = numbers.get(l/2).unwrap();
        *v1 as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut res = vec![];
    let mut h: HashMap<i32, i32> = HashMap::new();
    numbers.iter().for_each(|&x| {
        h.entry(x).and_modify(|val| *val += 1).or_insert(1);
    });
    let c = h.clone();
    let max_value = c.into_values().max().unwrap();
    h.into_iter().for_each(|(k, v)| if v == max_value {res.push(k)});
    res.sort();
    res
}

Artem

tich31337

5 months ago

3.10ms

86.91kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let l = numbers.len();
    if l % 2 == 0 {
        let v1 =  numbers.get(l/2).unwrap();
        let v2 =  numbers.get(l/2-1).unwrap();
        (*v1 + *v2) as f32 / 2.
    } else {
        let v1 = numbers.get(l/2).unwrap();
        *v1 as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut res = vec![];
    let mut h: HashMap<i32, i32> = HashMap::new();
    numbers.iter().for_each(|&x| {
        h.entry(x).and_modify(|val| *val += 1).or_insert(1);
    });
    let c = h.clone();
    let max_value = c.into_values().max().unwrap();
    h.into_iter().for_each(|(k, v)| if v == max_value {res.push(k)});
    res.sort();
    res
}

gsspdev

5 months ago

3.02ms

86.91kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    let length = numbers.len();
    let mid = length / 2;
    numbers.sort();
    let med: f32;
    if length % 2 == 0 {
        med = (numbers[mid - 1] as f32 + numbers[mid] as f32) / 2.0 as f32
    } else {
        med = numbers[mid] as f32
    };
    med
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut values = numbers.clone();
    values.sort();
    let mut map = HashMap::new(); // HashMap<i32, u32>
    for num in values {
        *map.entry(num).or_insert(0) += 1;
    }
    // Find the maximum frequency
    let max_frequency = match map.values().max() {
        Some(&max) => max,
        None => return Vec::new(), // Return empty vector if input is empty
    };
    // Collect all values that appear with the maximum frequency
    let mut result: Vec<i32> = map
        .iter()
        .filter(|&(_, &count)| count == max_frequency)
        .map(|(&key, _)| key)
        .collect();
    // Sort the result
    result.sort();
    result
}

panda wiz

pandamrx

5 months ago

3.33ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    numbers.sort();
    let len = numbers.len();
    let mid = len / 2;
    if len % 2 == 0 {
        let a = numbers[mid - 1];
        let b = numbers[mid];
        return (a as f32 + b as f32) / 2.0;
    }
    return numbers[mid] as f32;
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut counts = HashMap::new();
    for &number in numbers.iter() {
        counts.entry(number).and_modify(|counter| *counter += 1).or_insert(1);
    }
    let mut max_count = 0;
    let mut result = Vec::new();
    for (_key, val) in counts.iter() {
        if *val > max_count {
            max_count = *val;
        }
    }
    for (key, val) in counts.iter() {
        if *val == max_count {
            result.push(*key);
        }
    }
    result.sort();
    return result;
}