Animal sanctuary registry

Hashmaps

Hashmaps are a powerful data structure that allow you to store key-value pairs. In Rust, the HashMap type is provided that uses the a hashing algorithm called SipHash to store keys and values in a way that allows for fast and secure lookups. Think of them as a dictionary in Python or an object in JavaScript.

In this challenge, we want to build a sanctuary registry that allows us to manage animals in different sections of the sanctuary. We'll use a HashMap to store the sections as keys and a Vec to store the animals in each section. Each key is a section name String and each value is a list of animals in that section Vec<String>.

Task

You are given a type of Collection which is a HashMap<String, Vec<String>>. The key is the section name and the value is a list of animals in that section.

Your task is to implement the following functions:

add_animal_to_section: This function should add an animal to a section in the registry. If the section does not exist, it should be created. If the animal is already in the section, it should not be added again.
get_animals_in_section: This function should return a list of animals sorted alphabetically in a given section. If the section does not exist, it should return an empty list.
get_all_animals_sorted: This function should return a copy of the entire registry with all animals sorted alphabetically in each section.

Example

let mut registry = Collection::new();
 
add_animal_to_section("Eagle", "Birds", &mut registry);
assert_eq!(get_animals_in_section("Birds", &registry), vec!["Eagle"]);

Hints

Use the insert method on a HashMap to add a new section or update an existing section.
Use the entry method on a HashMap to get a mutable reference to a section.
Use the iter method on a HashMap to iterate over the key-value pairs.
Use the sort method on a Vec to sort the animals alphabetically.

Editor not available on Mobile!

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

Solutions

Camiam144

9 hours ago

3.76ms

90.94kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    registry.entry(section.to_string())
            .or_insert_with(Vec::new);
//            .push(animal.to_string());
    let vec= registry.get_mut(section).unwrap();
    if vec.iter().any(|elem| elem == &animal.to_string()) {
     return;
    }
    vec.push(animal.to_string());
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut outvec = registry.get(section).unwrap_or(&vec![]).to_vec();
    outvec.sort();
    outvec
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animal_vec: Vec<String> = vec![];
    for (key, _val) in registry.iter(){
      let b = get_animals_in_section(&key, registry);
//      b.sort(); 
      animal_vec.extend(b);
    }
    animal_vec.sort();
    animal_vec
}

Camiam144

9 hours ago

5.21ms

90.94kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    registry.entry(section.to_string())
            .or_insert_with(Vec::new);
//            .push(animal.to_string());
    let vec= registry.get_mut(section).unwrap();
    if vec.iter().any(|elem| elem == &animal.to_string()) {
     return;
    }
    vec.push(animal.to_string());
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut outvec = registry.get(section).unwrap_or(&vec![]).to_vec();
    outvec.sort();
    outvec
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animal_vec: Vec<String> = vec![];
    for (key, _val) in registry.iter(){
      let b = get_animals_in_section(&key, registry);
//      b.sort(); 
      animal_vec.extend(b);
    }
    animal_vec.sort();
    animal_vec
}

Camiam144

9 hours ago

3.70ms

90.94kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    registry.entry(section.to_string())
            .or_insert_with(Vec::new);
//            .push(animal.to_string());
    let vec= registry.get_mut(section).unwrap();
    if !vec.iter().any(|elem| elem == &animal.to_string()) {
      vec.push(animal.to_string());
    }
    
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut outvec = registry.get(section).unwrap_or(&vec![]).to_vec();
    outvec.sort();
    outvec
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animal_vec: Vec<String> = vec![];
    for (key, _val) in registry.iter(){
      let b = get_animals_in_section(&key, registry);
//      b.sort(); 
      animal_vec.extend(b);
    }
    animal_vec.sort();
    animal_vec
}

Ushakov Andrey

stdstring

14 hours ago

4.47ms

92.97kb

use std::collections::HashMap;
use std::collections::HashSet;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    if !registry.contains_key(section) {
        registry.insert(section.to_string(), Vec::new());
    }
    let section_data = registry.get_mut(section).expect("registry invariant violation");
    let animal_str = animal.to_string();
    if !section_data.contains(&animal_str) {
        section_data.push(animal_str);
    }
    // TODO: implement this function
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(section) {
        Some (section_data) => {
            let mut animals = section_data.to_vec();
            animals.sort();
            animals
        }
        None => Vec::new() 
    }
    // TODO: implement this function
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_animals = HashSet::new();
    for (_, section_data) in registry.iter() {
        for animal in section_data.iter() {
            all_animals.insert(animal.clone());
        }
    }
    let mut result = all_animals.into_iter().collect::<Vec<_>>();
    result.sort();
    result
    // TODO: implement this function
}

Luigi Terrone

LuigiTer

21 hours ago

3.74ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
    
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    if let Some(animals) = registry.get(section) {
        let mut animals_sorted = animals.clone();
        animals_sorted.sort();
        animals_sorted
    }
    else {
        Vec::new()
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all_animals: Vec<String> = Vec::new();
    for animals in registry.values() { 
        all_animals.extend(animals.iter().cloned());
    }
    
    all_animals.sort();
    all_animals
}

Karol Płatkowski

spoohie

2 days ago

3.90ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let vec = registry.entry(section.to_owned()).or_default();
    let str_animal = animal.to_owned();
    if !vec.contains(&str_animal) {
        vec.push(str_animal);
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut vec = registry.get(section).cloned().unwrap_or_default();
    vec.sort(); // Sorts alphabetically
    vec
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all: Vec<String> = Vec::new();
    for (_, val) in registry {
        all.extend(val.clone());
    }
    all.sort();
    all
}

Heino Mortensen

hmortensen83

2 days ago

4.26ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals_in_section = registry.entry(section.to_owned()).or_default();
    if !animals_in_section.contains(&animal.to_owned()) {
        animals_in_section.push(animal.to_owned());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut animals: Vec<String> = match registry.get(section) {
        Some(animal_set) => animal_set.iter().cloned().collect(),
        None => Vec::new(),
    };
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut animals: Vec<String> = registry.values().flatten().cloned().collect();
    animals.sort();
    animals
}

0x0f1

Paul4673

2 days ago

4.09ms

91.93kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    match registry.get_mut(section) {
        Some(animals) => {
            if !animals.contains(&animal.to_string()){
                animals.push(animal.to_string());
            }
        },
        None => {
            registry.insert(section.to_string(), vec![animal.to_string()]);
        },
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let section_exists = registry.get(&String::from(section));
    match section_exists {
        Some(animals) => {
            let mut animals_by_section = (*animals).to_vec();
            animals_by_section.sort();
            animals_by_section
        },
        None => {
            Vec::new()
        },
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut sorted_animals : Vec<String> = Vec::new();
    for (_key, section) in registry {
        for animal in section.iter() {
            sorted_animals.push(animal.clone());
        }
    }
    sorted_animals.sort();
    sorted_animals
}

Gomathi Shankar

gomathishankar37

4 days ago

3.70ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    match registry.get_mut(section) {
        Some(animal_vec) => {
            // animal_vec.push(animal.to_string());
            // animal_vec.dedup();
            if !animal_vec.contains(&animal.to_string()) {
                animal_vec.push(animal.to_string());
            }
            }
        None => {
            registry.insert(section.to_string(), vec![animal.to_string()]);
            }
    };
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    match registry.get(section) {
        Some(e) => {
            let mut dummy = e.to_vec();
            dummy.sort();
            return dummy;
        },
        None => Vec::new(),
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all_animals: Vec<String> = Vec::new();
    for (_, v) in registry.iter() {
        all_animals.extend_from_slice(v);
    }
    all_animals.sort();
    return all_animals;
}

Satya Sundar Sahu

satya200

4 days ago

3.73ms

91.50kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    match registry.get_mut(section) {
        Some(val) => {
            if !val.contains(&animal.to_string()) {
                val.push(animal.to_string());
            }
        },
        None => { 
            registry.insert(section.to_string(), vec![animal.to_string()]);
        }
    };
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    match registry.get(section) {
        Some(val) => {
            let mut val_cp = val.to_vec();
            val_cp.sort();
            val_cp.to_vec()
        },
        None => Vec::new()
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all_animal: Vec<String> = Vec::new();
    for(_, v) in registry.iter() {
        all_animal.extend_from_slice(v);
    }
    all_animal.sort();
    all_animal
}

Tri Nguyen

nguyentri

6 days ago

3.83ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // Only add the animal if it's not already in the section
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // Return the list of animals in the section, or an empty list if the section doesn't exist.
    match registry.get(section) {
        Some(animals) => {
            let mut cloned_animals = animals.clone();
            cloned_animals.sort(); // Sort the cloned vector before returning
            cloned_animals
        }
        None => Vec::new(), // Return an empty vector if the section is not found
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // Collect all animals from all sections into a single vector, sort it, and return it.
    let mut all_animals: Vec<String> = registry
        .values()
        .flat_map(|animals| animals.clone())
        .collect();
    all_animals.sort();
    all_animals.dedup(); // Remove duplicates
    all_animals
}

xxxxsk

6 days ago

3.78ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    registry.entry(section.to_string()).and_modify(|v| {
       if !v.contains(&animal.to_string()) {
           v.push(animal.to_string());
       } 
    }).or_insert(vec![animal.to_string()]);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut res =registry.get(section).unwrap_or(&Vec::new()).clone();
    res.sort();
    res.dedup();
    res
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut collections = Vec::new();
    for (section, animals) in registry.iter() {
        collections.extend_from_slice(animals)
    }
    collections.sort();
    collections.dedup();
    // collections.push("123".to_string());
    collections
}

Pierre Gordo

PierreGordo

8 days ago

5.02ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
// "Felines": <"Tiger", "Cat", "Lion">
// Workflow
// 1)Check whether the key exists
//  1.1) If it does, borrow the Vec as mutable and add the desired animal to it
//  1.2) If it does NOT exist, make a new key: value pair in the desired format
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function 
    //Skip the checking and get strait to modifying
    if let Some(anim_vector) = registry.get_mut(section){
        anim_vector.push(animal.to_string());
        //Sort and deduplicate
        //anim_vector.sort();
        anim_vector.dedup();
    }
    else{
        registry.insert(section.to_string(), vec![animal.to_string()]);
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut anim_vec = Vec::new();
    if registry.contains_key(section)
    {
        for x in registry[section].iter(){
                anim_vec.push(x.to_string());
            }
    }
    anim_vec.sort();  
    anim_vec
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut anim_vec = Vec::new();
    
    for (_section, animal) in registry{
        anim_vec.extend(animal.clone());
        
    }
    anim_vec.sort();
    anim_vec
}

Lucop1911

9 days ago

4.07ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut animals = registry.get(section).unwrap_or(&vec![]).to_vec();
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut animals = vec![];
    for a in registry.values() {
        let a = a.clone();
        animals.extend(a);
    }
    animals.sort();
    animals
}

s.i

ssmi75

11 days ago

4.84ms

91.93kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert(Vec::new());
    let a = animal.to_string();
    if !animals.contains(&a) {
        animals.push(a);
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(&section.to_string()) {
        None => vec![],
        Some(v) => {
            let mut result = v.to_vec();
            result.sort();
            result
        }
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut result = vec![];
    for (_, animals) in registry.iter() {
        for a in animals.iter() {
            if !result.contains(a) {
                result.push(a.to_string());
            }
        }
    }
    result.sort();
    result
}

Abhishek Sharma

soro-kuraima

11 days ago

3.89ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(section) {
        Some(animals) => {
            let mut sorted_animals = animals.clone();
            sorted_animals.sort();
            sorted_animals
        }
        None => Vec::new(),
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_sorted_animals = Vec::new();
    for (_, animals) in registry.iter() {
        let a = animals.clone();
        all_sorted_animals.extend(a);
    }
    all_sorted_animals.sort();
    all_sorted_animals
}

ikatlinsky

12 days ago

4.17ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut animals = registry.get(section).unwrap_or(&vec![]).to_vec();
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut animals = vec![];
    for a in registry.values() {
        let a = a.clone();
        animals.extend(a);
    }
    animals.sort();
    animals
}

zzispp

12 days ago

4.14ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(section) {
        Some(animals) => {
            let mut sorted_animals = animals.clone();
            sorted_animals.sort();
            sorted_animals
        }
        None => Vec::new(),
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_sorted_animals = Vec::new();
    for (_, animals) in registry.iter() {
        let a = animals.clone();
        all_sorted_animals.extend(a);
    }
    all_sorted_animals.sort();
    all_sorted_animals
}

hahu07

13 days ago

4.51ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(section) {
        Some(animals) => {
            let mut sorted_animals = animals.clone();
            sorted_animals.sort();
            sorted_animals
        }
        None => Vec::new(),
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_sorted_animals = Vec::new();
    for (_, animals) in registry.iter() {
        let a = animals.clone();
        all_sorted_animals.extend(a);
    }
    all_sorted_animals.sort();
    all_sorted_animals
}

Enes

enesscevik

13 days ago

3.59ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let section_entry = registry.entry(section.to_owned()).or_insert(Vec::new());
    if !section_entry.contains(&animal.to_owned()){
        section_entry.push(animal.to_owned());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let animals = registry.get(section);
    match animals {
        Some(animals_vec) => {
            let mut sorted = animals_vec.clone();
            sorted.sort();
            sorted
        }
        None => vec![],
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all: Vec<String> = Vec::new();
    for (_, val) in registry {
        all.extend(val.clone());
    }
    all.sort();
    all
}

diucicd

14 days ago

4.37ms

92.97kb

use std::collections::HashMap;
use std::collections::HashSet;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    if let Some(lst) = registry.get_mut(section) {
        if !lst.contains(&animal.to_string()) {
            lst.push(animal.to_string());
        }
    } else {
        registry
            .entry(section.to_string())
            .or_default()
            .push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    registry
        .get(section)
        .map(|s| {
            let mut a = s.clone();
            a.sort();
            a
        })
        .unwrap_or(Vec::new())
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all = HashSet::new();
    for (_k, v) in registry.iter() {
        for l in v.iter() {
            all.insert(l.clone());
        }
    }
    let mut ret: Vec<String> = all.into_iter().collect();
    ret.sort_unstable();
    ret
}

diucicd

14 days ago

3.88ms

92.97kb

use std::collections::HashMap;
use std::collections::HashSet;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    if let Some(lst) = registry.get_mut(section) {
        if !lst.contains(&animal.to_string()) {
            lst.push(animal.to_string());
        }
    } else {
        registry.entry(section.to_string()).or_default().push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    registry
        .get(section)
        .map(|s| {
            let mut a = s.clone();
            a.sort();
            a
        })
        .unwrap_or(Vec::new())
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all = HashSet::new();
    for (_k, v) in registry.iter() {
        for l in v.iter() {
            all.insert(l.clone());
        }
    }
    let mut ret: Vec<String> = all.into_iter().collect();
    ret.sort_unstable();
    ret
}

ycgw

14 days ago

4.52ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let section_entry = registry.entry(String::from(section)).or_insert(Vec::new());
    if !section_entry.contains(&String::from(animal)) {
        section_entry.push(String::from(animal));
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let animals = registry.get(section);
    match animals {
        Some(animal_vec) => {
            let mut sorted_animals = animal_vec.clone();
            sorted_animals.sort();
            sorted_animals
        }
        None => vec![],
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_animals: Vec<String> = Vec::new();
    for (_, value) in registry {
        all_animals.extend(value.clone());
    }
    all_animals.sort();
    all_animals
}

esl

esl07

15 days ago

3.85ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(section) {
        Some(animals) => {
            let mut sorted_animals = animals.clone();
            sorted_animals.sort();
            sorted_animals
        }
        None => Vec::new(),
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_sorted_animals = Vec::new();
    for (_, animals) in registry.iter() {
        let a = animals.clone();
        all_sorted_animals.extend(a);
    }
    all_sorted_animals.sort();
    all_sorted_animals
}

jeroenvgestel

15 days ago

3.86ms

91.93kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    match registry.get_mut(section) {
        Some(vec) => {
            if !vec.contains(&animal.to_string()) {
                vec.push(animal.to_string());
            }
        },
        None => {
            registry.insert(section.to_string(), vec![animal.to_string()]);
        }
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    match registry.get(section) {
        Some(val) => {
            let mut newvec = val.to_vec();
            newvec.sort();
            newvec
        }
        None => vec![]
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all_animals: Vec<String> = Vec::new();
    for (_, animals) in registry {
        for animal in animals {
            all_animals.push(animal.clone())
        }
    }
    all_animals.sort();
    all_animals
}

HusseinAbdelhamid

16 days ago

5.13ms

91.93kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    if registry.contains_key(&section.to_string()){
        if registry.get(section).unwrap().contains(&animal.to_string()){
            return;
        }
        registry.get_mut(&section.to_string()).unwrap().push(animal.to_string());
        return;
    }
    registry.insert(section.to_string(),vec![animal.to_string()]);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    if !registry.contains_key(&section.to_string()){
        return vec![];
    }
     let mut copy = registry.get(&section.to_string()).unwrap().clone();
     copy.sort();
     copy
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_animals = Vec::new();
    for animals in registry.values(){
        for animal in animals.iter(){
            all_animals.push(animal.clone())
        }
    }
    all_animals.sort();
    all_animals
}

Smith Cruise

Smith-Cruise

16 days ago

3.56ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let animals = registry.entry(section.to_string()).or_insert_with(Vec::new);
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    match registry.get(section) { 
        Some(vec) => {
            let mut vec_cloned = vec.clone();
            vec_cloned.sort();
            vec_cloned
        },
        None => {
            Vec::new()
        }
    }
    
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut vec = Vec::new();
    for (key, value) in registry.iter() {
        for animal in value {
            vec.push(animal.clone());
        }
    }
    vec.sort();
    vec
}

ALDebugs

19 days ago

4.21ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let list = registry.entry(section.to_string()).or_insert(Vec::new());
    if list.contains(&animal.to_string()) {
        return;
    }
    list.push(animal.to_string());
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    if let Some(animals) = registry.get(section) {
        let mut cloned = animals.clone();
        cloned.sort();
        cloned
    } else {
        Vec::new()
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all: Vec<String> = Vec::new();
    for (_, i) in registry.iter() {
        all.extend(i.iter().cloned());
    }
    all.sort();
    all
}

Tim

timvyy

19 days ago

4.17ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let animals = registry.entry(section.to_string()).or_insert(Vec::new());
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = registry.get(section).unwrap_or(&Vec::new()).clone();
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals: Vec<String> = registry.values().flatten().cloned().collect();
    animals.sort();
    animals
}

AQian

AQian0

19 days ago

4.37ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    registry.entry(section.to_string()).and_modify(|x| {
        if !x.contains(&animal.to_string()) {
            x.push(animal.to_string())
        }
    }).or_insert(vec![animal.to_string()]);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = match registry.get(section) {
        Some(animals) => animals.clone(),
        None => vec![]
    };
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_animals: Vec<String> = registry.values().flatten().cloned().collect();
    all_animals.sort();
    all_animals
}

Torge

tostu

20 days ago

3.91ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_insert(Vec::new());
    // Only push if the animal is not already present in the section
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = registry.get(section).unwrap_or(&Vec::new()).clone();
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals: Vec<String> = registry.values().flatten().cloned().collect();
    animals.sort();
    animals
}

dunxen

21 days ago

4.04ms

90.94kb

use std::collections::{hash_map::Entry, HashMap};
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    match registry.entry(section.to_string()) {
        Entry::Occupied(mut entry) => {
            let section = entry.get_mut();
            if !section.contains(&animal.to_string()) {
                section.push(animal.to_string());
            }
        },
        Entry::Vacant(entry) => {
            entry.insert(vec![animal.to_string()]);
        },
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut section_vec = registry.get(section).unwrap_or(&vec![]).to_owned();
    section_vec.sort();
    section_vec
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all: Vec<String> = registry.values().flatten().cloned().collect();
    all.sort();
    all
}

noomcreator

22 days ago

4.38ms

91.93kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
        match registry.get_mut(section) {
        Some(animal_vector_string) => {
          if !animal_vector_string.contains(&animal.to_string()) {
            animal_vector_string.push(animal.to_string()); 
          }
        },
        None => {
            registry.entry(section.to_string()).or_insert(Vec::new()).push(animal.to_string());
        }
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = match registry.get(section) {
        Some(animals) => {
            animals.clone()
        },
        None => [].to_vec(),
    };
    animals.sort();
    animals
    
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals: Vec<String> = Vec::new();
    for (_key,value) in registry.iter() {
        for val in value.iter() {
        animals.push(val.to_string());
        }
    }
    animals.sort();
    animals
}

Sergey Matyash

matiaspub

22 days ago

4.70ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let ent = registry
        .entry(section.to_string())
        .or_insert_with(Vec::new);
    if !ent.contains(&animal.to_string()) {
        ent.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut res = match registry.get(section) {
        Some(v) => v.to_vec(),
        None => vec![]
    };
    res.sort();
    res
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut res: Vec<String> = vec![];
    for (_, v) in registry.iter() {
        for i in v.iter() {
            res.push(i.to_string());
        }
    }
    res.sort();
    res
}

maomao9-0

22 days ago

4.17ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let v = registry.entry(section.to_string()).or_insert(Vec::new());
    if !v.contains(&animal.to_string()) {
        v.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut v = registry.get(section).cloned().unwrap_or(Vec::new());
    v.sort();
    v
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all_v = Vec::new();
    for (_, v) in registry {
        all_v.extend_from_slice(v);
    }
    all_v.sort();
    all_v
}

zapp42

23 days ago

3.88ms

91.50kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let entry = registry
                .entry(section.to_string())
                .or_insert(vec![animal.to_string()]);
    if !entry.contains(&animal.to_string()) {
        entry.push(animal.to_string())
    }
    
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut result = match registry.get(section) {
        Some(animals) => animals.to_vec(),
        None => Vec::new()
    };
    result.sort();
    result
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut result: Vec<String> = registry.values().flatten().cloned().collect();
    result.sort();
    result
}

GregGorin

23 days ago

4.50ms

91.67kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let vec: &mut Vec<String> = registry.entry(section.to_string()).or_insert(Vec::<String>::new());
    add_if_not_contains(vec,animal);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {   
    let mut vec = if registry.contains_key(section) {registry.get(section).unwrap().iter().cloned().collect::<Vec<String>>()} else {Vec::<String>::new()} ;
    vec.sort();
    vec   
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut vec = Vec::<String>::new();
    registry.values().for_each(|section_vec|{section_vec.iter().for_each(|animal|{add_if_not_contains(&mut vec,animal)})});
    vec.sort();
    vec
}
fn add_if_not_contains(vec:&mut Vec<String>,animal: &str) {
    let n_animal = animal.to_owned();       
    if !vec.contains(&n_animal) {
        vec.push(n_animal);
    }   
}

LeonardoPinheiro23

23 days ago

4.16ms

91.88kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
        // insert animal to section if section exists OR create new section with animal
        registry.entry(String::from(section))
            .and_modify(|section_animals| {
                let animal = String::from(animal);
                if !section_animals.contains(&animal) {
                    section_animals.push(animal)
                }
            })
            .or_insert_with(|| vec![String::from(animal)]);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    match registry.get(section) {
        Some(animals) => {
            let mut sorted_animals = animals.to_vec();
            sorted_animals.sort();
            sorted_animals
        },
        None => Vec::new(),
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let total_len = registry.values().map(|animals| animals.len()).sum();
    let mut all_animals_sorted = Vec::with_capacity(total_len);
    for animals in registry.values() {
        all_animals_sorted.extend(animals.iter().cloned());
    }
    all_animals_sorted.sort();
    all_animals_sorted
}

annececiledunand

24 days ago

5.18ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let current_section_animals: &mut Vec<String> = registry.entry(section.to_string()).or_default();
    
    if !current_section_animals.contains(&animal.to_string()) { 
        current_section_animals.push(animal.to_string());
    }
    
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut animals: Vec<String> = match registry.get(section) {
        Some(animal) => animal.to_vec(),
        None => Vec::new(),
    };
    
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut animals: Vec<String> = Vec::new();
    
    for (_key, value) in registry.iter() {
        animals.extend(value.clone());
    }
    
    animals.sort();
    animals
}

annececiledunand

24 days ago

4.18ms

90.94kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let empty_vec: Vec<String> = Vec::new();
    let mut current_section_animals: Vec<String> = registry.get(section).unwrap_or(&empty_vec).clone();
    
    if current_section_animals.contains(&animal.to_string()) { return; }
    
    current_section_animals.push(animal.to_string());
    registry.insert(section.to_string(), current_section_animals);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let empty_vec: Vec<String> = Vec::new();
    let mut animals: Vec<String> = registry.get(section).unwrap_or(&empty_vec).clone();
    
    animals.sort();
    animals.to_vec()
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut animals: Vec<String> = Vec::new();
    
    for (_key, value) in registry.iter() {
        for an_animal in value {
            animals.push(an_animal.to_string());
        }
    }
    
    animals.sort();
    animals
}

Tommytto

25 days ago

5.87ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let section_val = registry.entry(section.to_string()).or_insert(Vec::new());
    if !section_val.contains(&animal.to_string()) {
        section_val.push(animal.to_string())
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let section_val = registry.get(section).cloned().unwrap_or_default();
    let mut section_val = section_val.to_vec();
    section_val.sort();
    section_val
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut animals: Vec<String> = registry.values().flatten().cloned().collect();
    animals.sort();
    animals
}

Travis

ttmgraham

25 days ago

4.38ms

91.67kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let entry = registry.entry(section.to_string()).or_insert(vec![animal.to_string()]);
    if !entry.contains(&animal.to_string()){
        entry.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut results = match registry.get(section) {
        Some(animals) => animals.clone(),
        None => vec![]
    };
    results.sort();
    results
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut results = vec![];
    for (_, value) in registry{
        for animal in value{
            results.push(animal.to_string());
        }
    }
    results.sort();
    results
}

Erik Hollembeak

futureperfect

25 days ago

4.33ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_default();
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut result = match registry.get(section) {
        Some(animals) => animals.to_vec(),
        None => Vec::new(),
    };
    result.sort();
    result
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut result: Vec<String> = registry.values().flatten().cloned().collect();
    result.sort();
    result
}

Erik Hollembeak

futureperfect

25 days ago

4.63ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    let animals = registry.entry(section.to_string()).or_default();
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    let mut result = match registry.get(section) {
        Some(animals) => animals.to_vec(),
        None => Vec::new(),
    };
    result.sort();
    result
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut result: Vec<String> = registry.values().flatten().cloned().collect();
    result.sort();
    result
}

wry

Liudel

a month ago

7.23ms

90.94kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let entry = registry
        .entry(section.to_string())
        .or_insert(vec![animal.to_string()]);
    if !entry.contains(&animal.to_string()) {
        entry.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = vec![];
    match registry.get(&section.to_string()) {
        Some(e) => animals = e.to_vec(),
        None => (),
    }
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all = vec![];
    for (_, animals) in registry {
        all.append(&mut animals.to_vec());
    }
    all.sort();
    all
}

wry

Liudel

a month ago

5.63ms

90.94kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let entry = registry
        .entry(section.to_string())
        .or_insert(vec![animal.to_string()]);
    if !entry.contains(&animal.to_string()) {
        entry.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = vec![];
    match registry.get(&section.to_string()) {
        Some(e) => animals = e.to_vec(),
        None => (),
    }
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    let mut all = vec![];
    for (_, animals) in registry {
        all.append(&mut animals.to_vec());
    }
    all.sort();
    all
}

AshutoshKumarPatel

a month ago

4.03ms

90.56kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let animals = registry.entry(section.to_string()).or_insert(Vec::new());
    if !animals.contains(&animal.to_string()) {
        animals.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    if let Some(animals) = registry.get(section) {
        let mut sorted = animals.clone();
        sorted.sort();
        sorted
    } else {
        vec![]
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all_animals: Vec<String> = Vec::new();
    for (_, animals) in registry {
        all_animals.extend(animals.clone());
    }
    all_animals.sort();
    all_animals
}

Hendrik Dreesmann

DeemanOne

a month ago

4.78ms

91.93kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    registry.entry(section.to_string()).and_modify(|sec| {if !sec.contains(&animal.to_string()) {sec.push(animal.to_string());}}).or_insert(vec![animal.to_string()]);
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let ret = registry.get(section);
    match ret{
        Some(list) => { let mut list = list.clone(); list.sort(); return list;},
        None => return Vec::new()
    }
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut ret: Vec<String> =vec![];
    for list in registry.values(){
        for string in list {
            ret.push(string.clone());
        }
    }
    ret.sort();
    ret
}

sjmellor

a month ago

4.36ms

91.26kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    let entry = registry.entry(section.to_string()).or_insert(vec![animal.to_string()]);
    if !entry.contains(&animal.to_string()) {
        entry.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals = Vec::<String>::new();
    
    match registry.get(section) {
        Some(e) => animals = e.to_vec(),
        None => (),
    }
    animals.sort();
    animals
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut all = Vec::<String>::new();
    for (_, animals) in registry.iter() {
        all.append(&mut animals.to_vec());
    }
    
    all.sort();
    all
}

Ajit Kumar

urwithajit9

a month ago

4.32ms

92.12kb

use std::collections::HashMap;
type Collection = HashMap<String, Vec<String>>;
pub fn add_animal_to_section(animal: &str, section: &str, registry: &mut Collection) {
    // TODO: implement this function
    // Get the animal list for given section
    // Check if the given animal exist in the list
    // add new animal if not present
    let vec = registry.entry(section.to_string()).or_insert(Vec::new());
    if !vec.contains(&animal.to_string()) {
          vec.push(animal.to_string());
    }
}
pub fn get_animals_in_section(section: &str, registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals: Vec<String> = Vec::new();
    if let Some(value) = registry.get(section){
        animals = value.to_vec();
        animals.sort();
    }
    return animals;    
}
pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
    // TODO: implement this function
    let mut animals: Vec<String> = Vec::new();
    for (_section, animal_list) in registry.iter(){
        //animal_list.sort();
        // for animal in animal_list.iter(){
        //     animals.push(animal.to_string());
        // }
        animals.extend(animal_list.clone());
    }
    animals.sort();
    // animals.reverse();
    println!("{:?}",animals);
    animals
}
// pub fn get_all_animals_sorted(registry: &Collection) -> Vec<String> {
//     // TODO: implement this function
//     let mut all_animals: Vec<String> = Vec::new();
//     for (_, animals) in registry {
//         all_animals.extend(animals.clone());
//     }
//     all_animals.sort();
//     all_animals
// }