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

ikatlinsky

18 hours 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

6 days 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

9 days 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

13 days 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

17 days 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

20 days 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

22 days 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

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

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

2 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

2 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

2 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

2 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

2 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

2 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

3 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

3 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

3 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

3 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

3 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

3 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

3 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

3 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

3 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;
}

lugtester

3 months ago

2.91ms

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();
    match length%2 {
        0 => (numbers[length/2]+ numbers[length/2 - 1]) as f32 /2.0 ,
        _ => numbers[length/2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut numeros: HashMap<i32, i32> = HashMap::new();
    for i in numbers {
        *numeros.entry(*i).or_insert(0) += 1;
    }
    let max_value = numeros.values().max().unwrap().clone();
    /*
    let mut results = Vec::new();
    for (k,v) in numeros.iter() {
        if v == max_value {
            results.push(*k);
        }
    }
    */
    let mut results: Vec<i32> = numeros.into_iter()
        .filter_map(|(k,v)| if v == max_value {Some(k)} else {None})
        .collect();
    results.sort();
    results
}

Anna Komarova

Vlasanya

3 months ago

2.95ms

86.88kb

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 {
        let mid1 = numbers[len / 2 - 1];
        let mid2 = numbers[len / 2];
        (mid1 as f32 + mid2 as f32) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut frequency = HashMap::new();
    
    for &num in numbers {
        *frequency.entry(num).or_insert(0) += 1;
    }
    
    let max_frequency = frequency.values().cloned().max().unwrap_or(0);
    
    let mut modes: Vec<i32> = frequency
        .into_iter()
        .filter_map(|(num, count)| if count == max_frequency { Some(num) } else { None })
        .collect();
    
    modes.sort();
    modes
}

Icarus

IcarusxB

3 months ago

3.87ms

86.88kb

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] as f32 + numbers[len / 2] as f32) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut frequency_map: HashMap<i32, u32> = HashMap::new();
    
    for &num in numbers.iter() {
        *frequency_map.entry(num).or_insert(0) += 1;
    }
    let max_freq = *frequency_map.values().max().unwrap_or(&0);
    let mut modes: Vec<i32> = frequency_map.into_iter()
        .filter(|&(_, count)| count == max_freq)
        .map(|(num, _)| num)
        .collect();
    modes.sort();
    modes
}

no-yan

3 months ago

2.96ms

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 == 0 {
        let sm = (numbers[len/2-1] + numbers[len/2])  as f32;
        return sm / 2.0;
    }
    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 hm = HashMap::new();
    let mut max_count = 0;
    for &num in numbers {
        let count = hm.entry(num).or_insert(0) ;
        *count+= 1;
        if  *count > max_count {
            max_count = *count
        }
    }
    let mut res : Vec<i32>= hm.iter().filter(|(_, y)| **y == max_count)
        .map(|(number, _) | number.clone())
        .collect();
    res.sort();
    res
}

AnKarl

Zythophilus

3 months ago

3.77ms

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 {
        ((numbers[(numbers.len() / 2) as usize] + numbers[(numbers.len() / 2 - 1) as usize]) as f32) / 2.0
    } else {
        numbers[(numbers.len() / 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 map = HashMap::<i32, u32>::new();
    for num in numbers {
        let counter = map.entry(*num).or_insert(0);
        *counter += 1;
    }
    let max = map.values().max().unwrap();
    let mut res = map.iter().filter(|(_, v)| *v == max).map(|(k, _)| *k).collect::<Vec<i32>>();
    
    res.sort();
    res
}

Ayushman Rathore

Spartan09

4 months ago

3.01ms

86.88kb

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

Lucas Deprit

lucasdeprit

4 months ago

2.98ms

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
    let len = numbers.len();
    if len % 2 == 0 {
        return (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 hash_map: HashMap<i32, i32>= HashMap::new();
    for &number in numbers.iter() {
        *hash_map.entry(number).or_insert(0) += 1; 
    }
    let mut response: Vec<i32> = Vec::new();
    if let Some(val) = hash_map.values().max() {
        response.extend(hash_map.iter().filter_map(|(key, value)|
		if *value == *val {
			Some(key)
		} else {
			None
		}));
    }
    response
}

Lucas Deprit

lucasdeprit

4 months ago

2.88ms

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
    let len = numbers.len();
    if len % 2 == 0 {
        return (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 hash_map: HashMap<i32, i32>= HashMap::new();
    for &number in numbers.iter() {
        *hash_map.entry(number).or_insert(0) += 1; 
    }
    let mut response: Vec<i32> = Vec::new();
    if let Some(val) = hash_map.values().max() {
        response.extend(hash_map.iter().filter_map(|(key, value)|
		if *value == *val {
			Some(key)
		} else {
			None
		}));
    }
    response
}

Manuel Manjarres R.

manuelmj

4 months ago

2.99ms

87.72kb

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(); 
    println!("{:?}",numbers);
    let total_len = u32::try_from(numbers.len()).unwrap_or(u32::MAX);
    let middle: usize = usize::try_from(total_len / 2).unwrap(); 
    
    if total_len % 2 != 0 {
        return *numbers.get(middle).unwrap() as f32; 
    }
    (numbers.get(middle - 1).unwrap() + numbers.get(middle ).unwrap() ) as f32 / 2.0
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    println!("{:?}", numbers);
    let mut freq: HashMap<i32,i32> = HashMap::new();
    
    for &number in numbers.iter() {
        *freq.entry(number).or_insert(0) += 1; 
    }
    println!("{:?}",freq);
    if let Some((_,max_value)) = freq.iter().max_by_key(|&(_, v)| v){
       return freq.iter()
            .filter(|&(_, v)| v == max_value) 
            .map(|(k, _)| *k) // Extrae solo las claves
            .collect(); // Recoge las claves en un Vec
    };
    vec![]
}

Yi Hao

leongyihao

4 months ago

2.93ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
	numbers.sort();
	if 0 == numbers.len() % 2 {
		((numbers[numbers.len() / 2 - 1] as f32) + (numbers[numbers.len() / 2] as f32)) / 2.
	}
	else {
		numbers[numbers.len() / 2] as f32
	}
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
	let mut tracker = HashMap::<i32, i32>::new();
	for item in numbers.iter() {
		*tracker.entry(*item).or_insert(0) += 1;
	}
	let mut biggest = Vec::<i32>::new();
	if let Some(val) = tracker.values().max() {
		biggest.extend(tracker.iter().filter_map(|(key, value)|
		if *value == *val {
			Some(key)
		} else {
			None
		}));
	}
	biggest
}

Jordan

Jordan-Haidee

4 months ago

2.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();
    if numbers.len() % 2 == 0 {
        let idx = numbers.len() / 2 as usize;
        return (numbers[idx - 1] as f32 + numbers[idx] as f32) / 2.;
    } else {
        let idx = numbers.len() / 2 as usize;
        return numbers[idx] as f32;
    }
}
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>::new();
    for n in numbers.iter() {
        map.entry(*n).and_modify(|v| *v += 1).or_insert(1);
    }
    let max = map.values().max().unwrap();
    let mut res = vec![];
    for (k, v) in map.iter() {
        if *v == *max {
            res.push(*k);
        }
    }
    res.sort();
    res
}

Nikita Smirnov

Nismirno

4 months ago

3.70ms

86.88kb

use std::collections::{hash_map::Entry, HashMap};
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let size = numbers.len();
    let mid = size / 2;
    if size % 2 == 0 {
        (numbers[mid - 1] as f32 + numbers[mid] as f32) / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut freq_map: HashMap<i32, i32> = HashMap::new();
    let mut most_freq = 1;
    for &number in numbers {
        if let Entry::Occupied(mut entry) = freq_map.entry(number) {
            let value = entry.get_mut();
            *value += 1;
            most_freq = most_freq.max(*value);
        } else {
            freq_map.insert(number, 1);
        }
    }
    let mut res = freq_map
        .into_iter()
        .filter(|(_, freq)| *freq == most_freq)
        .map(|(num, _)| num)
        .collect::<Vec<i32>>();
    res.sort();
    res
}

Christopher Nielson

c-nielson

4 months ago

3.06ms

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 - 1) / 2] as f32
    } else {
        (numbers[len / 2] + numbers[(len / 2) - 1]) as f32 / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map = HashMap::new();
    for number in numbers {
        let count = map.entry(number).or_insert(0);
        *count += 1;
    };
    let max = *map.values().max().or(Some(&0)).unwrap();
    let mut result: Vec<i32> = Vec::new();
    map.iter().for_each(|(key, value)| {
        if value == &max {
            result.push(**key);
        }
    });
    result
}

SeinPierre

4 months ago

3.47ms

87.24kb

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 == 1{
        numbers[n/2] as f32
    } else {
        (numbers[n/2 -1] + numbers[n / 2]) as f32 / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    if numbers.is_empty() {
        return vec![];
    }
    let mut count: HashMap<i32, i32> = HashMap::default();
    for n in numbers {
        *count.entry(*n).or_default() += 1;
    }
    dbg!(&count);
    let max_count = count.iter().max_by_key(|(_, &v)| v).unwrap().1;
    count.iter().filter(|(_, v)| *v == max_count).map(|(k, _)| *k).collect()
}

エヴァンゲリオン

Lu-zihang

5 months ago

2.94ms

87.24kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let n = numbers.len();
    if n % 2 == 1 {
        numbers[n / 2] as f32
    } else {
        let a = numbers[n / 2 - 1] as f32;
        let b = numbers[n/2] as f32;
        (a + b) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    if numbers.is_empty() {
        return vec![];
    }
    let mut count: HashMap<i32, i32> = HashMap::default();
    for n in numbers {
        *count.entry(*n).or_default() += 1;
    }
    dbg!(&count);
    let max_count = count.iter().max_by_key(|(_, &v)| v).unwrap().1;
    count.iter().filter(|(_, v)| *v == max_count).map(|(k, _)| *k).collect()
}

Florian Gaudin-Delrieu

FlorianGD

5 months ago

2.95ms

87.24kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let n = numbers.len();
    if n % 2 == 1 {
        numbers[n / 2] as f32
    } else {
        let a = numbers[n / 2 - 1] as f32;
        let b = numbers[n/2] as f32;
        (a + b) / 2.0
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    if numbers.is_empty() {
        return vec![];
    }
    let mut count: HashMap<i32, i32> = HashMap::default();
    for n in numbers {
        *count.entry(*n).or_default() += 1;
    }
    dbg!(&count);
    let max_count = count.iter().max_by_key(|(_, &v)| v).unwrap().1;
    count.iter().filter(|(_, v)| *v == max_count).map(|(k, _)| *k).collect()
}

Sthitaprajna Sahu

sthitasahu

5 months ago

2.77ms

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==1{
        numbers[length/2] as f32
    }
    else{
        (numbers[length/2]+numbers[(length/2)-1])  as f32/2  as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut occurrences=HashMap::new();
   
    for &num in numbers {
        *occurrences.entry(num).or_insert(0) += 1;
    }
   let max_count = occurrences.values().cloned().max().unwrap_or(0);
    occurrences
        .into_iter()
        .filter_map(|(num, count)| if count == max_count { Some(num) } else { None })
        .collect()
}

dawwestk

5 months ago

2.70ms

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 numbers.len() & 1 == 1 {
        numbers[l/2] as f32
    } else {
        (numbers[(l/2)-1] + numbers[l/2]) as f32 / 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, i32> = HashMap::new();
    numbers
        .iter()
        .for_each(|n| {
            h.entry(*n).and_modify(|counter| *counter += 1).or_insert(1);
        });
    get_mode_from_hashmap(h)
}
pub fn get_mode_from_hashmap(h: HashMap<i32, i32>) -> Vec<i32> {
     let mut max_val: i32 = 0;
     let mut max_vals: Vec<i32> = vec![];
     for (k, v) in h.iter() {
        if *v > max_val {
            max_val = *v;
            max_vals.clear();
            max_vals.push(*k);
        } else if *v == max_val {
            max_vals.push(*k)
        }
     }
     max_vals.sort();
     max_vals
}

PangoSea

kapaseker

5 months ago

2.89ms

86.89kb

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.is_empty() {
        return 0.0;
    }
    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> {
    // TODO: Implement logic here to return the mode of the list
    let mut occurrences = HashMap::new();
    let mut order = Vec::new();
    // Count the occurrences of each number and keep track of their order
    for &num in numbers {
        let counter = occurrences.entry(num).or_insert(0);
        *counter += 1;
        if *counter == 1 {
            order.push(num);
        }
    }
    // Determine the highest frequency
    let max_count = occurrences.values().cloned().max().unwrap_or(0);
    // Collect all numbers with the highest frequency, preserving the original order
    order.into_iter()
        .filter(|&num| occurrences[&num] == max_count)
        .collect()
}

Marco-Normal

5 months ago

2.79ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    if numbers.len() % 2 == 0 {
        return (numbers[numbers.len() / 2] + numbers[numbers.len() / 2 - 1]) as f32 / 2.0
    } else {
        return (numbers[numbers.len() / 2]) as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map: HashMap<i32, i32> = HashMap::new();
    for num in numbers.iter() {
        map.entry(*num).and_modify(|x| *x += 1).or_insert(1);
    }
    let mut max_count = 0;
    for v in map.values() {
        if *v > max_count {
            max_count = *v;
        }
    }
    let mut ans = Vec::new();
    for (n, c) in map.iter() {
        if *c == max_count {
            ans.push(*n);
        }
    }
    ans.sort();
    ans
}

Larry Oates

Leafmun-certii

5 months ago

3.23ms

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 length = numbers.len();
    if length % 2 == 0 {
        let lower_middle = length/2;
        return (numbers[lower_middle-1] + numbers[lower_middle]) as f32 / 2.0
    }
    else {
        return numbers[length/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 {
        num_count.entry(num)
        .and_modify(|c| {*c += 1 })
        .or_insert(1);
    }
    let max_count = num_count.values().max();
    match max_count {
        None => return Vec::new(),
        Some(max) => return num_count.iter()
            .filter(|x| x.1 == max)
            .map(|x| **x.0)
            .collect(),
    }
}

vikingNR

5 months ago

2.56ms

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 length = numbers.len();
    if length % 2 == 1{
        return numbers[length/2] as f32
    } else {
        return ((numbers[length / 2] + numbers[length / 2 ] - 1) as f32 / 2.0) as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut map = HashMap::new();
    let mut v = Vec::new();
    let mut max = 1;
    for num in numbers{
        map.entry(num).and_modify(|counter| {*counter += 1; max = *counter}).or_insert(1);
    } //(1:4,2:4,3:1)
    for (num, count) in map{
        if count == max {v.push(*num)}
    }
    v
}

VLund

VladikPopik

5 months ago

2.94ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    if numbers.is_empty() {
        return 0.0;
    }
    numbers.sort();
    let len = numbers.len();
    if len % 2 == 0 {
        (numbers[len / 2 - 1] as f32 + numbers[len / 2] 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 occurrences = HashMap::new();
    numbers.iter().for_each(|n| {
        *occurrences.entry(*n).or_insert(0) += 1;
    });
    let mut result = occurrences.values().max().map_or(Vec::new(), |max_value| {
        occurrences.iter()
            .filter(|(_, &v)| v == *max_value)
            .map(|(&k, _)| k)
            .collect()
    });
    result.sort();
    result
}

Algorab

5 months ago

2.48ms

86.88kb

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

Joe Schneider

josschne

5 months ago

4.65ms

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 == 0 {
        (numbers[len/2] + numbers[len/2-1]) as f32 / 2f32
    } 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 occurrences = HashMap::new();
    numbers.iter().for_each(|n| {
        *occurrences.entry(*n).or_insert(0) += 1;
    });
    let mut result = occurrences.values().max().map_or(Vec::new(), |max_value| {
        occurrences.iter()
            .filter(|(_, &v)| v == *max_value)
            .map(|(&k, _)| k)
            .collect()
    });
    result.sort();
    result
}

Ahmet Özcan

ahmetoozcan

5 months ago

4.53ms

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,
        _ => 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 counts = numbers.iter()
        .fold(HashMap::new(), |mut acc, &x| { *acc.entry(x).or_insert(0) += 1; acc });
    
    let max_count = match counts.values().max() {
        Some(&max) => max,
        None => return Vec::new(),
    };
    counts.into_iter()
        .filter(|(_, count)| *count == max_count)
        .map(|(num, _)| num)
        .collect()
}