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

Adrian Stanciu

stanciuadrian

10 days ago

3.12ms

86.97kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let len = numbers.len();
    match (len % 2, len / 2) {
        (0, half) => (numbers[half - 1] + numbers[half]) as f32 / 2.0,
        (1, half) => numbers[half] as f32,
        _ => unreachable!(),
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut max_count: usize = 0;
    let mut map = HashMap::new();
    for &n in numbers {
        let val = map.entry(n).or_default();
        *val += 1;
        max_count = max_count.max(*val);
    }
    let mut res = vec![];
    for (n, count) in map {
        if count == max_count {
            res.push(n);
        }
    }
    res.sort();
    res
}

Splatrac

splatrac

16 days ago

2.75ms

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 {
        let mid = numbers.len() / 2; 
        return (numbers[mid - 1] as f32 + numbers[mid] as f32) / 2.0;
    } else {
        let i = ((numbers.len() as u32 + 1) / 2) - 1;
        return numbers[i as usize] as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut h: HashMap<i32, i32> = HashMap::new();
    for number in numbers {
        let value_ref: &mut i32 = h
            .entry(*number)
            .or_insert(0);
            *value_ref += 1; 
    }
    // TODO: Implement logic here to return the mode of the list
    let max_val = h.values().max().unwrap(); // Get the maximum value
    let mut keys: Vec<i32> = h.iter().filter(|&(_, &v)| v == *max_val).map(|(k, _)| *k).collect();
    keys.sort();
    keys
}

Lvfalue

21 days ago

3.08ms

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 len = numbers.len();
    if len % 2 == 0 {
        (numbers[len / 2] + numbers[len / 2 - 1]) as f32 / 2.0
    } else {
        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 count = HashMap::new();
    for n in numbers {
        *count.entry(n).or_insert(0) += 1;
    }
    if let Some(max) = count.values().max() {
        return count
            .iter()
            .filter(|entry| entry.1 == max)
            .map(|entry| **entry.0)
            .collect()
    }
    vec![]
}

TheJanzap

22 days ago

2.92ms

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
    let len = numbers.len();
    if len % 2 == 0 {
        (numbers[len / 2] as f32 + numbers[len / 2 + 1] as f32) / 2.0
    } else {
        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 num_count = HashMap::new();
    for num in numbers {
        let count = num_count.entry(num).or_insert(0);
        *count += 1;
    }
    let max_count = num_count.values().max().unwrap();
    num_count.iter()
        .filter(|entry| entry.1 == max_count)
        .map(|entry| **entry.0)
        .collect::<Vec<_>>()
}

LS Koenig

ghoti225

24 days ago

2.95ms

87.43kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    
    let n = numbers.len();
    println!("n={}", n);
    let is_even = n % 2 == 0;
    numbers.sort();
    if is_even {
        let idx = n / 2 - 1;
        let i1 = numbers[idx];
        let i2 = numbers[idx + 1];
        
        0.5*(i1 as f32 + i2 as f32)
    } else {
        let idx = (n - 1) / 2;
        numbers[idx] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    println!("numbers={:?}", numbers);
    let mut sorted_numbers = numbers.clone();
    sorted_numbers.sort();
    let na = sorted_numbers.len();
    println!("na={}", na);
    // let mut modemap = HashMap::new();  // TODO 
    // TODO -- DEFINIELY CAN SIMPLIFY HERE
    let mut veckey = vec![];
    let mut vecval = vec![];
    let mut kk = 0;
    let mut max_count = 0;
    for elem in sorted_numbers {
        if kk == 0 {
            veckey.push(elem);
            vecval.push(1 as i32);
            kk += 1;
            continue;
        }
        let n = veckey.len() - 1;
        
        if veckey[n] == elem {
            vecval[n] += 1;
        } else {
            veckey.push(elem);
            vecval.push(1 as i32);
        }
        if vecval[n] > max_count {
            max_count = vecval[n];
        }
        kk += 1;
    }
    //println!("sorted numbers={:?}", sorted_numbers);
    println!("veckey={:?}", veckey);
    println!("vecval={:?}", vecval);
    let mut modemap = HashMap::new(); 
    for ii in 0..veckey.len() {
        modemap.insert(veckey[ii], vecval[ii]);
    }
    let retval = modemap.into_iter()
        .filter(|&(_, count)| count == max_count)
        .map(|(number, _)| number)
        .collect();
    //let retval = vec![*vecval.iter().max().unwrap()];
    println!("retval={:?}", retval);
    retval
    
}

PavelPerna

a month ago

3.10ms

87.02kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    let len = numbers.len();
    numbers.sort();
    if len == 0{
        return 1.0;
    }
    if len % 2 == 0 {
            let mid = len/2;
            let midleft = mid - 1;
            (numbers[mid] + numbers[midleft]) as f32/2.0
    }else{
            numbers[len / 2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut candidates :HashMap<i32, i32> = HashMap::new();
    for &num in numbers {
        *candidates.entry(num).or_insert(0) += 1;
    }
    let mut resmax : i32 = 0;
    let mut ressame :Vec<i32> = vec![];
    let mut max:i32 = 0 ;
    let mut maxsametime:i32 = 0 ;
    for (num,times) in candidates.clone(){
        if max < times {
            max = times;
            resmax = num;
        }
        for (num2,times2) in candidates.clone(){
            if (times == times2) && (num!=num2){
                if !ressame.contains(&num){
                    if maxsametime < times{
                        maxsametime = times;
                    }
                    ressame.extend([num]);
                }
            }
        }
    }
    if maxsametime >= max{
        if !ressame.contains(&resmax){
            ressame.extend([resmax]);
        }
        ressame.sort();
        return ressame
    }else{
        return vec![resmax]
    }
    
}

Miguel Ángel Allende

maallende

a month ago

3.38ms

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] as f32;
    }else{
        return (numbers[numbers.len()/2-1]+numbers[numbers.len()/2]) as f32/2_f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut hash_map:HashMap<i32,i32> = HashMap::new();
    /*numbers.iter().map(|n|{
        let n = *n;
        hash_map.entry(n).and_modify(|counter|{
            *counter += 1;
        }).or_insert(1)
    });*/
    for number in numbers{
        hash_map.entry(*number).and_modify(|counter|{
            *counter += 1;
        }).or_insert(1);
    }
    let max: i32 = hash_map.values().cloned().max().unwrap_or(0);
    let result: Vec<i32> = hash_map.iter().filter(|(_,y)| **y==max).map(|(x,_)|*x).collect();
    /*let mut entries:Vec<(i32,i32)> = hash_map.iter().map(|(k, v)|(*k, *v)).collect();
    entries.sort_by(|a,b|a.1.cmp(&b.1));
    entries.reverse();
    let max:i32 = entries[0].1;
    let mut result: Vec<i32> = Vec::new();
    result.push(entries[0].0);
    let mut index = 1;
    while index < entries.len(){
        let entry = entries[index];
        if entry.1>= max{
            result.push(entry.0);
        }else{
            break
        }
        index += 1;
    }*/
    result
}

Arpan Shingala

arpan-vs

a month ago

4.25ms

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 mid = (numbers.len() - 1) / 2;
    if numbers.len() % 2 != 0 {
        return numbers[mid] as f32;
    } else {
        return (numbers[mid] + 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()
}

GunGraveCpp

a month 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

a month 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 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 - 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

2 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 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

3 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

3 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

3 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

3 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

3 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

3 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

4 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

4 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

4 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

4 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

4 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

4 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

5 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

5 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

5 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

5 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

5 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

5 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

5 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

6 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

6 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()
}