Unique Items

You now have a good understanding of iterators and closures and how they can be used to process collections of data.

In this challenge, you will use iterators to filter out duplicate items from a collection of potentially redundant entries.

Your Task

Define a function that takes a collection of items (as an iterator) and returns a collection of unique items in sorted order. The items are represented as strings. You are expected to handle duplicates and ignore entries that are empty or consist solely of whitespace.

Your function signature and return types must be determined by you, but the input must implement the Iterator trait, ensuring flexibility for different iterator sources.

Requirements

Filter duplicates: Ensure that the resulting collection contains only unique items.
Ignore invalid entries: Exclude entries that are empty or only consist of whitespace.
Sort the output: Return the items sorted in ascending lexicographical order.
Flexibility: The function should work with any iterator that has String, &String, or &str items.

Hints

Click here to reveal hints

Use trait bounds to ensure that the input iterator can provide items that can be converted to strings. e.g.

fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>,
{
    // Your code here
}

Use a HashSet to track unique items.
Use the filter_map method to remove invalid entries (e.g., empty or whitespace-only strings).
You can use the trim method on strings to handle whitespace effectively.
HashSet provides a method inesert that returns a bool indicating whether the item was already present.
To sort, you can convert to a Vec and call the sort method.

Editor not available on Mobile!

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

Solutions

reborn3d

5 days ago

4.16ms

89.48kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>,
{
    // Your code here
    let mut vector: Vec<String> = Vec::new();
    
    for item in items {
        let trimmed = item.as_ref().trim().to_string();
        if !trimmed.is_empty() && !vector.iter().any(|x| *x == trimmed){
            vector.push(trimmed.to_string())
        }
    }
        vector.sort();
        vector
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

5 days ago

4.16ms

89.55kb

use std::collections::BTreeSet;
pub fn _unique_items<T>(items: impl Iterator<Item = T>) -> Vec<String>
where
    T: AsRef<str>,
{
    let mut set = BTreeSet::new();
    items
        .filter_map(|id| {
            let id = id.as_ref().trim();
            if id.is_empty() {
                None
            } else {
                Some(id.to_string())
            }
        })
        .for_each(|id| {
            set.insert(id);
        });
    set.into_iter().collect()
}
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut items = items
        .filter_map(|id| {
            let id = id.as_ref().trim();
            if id.is_empty() {
                None
            } else {
                Some(id.to_string())
            }
        })
        .collect::<Vec<_>>();
    items.sort();
    items.dedup();
    items
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Omar Saber Talaat Abdelrahman

omar-s-ta

5 days ago

3.70ms

89.69kb

use std::collections::BTreeSet;
pub fn unique_items<T>(items: impl Iterator<Item = T>) -> Vec<String>
where
    T: AsRef<str>,
{
    let mut set = BTreeSet::new();
    items
        .filter_map(|id| {
            let id = id.as_ref().trim();
            if id.is_empty() {
                None
            } else {
                Some(id.to_string())
            }
        })
        .for_each(|id| {
            set.insert(id);
        });
    set.into_iter().collect()
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

SpontaneousOverthrow

7 days ago

4.91ms

89.78kb

// 1. Finish the function
use std::collections::HashSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>,
{
    let mut presented = HashSet::new();
    let mut a: Vec<String> = items
    .filter(|x| {
        let s = x.as_ref().trim();
        !s.is_empty() && presented.insert(s.to_string()) // insert returns true if new element
    })
    .map(|x| x.as_ref().trim().to_string())
    .collect::<Vec<String>>();
    a.sort();
    a
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

makinpaper

9 days ago

3.79ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut items = items
        .filter_map(|i| {
            let s = i.as_ref().trim();
            (!s.is_empty()).then(|| s.to_string())
        })
        .collect::<HashSet<_>>()
        .into_iter()
        .collect::<Vec<String>>();
    items.sort();
    items
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

<YoungAncient/>

youngancient

10 days ago

3.78ms

89.84kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I,T>(items: I) -> Vec<String>
where I: Iterator<Item = T>, T : AsRef<str>
{
    let mut items_store = HashSet::new();
    for item in items{
        let item_str = item.as_ref().trim();
        if !item_str.is_empty(){
            items_store.insert(item_str.to_string());
        }
    }
    let mut unique_ids:Vec<String> = items_store.into_iter().collect();
    unique_ids.sort();
    unique_ids
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Dan Wayne

danwayne-me

11 days ago

4.32ms

89.76kb

// 1. Finish the function
// pub fn unique_items ...
use std::collections::HashMap;
pub fn unique_items<T: AsRef<str>>(items: impl Iterator<Item = T>) -> Vec<String> {
    let non_empty = items
        .filter_map(|x| {
            let trimmed = x.as_ref().trim();
            if trimmed.is_empty() {
                None
            } else {
                Some(trimmed.to_string())
            }
        })
        .collect::<Vec<String>>();
    let mut set = std::collections::HashSet::new();
    for item in non_empty {
        set.insert(item);
    }
    let mut unique = set.into_iter().collect::<Vec<String>>();
    unique.sort();
    unique
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Asrul Firdaus

AsrulF

14 days ago

3.74ms

89.68kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where 
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let items = items.filter_map(|id| {
        let trimmed = id.as_ref().trim();
        if trimmed.is_empty() {
            None
        } else {
            Some(trimmed.to_string())
        }
    });
    let mut unique = std::collections::HashSet::new();
    
    for id in items {
        unique.insert(id);
    }
    let mut result = unique.iter().map(|id| id.to_string()).collect::<Vec<String>>();
    result.sort();
    result
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

kasaxpong

14 days ago

4.04ms

89.78kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
I: Iterator<Item = T>,
T: AsRef<str>,
{
    let mut set =  HashSet::new();
    let mut v: Vec<String> = items
        .filter_map(|x| {
            let trimmed = x.as_ref().trim();
            if !trimmed.is_empty() && set.insert(trimmed.to_string()) {
                Some(trimmed.into())
            } else {
                None
            }
            
        })
        .collect();
        v.sort();
        v
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Kishan

wdcs-kishansudani

18 days ago

5.11ms

89.78kb

use std::collections::HashSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut set = HashSet::new();
    let mut v: Vec<String> = items
        .filter_map(|x| {
            let trimmed = x.as_ref().trim();
            if !trimmed.is_empty() && set.insert(trimmed.to_string()) {
                Some(trimmed.into())
            } else {
                None
            }
        })
        .collect();
    v.sort();
    v
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

银雀Sparrxw

Sparr0www820

19 days ago

4.34ms

89.78kb

use std::collections::HashSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut set = HashSet::new();
    let mut v: Vec<String> = items
        .filter_map(|x| {
            let trimmed = x.as_ref().trim();
            if !trimmed.is_empty() && set.insert(trimmed.to_string()) {
                Some(trimmed.into())
            } else {
                None
            }
        })
        .collect();
    v.sort();
    v
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Dharm Singh

dharmvr1

20 days ago

4.76ms

89.78kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(product: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut set = HashSet::new();
    let mut new_vec: Vec<String> = product
        .filter_map(|p| {
            let trimmed = p.as_ref().trim();
            if !trimmed.is_empty() && set.insert(trimmed.to_string()) {
                Some(trimmed.to_string())
            } else {
                None
            }
        })
        .collect();
       new_vec.sort();
       new_vec
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Mykhailo Huzhvii

Ymkavi

23 days ago

5.71ms

89.78kb

use std::collections::HashSet;
pub fn unique_items<I>(iter: I) -> Vec<String> 
where
    I: Iterator,
    I::Item: AsRef<str>,
{
    let mut seen = HashSet::new();
    let mut item: Vec<String> = iter
    .map(|x| x.as_ref().trim().to_string())
    .filter_map(|x| seen.insert(x.clone()).then(|| x))
    .filter(|x| x.len() != 0)
    .collect();
    item.sort();
    item
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Yummy-Yums

a month ago

3.67ms

89.79kb

use std::collections::HashSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut unique_items = HashSet::new();
    let mut result: Vec<String> = items.filter_map(|item| {
        let item = item.as_ref().trim().to_string();
        if !item.is_empty() && unique_items.insert(item.clone()) {
            Some(item)
        } else {
            None
        }
    })
    .collect::<Vec<String>>();
    
    result.sort();
    result
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Ari Karim

arikarim

a month ago

4.27ms

89.82kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(iter: I) -> Vec<String>
    where
        I: Iterator<Item = T>,
        T: AsRef<str>,
 {
    let mut res = Vec::new();
    let mut map = std::collections::hash_set::HashSet::new();
    for i in iter {
        let current = i.as_ref().trim();
        let inserted = map.insert(current.to_string());
        if inserted && current != "" {
            res.push(current.to_string());
        }
    }
    res.sort();
    res
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Ari Karim

arikarim

a month ago

4.52ms

89.47kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(iter: I) -> Vec<String>
    where
        I: Iterator<Item = T>,
        T: AsRef<str> + PartialEq + std::cmp::PartialEq,
 {
    let mut res = Vec::new();
    for el in iter {
        let s = el.as_ref().trim();
        if !s.is_empty() && !res.contains(&s.to_string()) {
            res.push(s.to_string());
        }
    }
    res.sort();
    res
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Vincent SAMY

vsamy

a month ago

4.50ms

89.78kb

use std::collections::HashSet;
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where 
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut seen = HashSet::new();
    let mut v: Vec<String> = iter.filter_map(|s| {
        let trimmed = s.as_ref().trim();
        if !trimmed.is_empty() && seen.insert(trimmed.to_string()) {
            Some(trimmed.to_string())
        } else {
            None
        }
    })
    .collect();
    v.sort();
    v
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Jai

jsat97

a month ago

5.14ms

89.79kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(items: I) -> Vec<String> 
where
I: Iterator<Item = T>,
T: AsRef<str> + std::cmp::Eq + std::hash::Hash,
{
    let mut h = HashSet::new();
    let mut v =
    items
    .filter_map(|x| {
        let s = x.as_ref().trim().to_string();
        if !s.is_empty() && h.insert(s.clone()) {
            Some(s)
        } else {
            None
        }
    })
    .collect::<Vec<String>>();
    v.sort();
    v
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Abhishek Sharma

0xAbhiDev

a month ago

6.24ms

89.79kb

// 1. Finish the function
pub fn unique_items<I,T> (items:I)->Vec<String>
   where 
   I:Iterator<Item=T>,
   T:AsRef<str>,
   {
    let mut hashset=HashSet::new();
   let mut vec_string:Vec<String> = items.filter_map(|item| {let trimmed = item.as_ref().trim();
   if trimmed.is_empty(){
    None
   }
   else{
    Some(trimmed.to_string())
   }
   }).filter(move|value| hashset.insert(value.clone()))
   .collect();
    vec_string.sort();
    vec_string
   }
   
use std::collections::HashSet;
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Abhishek Sharma

0xAbhiDev

a month ago

5.26ms

89.79kb

// 1. Finish the function
pub fn unique_items<I,T> (items:I)->Vec<String>
   where 
   I:Iterator<Item=T>,
   T:AsRef<str>,
   {
    let mut hashset=HashSet::new();
   let mut vec_string:Vec<String> = items.filter_map(|item| {let trimmed = item.as_ref().trim();
   if trimmed.is_empty(){
    None
   }
   else{
    Some(trimmed.to_string())
   }
   }).filter(move|value| hashset.insert(value.clone()))
   .collect();
    vec_string.sort();
    vec_string
   }
   
use std::collections::HashSet;
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

QuJohan

a month ago

4.59ms

89.84kb

// 1. Finish the function
use std::collections::HashSet;
// pub fn unique_items ...
pub fn unique_items<T>(it: impl Iterator<Item=T>) -> Vec<String>
where 
    T: AsRef<str> + std::cmp::Eq + std::hash::Hash
{
    let mut set = HashSet::new();
    for e in it {
        let v = e.as_ref().trim();
        if !v.is_empty() {
            set.insert(v.to_string());
        }
    }
    let mut res: Vec<_> = set.into_iter().collect();
    res.sort();
    res
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

nojae15

a month ago

6.14ms

89.84kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I,T>(items: I) -> Vec<String>
where
    I : Iterator<Item = T>,
    T: AsRef<str> + std::cmp::Eq + std::hash::Hash,
{
    let mut hash = HashSet::new();
    let mut res = vec![];
    for i in items{
        let i = i.as_ref().trim();
        if !i.is_empty(){
            hash.insert(i.to_string());
        }
    }
    res = hash.into_iter().collect();
    res.sort();
    res
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

jfloresremar

a month ago

4.86ms

89.55kb

// 1. Finish the function
pub fn unique_items<I, S>(items: I) -> Vec<String>
where
    I: IntoIterator<Item = S>,
    S: AsRef<str>,
{
    let mut data: Vec<String> = items
        .into_iter()
        .filter_map(|item| {
            let item = item.as_ref().trim();
            if item.is_empty() {
                None
            } else {
                Some(item.to_string())
            }
        })
        // .filter(|item| !item.as_ref().trim().is_empty())
        // .map(|s| s.as_ref().trim().to_string())
        .collect();
    data.sort();
    data.dedup();
    data
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

jfloresremar

a month ago

4.72ms

89.55kb

// 1. Finish the function
pub fn unique_items<I, S>(items: I) -> Vec<String>
where
    I: IntoIterator<Item = S>,
    S: AsRef<str>,
{
    let mut data: Vec<String> = items
        .into_iter()
        .filter_map(|item| {
            let item = item.as_ref().trim();
            if item.is_empty() {
                None
            } else {
                Some(item.to_string())
            }
        })
        // .filter(|item| !item.as_ref().trim().is_empty())
        // .map(|s| s.as_ref().trim().to_string())
        .collect();
    data.sort();
    data.dedup();
    data
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

ghoti225

2 months ago

4.60ms

89.84kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<T>(items: impl Iterator<Item = T>) -> Vec<String> 
where
    T: AsRef<str>,
{
    // THE LONG WAY
    let mut hs = HashSet::new();
    for elem in items {
        let x = elem.as_ref().trim();
        let test = x.is_empty();
        if test == false {           
            hs.insert(x.to_string());
        }
    }
    let mut unique: Vec<String> = hs.into_iter().collect();
    unique.sort();
    unique
    // // A SHORTER WAY ??
    //  let unique = items
    //     .map(|item| item.as_ref().trim().to_string())
    //     .filter(|item| !item.is_empty())
    //     .collect::<HashSet<String>>();
    // let mut unique = unique.into_iter().collect::<Vec<String>>();
    // unique.sort();
    // unique
    
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Gurneet singh

GS-Jatt

2 months ago

4.27ms

89.47kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<T>(items: impl Iterator<Item = T>) -> Vec<String>
where
    T: AsRef<str>,
{
    let mut res = Vec::<String>::new();
    for item in items {
        let item = item.as_ref();
        let item = item.trim();
        if item.is_empty() {
            continue;
        }
        let item = item.to_string();
        if !res.contains(&item) {
            res.push(item);
        }
    }
    res.sort();
    res
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Omar

OmniKobra

2 months ago

3.88ms

89.68kb

use std::collections::HashSet;
use std::hash::Hash;
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str> + Eq + Hash,
{
    let unique = iter
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<HashSet<String>>();
    let mut unique = unique.into_iter().collect::<Vec<String>>();
    unique.sort();
    unique
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

jh4vision

2 months ago

3.99ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I,T>(iter:I ) ->Vec<String>
where
    I : Iterator<Item=T>,
    T : AsRef<str> 
{
    let unique_set:HashSet<String> = iter
        .filter_map(|s| {let s=s.as_ref().trim().to_string();
            if s.is_empty(){return None;}
            else {return Some(s);}} )
        .collect();
    let mut res:Vec<String> = unique_set.into_iter().collect();
    res.sort();
    res
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

TheJanzap

2 months ago

4.29ms

89.55kb

use std::ops::Not;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<Iter, T>(items: Iter) -> Vec<String>
where
    Iter: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut vec = items
        .filter_map(|item| item.as_ref().trim().is_empty().not().then(|| item.as_ref().trim().to_owned()))
        .collect::<Vec<_>>();
    vec.sort();
    vec.dedup();
    vec
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

shahab-tplus

2 months ago

3.65ms

89.55kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut set = iter.filter_map(|s| {
        let trimed = s.as_ref().trim();
        if trimed.is_empty() {
            None
        } else {
            Some(trimed.to_string())
        }
    }).collect::<Vec<String>>();
    set.sort();
    set.dedup();
    set
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Artem

artemnistuley

2 months ago

5.41ms

89.68kb

use std::collections::HashSet;
use std::hash::Hash;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where 
    I: Iterator<Item = T>,
    T: AsRef<str>
{
    let unique_items = items
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<HashSet<String>>();
    let mut unique = unique_items.into_iter().collect::<Vec<String>>();
    unique.sort();
    unique
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Christophe Mohimont

mohic

2 months ago

4.54ms

89.68kb

use std::collections::HashSet;
use std::hash::Hash;
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str> + Eq + Hash,
{
    let unique = iter
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<HashSet<String>>();
    let mut unique = unique.into_iter().collect::<Vec<String>>();
    unique.sort();
    unique
}

muemart

2 months ago

5.67ms

89.78kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>,
      {
    let mut seen = HashSet::new();
    let mut unique_ids = items
        .filter_map(|id| {
            let trimmed = id.as_ref().trim();
            if !trimmed.is_empty() && seen.insert(trimmed.to_string()) {
                Some(trimmed.to_string())
            } else {
                None
            }
        })
        .collect::<Vec<String>>();
    unique_ids.sort();
    unique_ids
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Smith, Taylor

a647965_fidelity

2 months ago

4.87ms

89.71kb

use std::collections::BTreeSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<'a, T>(items: impl Iterator<Item=T>) -> Vec<String>
where T: Ord + ToString {
    items
        .map(|item| item.to_string().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<BTreeSet<_>>()
        .into_iter()
        .collect::<Vec<_>>()
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Smith, Taylor

a647965_fidelity

2 months ago

5.46ms

89.55kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<'a, T>(items: impl Iterator<Item=T>) -> Vec<String>
where T: Ord + ToString {
    let mut vec = items
        .map(|item| item.to_string().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<Vec<_>>();
    vec.sort();
    vec.dedup();
    vec
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Smith, Taylor

a647965_fidelity

2 months ago

5.18ms

89.71kb

use std::collections::BTreeSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<'a, T>(items: impl Iterator<Item=T>) -> Vec<String>
where T: Ord + ToString {
    items
        .map(|item| item.to_string().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<BTreeSet<_>>()
        .into_iter()
        .collect::<Vec<_>>()
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

StevenCanDrink

2 months ago

4.09ms

89.82kb

use std::{ collections::HashMap, hash::Hash };
// 1. Finish the function
pub fn unique_items<T>(input: impl Iterator<Item = T>) -> Vec<String>
    where T: Clone + Hash + Eq + ToString + std::cmp::Ord
{
    let mut new_hash = HashMap::new();
    for string in input {
        let to_string: String = string.to_string().trim().to_string();
        if to_string.contains("\n") || to_string.contains("\t") || to_string.is_empty() {
            continue;
        }
        if !new_hash.contains_key(&to_string) {
            new_hash.insert(to_string, 1);
        }
    }
    let mut unique_vec: Vec<_> = new_hash.keys().cloned().collect();
    unique_vec.sort();
    unique_vec
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string()
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Chih Ying Yen

xavierforge

2 months ago

3.73ms

89.63kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(iter: I) -> Vec<String> 
where 
    I: Iterator<Item = T>,
    T: AsRef<str> 
{
    let mut filtered = iter.filter_map(|item| {
        // Use HashSet to track unique items as hints suggested
        let mut unique = HashSet::new();
        let trimmed = item.as_ref().trim();
        if !trimmed.is_empty() && unique.insert(trimmed)  {
            Some(trimmed.to_string())
        } else {
            None
        }
    }).collect::<Vec<String>>();
    filtered.sort();
    filtered.dedup(); 
    filtered
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Chih Ying Yen

xavierforge

2 months ago

4.14ms

89.55kb


// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(iter: I) -> Vec<String> 
where 
    I: Iterator<Item = T>,
    T: AsRef<str> 
{
    let mut filtered = iter.filter_map(|item| {
        let trimmed = item.as_ref().trim();
        if trimmed.is_empty() {
            None
        } else {
            Some(trimmed.to_string())
        }
    }).collect::<Vec<String>>();
    // Since dedup removes consecutive repeated elements in the vector
    // so sort should be done before dedup
    filtered.sort();
    filtered.dedup(); 
    filtered
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

amdfxlucas

2 months ago

3.78ms

89.55kb

use std::cmp::Ord;
use std::cmp::PartialEq;
 pub fn unique_items<T: AsRef<str>+ Ord + PartialEq>(iter: impl Iterator<Item = T>) -> Vec<String>
 {
    let mut res = iter.filter(|x|{ !x.as_ref().is_empty() && !x.as_ref().trim().is_empty() }).
    map(|x| x.as_ref().trim().to_string() )
    .collect::<Vec<String>>();
    res.sort();
    res.dedup();
    res
 }
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

GunGraveCpp

2 months ago

4.82ms

89.55kb


use core::convert::AsRef;
pub fn unique_items<'a, T>(mass: impl Iterator<Item = T>) -> Vec<String>
where
    T: AsRef<str>,
{
    let mut item = mass
        .map(|x| x.as_ref().trim().to_string())
        .filter(|x| x.len() != 0)
        .collect::<Vec<String>>();
    item.sort();
    item.dedup();
    item
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

undefeated_

boyboi86

3 months ago

4.42ms

89.55kb

// 1. Finish the function
pub fn unique_items<T: AsRef<str>, I: Iterator<Item = T>>(iter: I) -> Vec<String> {
    let mut items: Vec<String> = iter
        .filter_map(|s| {
            let trimmed = s.as_ref().trim();
            if trimmed.is_empty() {
                None
            } else {
                Some(trimmed.to_string())
            }
        })
        .collect();
    
    items.sort_unstable();
    items.dedup();
    items
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

undefeated_

boyboi86

3 months ago

3.82ms

89.55kb

// 1. Finish the function
pub fn unique_items<T: AsRef<str>, I:Iterator<Item=T>>(iter: I) -> Vec<String> {
    let mut iter: Vec<String> = iter.map(|s| s.as_ref().trim().to_string())
    .filter(|s| !s.is_empty())
    .collect::<Vec<_>>();
    
    iter.sort();
    iter.dedup();
    iter
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

toto

3 months ago

4.06ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    T: AsRef<str>,
    I: Iterator<Item = T>,
{
    let mut items = items
        .filter_map(|item| {
            let trimmed = item.as_ref().trim();
            match trimmed.is_empty() {
                true => None,
                false => Some(String::from(trimmed)),
            }
        })
        .collect::<HashSet<_>>()
        .into_iter()
        .collect::<Vec<_>>();
    items.sort();
    items
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

aghia98

3 months ago

3.97ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>,
{
    let mut v = items.filter_map(|item| {
        let trimmed = item.as_ref().trim();
        match trimmed.is_empty() {
            true => None,
            false => Some(String::from(trimmed))
        }
    }).collect::<HashSet<_>>().into_iter().collect::<Vec<_>>();
    v.sort();
    v
    
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

aghia98

3 months ago

4.21ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>,
{
    let mut v = items.filter_map(|item| {
        let trimmed = item.as_ref().trim();
        match trimmed.is_empty() {
            true => None,
            false => Some(String::from(trimmed))
        }
    }).collect::<HashSet<_>>().into_iter().collect::<Vec<_>>();
    v.sort();
    v
    
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

manu3618

3 months ago

4.62ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<'a, T: AsRef<str>>(it: impl Iterator<Item=T>) -> Vec<String>{
    let s = it.into_iter()
        .filter_map(|x| match String::from(x.as_ref()).trim(){ 
            "" => None,
            u => Some(String::from(u))
        })
        .collect::<HashSet<_>>();
    let mut v = s.iter().cloned().collect::<Vec<_>>();
    v.sort();
    v
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Lvfalue

3 months ago

3.89ms

89.78kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where I: Iterator<Item=T>,
      T: AsRef<str>,
{
    let mut seen = HashSet::new();
    let mut items = iter.filter_map(|v| {
        let tv = v.as_ref().trim();
        if tv.is_empty() || !seen.insert(tv.to_string()) {
            None
        } else {
            Some(tv.to_string())
        }
    }).collect::<Vec<String>>();
    items.sort();
    items
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

visanr

3 months ago

3.56ms

89.78kb

// 1. Finish the function
// pub fn unique_items ...
use std::collections::HashSet;
pub fn unique_items<I, T>(iter: I) -> Vec<String> 
where I: Iterator<Item=T>,
      T: AsRef<str>,
{
    let mut seen = HashSet::new();
    let mut unique = iter
        .filter_map(|v| {
            let tv = v.as_ref().trim();
            if tv.is_empty() || !seen.insert(tv.to_string()) {
                return None;
            }
            Some(tv.to_string())
        })
        .collect::<Vec<String>>();
    unique.sort();
    unique
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Luka Bračun

lbracun

3 months ago

3.81ms

89.55kb

// 1. Finish the function
pub fn unique_items<T: AsRef<str>, I: Iterator<Item = T>>(items: I) -> Vec<String> {
    let mut u_items: Vec<String> = items
        .map(|s| s.as_ref().trim().to_string())
        .filter(|s| !s.is_empty())
        .collect();
    u_items.sort();
    u_items.dedup();
    u_items
}
/// Example usage
pub fn main() {
    let product_ids = vec![
        "abc123".to_string(),
        "  ".to_string(),
        "def456".to_string(),
        "abc123".to_string(),
        "ghi789".to_string(),
        "ghi789".to_string(),
        "   def456".to_string(),
    ];
    let unique_ids = unique_items(product_ids.into_iter());
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}