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

Ayushman Rathore

Spartan09

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

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

6 hours 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
}

manuelmj

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

a month 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()
}

Mikhail Shutov

mshutov

a month ago

3.74ms

86.88kb

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

Dominicm99

a month 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 mid = numbers.len() / 2;
    if numbers.len() % 2 == 1 {
        return numbers[mid] as f32;
    }
    return (numbers[mid] as f32 + numbers[mid-1] as f32)/2.0;
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut freq : HashMap<i32, u32> = HashMap::new(); 
    for n in numbers {
        freq.entry(*n).and_modify(|fr| { *fr += 1 }).or_insert(1);
    }
    let max = freq.values().max().unwrap();
    let mut result: Vec<i32> = freq.iter().filter(|(_,fr)| *fr ==  max).map(|(k,_)| *k).collect();
    result.sort();
    result
}

rawar089

a month ago

2.68ms

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 {
        (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 h: HashMap<i32, i32> = HashMap::new();
    for &n in numbers {
        h.entry(n).and_modify(|count| *count += 1).or_insert(1);
    }
    let max_count = h.values().max().unwrap();
    let mut modes = h
        .iter()
        .filter(|&(_, &count)| count == *max_count)
        .map(|(&k, _)| k)
        .collect::<Vec<i32>>();
    modes.sort();
    modes
}

nedrw

a month ago

2.95ms

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 {
        (numbers[length/2-1] + numbers[length/2]) as f32 / 2.
    } else {
        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 count = 0;
    let mut hmap = HashMap::new();
    for i in numbers {
        hmap.entry(i).and_modify(|x| *x += 1).or_insert(0);
        if hmap[i] > count {
            count = hmap[i];
        }
    }
    let mut res = vec![];
    for (k, v) in hmap {
        if v == count {
            res.push(*k);
        }
    }
    res.sort();
    res
}

zahrajavar

a month ago

2.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 n = numbers.len();
    if n%2 ==0 {
        return ((numbers[n/2]as f32 + numbers[(n/2)-1]as f32 )/2.0);
    }else{
        return numbers[(n-1)/2] as f32;
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut frequency_map = HashMap::new();
    for &num in numbers{
        *frequency_map.entry(num).or_insert(0) += 1;
    }
    let max_frequency = match frequency_map.values().max() {
            Some(&max) => max,
            None => return Vec::new(), // Return an empty vector if input is empty
        };
    let mut modes = Vec::new();
    for (value, freq) in frequency_map{
        if freq == max_frequency{
            modes.push(value);
        }
    
    }
     modes.sort();
        modes
}

Kamuran

karapy

a month ago

3.79ms

86.88kb

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] + numbers[len / 2 - 1]) as f32 / 2f32
    } else {
        numbers[len / 2] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut occurrences = HashMap::new();
    // Count the frequency of each number
    for &num in numbers {
        *occurrences.entry(num).or_insert(0) += 1;
    }
    // Find the maximum frequency
    let max_count = occurrences.values().cloned().max().unwrap_or(0);
    // Collect all numbers that match the maximum frequency
    let mut modes: Vec<i32> = occurrences
        .into_iter()
        .filter(|&(_, count)| count == max_count)
        .map(|(num, _)| num)
        .collect();
    // Sort the modes before returning
    modes.sort();
    modes
}

Max

maxemontio

a month ago

2.94ms

86.88kb

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

L-Super

a month ago

3.34ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let size = numbers.len();
    let m = size / 2;
    if size % 2 == 0 {
        return (numbers[m] + numbers[m - 1]) as f32 / 2.0;
    }
    numbers[m] as f32
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut count: HashMap<i32, i32> = HashMap::new();
    for i in numbers {
        let n = count.entry(*i).or_insert(0);
        *n += 1;
    }
  let max = count.values().max().unwrap_or(&0);
    let mut result = Vec::new();
    
    for (key, value) in count.iter() {
        if value == max {
            result.push(*key)
        }
    };
    result.sort();
    result
}

Stan

i2z4

a month ago

2.93ms

86.88kb

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 mid1 = numbers[n / 2 - 1];
        let mid2 = numbers[n / 2];
        (mid1 + mid2) as f32 / 2.0
    }
}
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_freq = *frequency_map.values().max().unwrap_or(&0);
    frequency_map
        .into_iter()
        .filter(|&(_, count)| count == max_freq)
        .map(|(num, _)| num)
        .collect()
}

aey4

a month ago

2.98ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let middle = numbers.len()/2;
    return match numbers.len() % 2 == 0 {
        true => (numbers[middle - 1] + numbers[middle])as f32 / 2.0,
        false => (numbers[middle]) as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
let mut recurrency = HashMap::new();
for &number in numbers {
    recurrency.entry(number).and_modify(|count| *count += 1).or_insert(1);
}
let count_max = recurrency.values().copied().max().unwrap_or(0);
let mut result: Vec<i32> = recurrency
        .iter()
        .filter(|&(_, &count)| count == count_max)
        .map(|(&number, _)| number)
        .collect();
    result.sort();
    result
}

Lauri Sarap

LauriSarap

a month 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();
    
    let len = numbers.len();
    if len % 2 == 0 { 
        let mid1 = len / 2 - 1;
        let mid2 = len / 2;
        (numbers[mid1] as f32 + numbers[mid2] 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 map: HashMap<i32, i32> = HashMap::new();
    for &number in numbers {
        *map.entry(number).or_insert(0) += 1;
    }
    let mut max_value = i32::MIN;
    for &value in map.values() {
        if value > max_value {
            max_value = value;
        }
    }
    let mut list_of_most_frequent_numbers: Vec<i32> = Vec::new();
    for (&key, &value) in &map {
        if value == max_value {
            list_of_most_frequent_numbers.push(key);
        }
    }
    list_of_most_frequent_numbers
}

chuyuanlinzi

a month 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 size = numbers.len();
    let is_odd = size % 2 == 1;
    if is_odd{
         numbers[(size - 1) / 2] as f32
    } else {
        let index_middle = size / 2;
        (numbers[index_middle - 1] as f32 + numbers[index_middle] 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 count_map:HashMap<i32, i32> = HashMap::new();
    for &num in numbers{
        count_map.entry(num).and_modify(|count| *count+=1).or_insert(1);
    }
    let max_count = count_map.values().max().copied().unwrap_or(0);
    let mut result: Vec<i32> = count_map.iter().filter(|&(_, &count)| count == max_count).map(|(&num, _)| num).collect();
    result.sort();
    result
}

RonaldoArayadev

a month ago

2.73ms

86.90kb

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 num = numbers.len();
    let medianindex = ((num as f64) / 2.0) as u32;
    if num % 2 == 0 {
        return (numbers[(medianindex-1) as usize] + numbers[medianindex as usize]) as f32 / 2.0;
    }
    else {
        return numbers[medianindex as usize] as f32;
    }
}
pub struct Entry {
    key: i32,
    value: i32,
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut occurrences: HashMap<i32, i32> = HashMap::new();
    for &value in numbers {
        *occurrences.entry(value).or_insert(0) += 1;
    }
    let mut count_vec: Vec<Entry> = occurrences.iter().map(|(&key, &value)| {
        Entry {key, value}
    }).collect();
    count_vec.sort_by(|a, b| b.value.cmp(&a.value));
    let max = count_vec.first().unwrap().value;
    let mut answer = count_vec.iter().filter(|entry| {
        entry.value == max
    })
    .map(|entry| entry.key)
    .collect::<Vec<_>>();
    answer.sort_unstable();
    answer
}

hubbardip

a month ago

2.65ms

86.88kb

use std::{cmp::max, collections::HashMap};
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let mid = numbers.len() / 2;
    if numbers.len() % 2 == 0 {
        (numbers[mid] + numbers[mid - 1]) as f32 / 2.0
    } else {
        numbers[mid] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut hm: HashMap<i32, u32> = HashMap::new();
    let mut m = 0;
    for &i in numbers {
        let entry = hm.entry(i).or_default();
        *entry += 1;
        m = max(m, *entry);
    }
    let mut v: Vec<i32> = hm
        .iter()
        .filter_map(|(&n, &c)| if c == m { Some(n) } else { None })
        .collect();
    v.sort();
    v
}

Tarokc

a month ago

3.15ms

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 res: Vec<i32> = Vec::new();
    let mut map: HashMap<i32, i32> = HashMap::new();
    for i in numbers {
        *map.entry(*i).or_insert(0) += 1;
    }
    
    let mut val: i32 = 0;
    for (k,v) in map.into_iter() {
        if v > val {
            val = v;
            res.clear();
            res.push(k);
        }    
        else if v == val {
            res.push(k);
        }
        else {
            continue
        }
    }
    res.sort();
    res
}

Tarokc

a month 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
    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 res: Vec<i32> = Vec::new();
    let mut map: HashMap<i32, i32> = HashMap::new();
    for i in numbers {
        *map.entry(*i).or_insert(0) += 1;
    }
    
    let mut val: i32 = 0;
    for (k,v) in map.into_iter() {
        if v > val {
            val = v;
            res.clear();
            res.push(k);
        }    
        else if v == val {
            res.push(k);
        }
        else {
            continue
        }
    }
    res.sort();
    res
}

Caio César

caiocdcs

a month ago

3.02ms

87.12kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    // TODO: Implement logic here to return the median of the list
    let l = numbers.len();
    numbers.sort_unstable();
    if l % 2 == 0 {
        return (numbers[l / 2] as f32 + numbers[(l / 2) - 1] as f32) / 2.0;
    }
    numbers[l / 2] 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::with_capacity(numbers.len());
    numbers.iter().for_each(|&n| {
        map.entry(n).and_modify(|counter| *counter += 1).or_insert(1);
    });
    let max_elem = map.iter()
        .max_by(|a, b| a.1.cmp(&b.1))
        .unwrap();
    let mut mode = map.iter()
        .filter(|(_, &v)| v == *max_elem.1)
        .map(|(&k, _)| k)
        .collect::<Vec<i32>>();
    mode.sort_unstable();
    mode
}

viky

vikyw89

a month 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
    let mut sorted_numbers = numbers.clone();
    sorted_numbers.sort();
    let is_even = sorted_numbers.len() % 2 == 0;
    if !is_even {
        return sorted_numbers[(sorted_numbers.len() - 1) / 2] as f32;
    }
    let middle_left_index = sorted_numbers.len() / 2 - 1;
    let middle_right_index = sorted_numbers.len() / 2;
    let total = sorted_numbers[middle_left_index] + sorted_numbers[middle_right_index];
    return total as f32 / 2.0;
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let number_hashmap: HashMap<i32, i32> =
        numbers.iter().fold(HashMap::new(), |mut acc, &number| {
            *acc.entry(number).or_insert(0) += 1;
            acc
        });
    let max_count = number_hashmap.values().max().cloned().unwrap_or(0);
    let mut mode_numbers: Vec<i32> = number_hashmap
        .iter()
        .filter(|&(_, &count)| count == max_count)
        .map(|(&number, _)| number) // No need to dereference
        .collect();
    mode_numbers.sort();
    return mode_numbers;
}

viky

vikyw89

a month ago

4.16ms

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 mut sorted_numbers = numbers.clone();
    sorted_numbers.sort();
    let is_even = sorted_numbers.len() % 2 == 0;
    if !is_even {
        return sorted_numbers[(sorted_numbers.len() - 1) / 2] as f32;
    }
    let middle_left_index = sorted_numbers.len() / 2 - 1;
    let middle_right_index = sorted_numbers.len() / 2;
    let total = sorted_numbers[middle_left_index] + sorted_numbers[middle_right_index];
    return total as f32 / 2.0;
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let number_hashmap: HashMap<i32, i32> =
        numbers.iter().fold(HashMap::new(), |mut acc, &number| {
            *acc.entry(number).or_insert(0) += 1;
            acc
        });
    let max_count = number_hashmap.values().max().cloned().unwrap_or(0);
    let mut mode_numbers: Vec<i32> = number_hashmap
        .iter()
        .filter(|&(_, &count)| count == max_count)
        .map(|(&number, _)| number) // No need to dereference
        .collect();
    mode_numbers.sort();
    return mode_numbers;
}

vgpetrov

a month ago

2.91ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let median = numbers.len() / 2;
    if numbers.len() % 2 == 0 {
        (numbers[median] as f32 + numbers[(median) - 1] as f32) / 2.0
    } else {
        numbers[median] as f32
    }
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map = HashMap::new();
    numbers.iter().for_each(|n| {
        map.entry(*n)
            .and_modify(|e| *e += 1)
            .or_insert(1);
    });
    let el = map.iter()
        .max_by(|a, b| a.1.cmp(&b.1))
        .unwrap();
    let mut result: Vec<i32> = Vec::new();
    map.iter().for_each(|(k, v)| {
        if *v == *el.1 {
            result.push(*k);
        }
    });
    result.sort();
    result
}

michdorf

a month ago

3.05ms

87.12kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let len: f32 = numbers.len() as f32;
    let mid = (len / 2.0).floor();
    let i = mid as usize;
    if len % 2.0 == 0.0 {
        return ((numbers[i - 1] + numbers[i]) as f32) / 2.0;
    }
    return numbers[i] 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::with_capacity(numbers.len());
    for number in numbers {
        map.entry(*number).and_modify(|value| *value += 1).or_insert(1);
    }
    let max_occur = map.values().cloned().max().unwrap_or(0);
    let mut r = map.iter()
        .filter(|&(_, &v)| v == max_occur)
        .map(|(&k, _)| k)
        .collect::<Vec<i32>>();
    r.sort();
    r
}

Benjamin Falk

lumio

a month ago

4.38ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let item_count = (numbers.len() - 1) as f32;
    let start = (item_count / 2.0).floor() as usize;
    let end = (item_count / 2.0).ceil() as usize;
    let slice = &numbers[start..=end];
    let sum: i32 = slice.into_iter().sum();
    sum as f32 / slice.len() as f32
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    let mut map: HashMap<i32, i32> = HashMap::new();
    numbers.iter().for_each(|x| {
        let entry = map.entry(*x).or_insert(0);
        *entry += 1;
    });
    let max_count = map
        .iter()
        .max_by(|a, b| a.1.cmp(&b.1))
        .map(|(_, v)| v)
        .expect("Expected value");
    
    map.iter()
        .filter(|(_, v)| *v == max_count)
        .map(|(k, _)| *k)
        .collect()
}

JeppeFoldberg

a month ago

3.80ms

86.88kb

use std::collections::HashMap;
pub fn median(numbers: &mut Vec<i32>) -> f32 {
    numbers.sort();
    let length = numbers.len();
    if length % 2 == 0 {
        (numbers[length / 2 - 1] + numbers[length / 2]) as f32 / 2.0
    } else {
        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 map: HashMap<i32, i32> = HashMap::new();
    for number in numbers {
        map
            .entry(*number)
            .and_modify(|counter| *counter += 1)
            .or_insert(1);
    }
    let max = map.values().max().unwrap_or(&0);
    let mut result = Vec::new();
    
    for (key, value) in map.iter() {
        if value == max {
                result.push(*key)
            }
    };
    result.sort();
    result
}

Denis SOURON

Brack0

a month ago

3.13ms

86.88kb

use std::{cmp::Ordering, collections::HashMap};
pub fn median(numbers: &mut [i32]) -> f32 {
    numbers.sort();
    let mid = numbers.len() / 2;
    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 frequency_map: HashMap<i32, i32> = HashMap::new();
    for &num in numbers {
        *frequency_map.entry(num).or_insert(0) += 1;
    }
    let mut max_frequency = 0;
    let mut modes = vec![];
    for (&num, &frequency) in frequency_map.iter() {
        match frequency.cmp(&max_frequency) {
            Ordering::Greater => {
                max_frequency = frequency;
                modes.clear();
                modes.push(num);
            }
            Ordering::Equal => modes.push(num),
            Ordering::Less => {}
        }
    }
    modes.sort();
    modes
}

Enriko

rix71

a month ago

3.42ms

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 size = numbers.len();
    if size % 2 == 0 {
        (numbers[(size / 2) - 1] + numbers[size / 2]) as f32 * 0.5
    } else {
        numbers[size / 2] 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();
    numbers.iter().for_each(|num| {counts.entry(num).and_modify(|count| *count += 1).or_insert(1);});
    let max = counts.iter().max_by(|a, b| a.1.cmp(&b.1) ).map(|(_k, v)| v).unwrap();
    let mut modes = counts.iter().filter(|(_k, v)| **v == *max).map(|(k, _v)| **k).collect::<Vec<_>>();
    modes.sort();
    modes
}

Chris

chriswmann

a month ago

2.60ms

86.90kb

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_unstable();
    let len = numbers.len();
    
    match len {
        0 => panic!("Need at least one value to compute the median"),
        1 => numbers[0] as f32,
        len if len % 2 == 0 => (numbers[len / 2] + numbers[len / 2 - 1]) as f32 / 2.0,
        _ => numbers[len / 2] as f32
    }
}
pub struct Entry {
    key: i32,
    value: i32,
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut occurrences: HashMap<i32, i32> = HashMap::new();
    for &value in numbers {
        *occurrences.entry(value).or_insert(0) += 1;
    }
    let mut count_vec: Vec<Entry> = occurrences.iter().map(|(&key, &value)| {
        Entry {key, value}
    }).collect();
    count_vec.sort_by(|a, b| b.value.cmp(&a.value));
    let max = count_vec.first().unwrap().value;
    let mut answer = count_vec.iter().filter(|entry| {
        entry.value == max
    })
    .map(|entry| entry.key)
    .collect::<Vec<_>>();
    answer.sort_unstable();
    answer
}

Chris

chriswmann

a month ago

2.62ms

87.37kb

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_unstable();
    let len = numbers.len();
    
    match len {
        0 => panic!("Need at least one value to compute the median"),
        1 => numbers[0] as f32,
        len if len % 2 == 0 => (numbers[len / 2] + numbers[len / 2 - 1]) as f32 / 2.0,
        _ => numbers[numbers.len() / 2] as f32
    }
}
pub struct Entry {
    key: i32,
    value: i32,
}
pub fn mode(numbers: &Vec<i32>) -> Vec<i32> {
    // TODO: Implement logic here to return the mode of the list
    let mut occurrences: HashMap<i32, i32> = HashMap::new();
    for &value in numbers {
        *occurrences.entry(value).or_insert(0) += 1;
    }
    let mut count_vec: Vec<Entry> = occurrences.iter().map(|(&key, &value)| {
        Entry {key, value}
    }).collect();
    count_vec.sort_by(|a, b| b.value.cmp(&a.value));
    let max = count_vec.first().unwrap().value;
    count_vec.iter().filter(|entry| {
        entry.value == max
    }).map(|entry| entry.key)
    .collect()
}

Jaden Wijata

xenonminer

2 months ago

2.74ms

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 n = numbers.len();
    numbers.sort();
    if numbers.len() % 2 == 1 {
        return numbers[n/2] as f32;
    } else {
        return (numbers[n/2] + numbers[n/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 freq: HashMap<i32, u32> = HashMap::new();
    for n in numbers {
        freq.entry(*n).and_modify(|fr| {*fr += 1}).or_insert(1);
    }
    let max = freq.values().max().unwrap();
    let mut result: Vec<i32> = freq.iter().filter(|(_,fr)| *fr ==  max).map(|(k,_)| *k).collect();
    result.sort();
    return result
}

Giuliano

GiulianoCTRL

2 months ago

2.66ms

86.88kb

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