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

Sander Boelhouwers

sander-b-postnl

2 hours ago

3.66ms

89.55kb

// 1. Finish the function
pub fn unique_items<T: AsRef<str>>(iter: impl Iterator<Item = T>) -> Vec<String> {
    let mut items: Vec<String> = iter
        .map(|x| x.as_ref().trim().to_string())
        .filter(|x| !x.is_empty())
        .collect();
    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"]);
}

Abeautifulsnow

8 hours ago

4.02ms

89.55kb

// 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 unique_items: Vec<String> = items
        .map(|x| x.as_ref().to_string().trim().to_string())
        .filter(|x| !x.is_empty())
        .collect();
    unique_items.sort();
    unique_items.dedup();
    unique_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"]);
}

Ugo VENTURE

Swymn

a day ago

4.14ms

89.51kb

// 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 unique: Vec<String> = Vec::new();
    for item in iter {
        let string = item.as_ref().trim().to_string();
        if !string.is_empty() && !unique.contains(&string.to_string()) {
            unique.push(string.to_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"]);
}

Atanas Krondev

AtanasKrondev

8 days ago

3.80ms

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 uniques = HashSet::new();
    items
        .filter_map(|i| {
            let trimmed = i.as_ref().trim();
            if trimmed.is_empty() {
                None
            } else {
                Some(trimmed.to_string())
            }
        })
        .for_each(|u| {
            uniques.insert(u);
        });
    let mut vec: Vec<String> = uniques.into_iter().collect();
    vec.sort();
    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"]);
}

zibuyu28

8 days ago

3.81ms

89.84kb

// 1. Finish the function
// pub fn unique_items ...
use std::collections::HashSet;
pub fn unique_items<T: AsRef<str>>(iter: impl Iterator<Item=T>) -> Vec<String> {
    let mut set:HashSet<String> = HashSet::new();
    let mut res:Vec<String> = iter.filter_map(move |item| {
        let a = item.as_ref().trim();
        if a == "" || set.contains(&a.to_string()) {
            return None
        }
        set.insert(a.to_string());
        Some(a.to_string())
    }).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"]);
}

Artyom Chebotarev

Derik117

11 days ago

3.80ms

89.84kb

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 uni: HashSet<String> = items
        .map(|s| s.as_ref().trim().to_string())
        .filter(|s| !s.is_empty())
        .collect();
    let mut res: Vec<String> = uni.iter().cloned().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"]);
}

mihaya

mihaya03

11 days ago

4.67ms

89.80kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, S>(items: I) -> Vec<String>
where
    I: IntoIterator<Item = S>,
    S: AsRef<str>,
{
    let mut seen = HashSet::new();
    let mut unique = Vec::new();
    for item in items {
        let trimmed = item.as_ref().trim();
        if !trimmed.is_empty() && seen.insert(trimmed.to_string()) {
            unique.push(trimmed.to_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"]);
}

jcarey9149

16 days ago

3.94ms

89.84kb

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 unique_set: HashSet<_> = iter
        .map(|s| s.as_ref().trim().to_string())
        .filter(|s| !s.is_empty())
        .collect();
    let mut retval: Vec<String> = unique_set.iter().cloned().collect();
    retval.sort();
    retval
}
// 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"]);
}

Marouan Boulahtouf

MBoulahtouf

18 days ago

3.47ms

89.48kb

// 1. Finish the function
pub fn unique_items<I, T>(items: I) -> Vec<String>
where 
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut unique: Vec<String> = Vec::new();
    for item in items {
        let s = item.as_ref().trim().to_string();
        if !s.is_empty() && !unique.iter().any(|x| *x == s){
            unique.push(s.to_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"]);
}

Ignat S.

Igonato

20 days ago

4.40ms

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 set: HashSet<String> = items
        .filter_map(|item| {
            let s = item.as_ref().trim().to_string();
            if s.is_empty() {
                return None;
            }
            Some(s)
        })
        .collect();
    let mut v: Vec<String> = set.into_iter().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"]);
}

Luiz Pinheiro

lgabriellp

21 days ago

4.92ms

89.71kb

use std::collections::BTreeSet;
// 1. Finish the function
pub fn unique_items<T>(iter: impl Iterator<Item=T>) -> Vec<String> 
where 
    T: AsRef<str> + Ord
{
    iter
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| item.len() > 0)
        .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"]);
}

Egu0

egu0

24 days ago

4.33ms

89.84kb

use std::collections::HashSet;
pub fn unique_items(items: impl Iterator<Item = impl AsRef<str>>) -> Vec<String>
{
    let mut set: HashSet<String> = HashSet::new();
    for i in items {
        let s = i.as_ref().trim().to_string();
        if s.is_empty() {
            continue;
        }
        set.insert(s);
    }
    let mut v = set.into_iter().collect::<Vec<String>>();
    v.sort();
    v
}

Egu0

egu0

24 days ago

4.24ms

89.84kb

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<String> = HashSet::new();
    for i in items {
        let s = i.as_ref().trim().to_string();
        if s.is_empty() {
            continue;
        }
        set.insert(s);
    }
    let mut v = set.into_iter().collect::<Vec<String>>();
    v.sort();
    v
}

azmahflameheart

24 days ago

6.60ms

89.71kb

use std::collections::BTreeSet;
// 1. Finish the function
pub fn unique_items<I, T>(items: I) -> Vec<String>
where 
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    items.map(|a| a.as_ref().trim().to_string())
        .filter(|a| !a.is_empty())
        .collect::<BTreeSet<_>>()
        .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"]);
}

LawisChen

a month ago

4.16ms

89.68kb

use std::collections::HashSet;
pub fn unique_items<'a>(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    let mut items = iter
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| item.len() > 0)
        .collect::<HashSet<_>>()
        .into_iter()
        .collect::<Vec<_>>();
    items.sort();
    return 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"]);
}

Snoweuph

snoweuph

a month ago

3.87ms

89.71kb

use std::collections::HashSet;
pub fn unique_items(items: impl Iterator<Item: AsRef<str>>) -> Vec<String> {
    let mut map = HashSet::new();
    let mut filtered: Vec<_> = items
        .filter_map(|item| {
            let item = item.as_ref().trim().to_string();
            if item.is_empty() || map.contains(&item) {
                return None;
            }
            map.insert(item.clone());
            Some(item)
        })
        .collect();
    filtered.sort();
    filtered
}

Yashwanth

Yash981

a month ago

4.31ms

89.80kb

use std::{collections::HashSet,hash::Hash};
// 1. Finish the function
pub fn unique_items<I,T>(items:I) -> Vec<String> 
where 
    I:Iterator<Item=T>,
    T:AsRef<str>+Eq+Hash,
{
    let unique:HashSet<_> = items.collect();
    let filtered:HashSet<String> = unique.into_iter().filter(|x| x.as_ref().trim().len()!=0).map(|y| y.as_ref().trim().to_string()).collect();
    let mut vec_values:Vec<_> = filtered.into_iter().collect();
    vec_values.sort();
    vec_values
}
/// 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"]);
}

vqk-2003

a month ago

5.08ms

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 result = iter.filter_map(|x| {
        let trimmed = x.as_ref().trim();
        if !trimmed.is_empty() {
            Some(trimmed.to_string())
        } else {
            None
        }
    }).collect::<HashSet<_>>();
    let mut result = result.into_iter().collect::<Vec<_>>();
    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"]);
}

ffrie

a month ago

3.56ms

89.68kb

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> + ToString + std::cmp::Eq + std::hash::Hash,
{
    let mut unique_ids = HashSet::<String>::from_iter(
        iter.map(|item| item.as_ref().trim().to_string())
        .filter(|item| !item.is_empty())
        ).into_iter().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"]);
}

reborn3d

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3 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

3 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

3 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

3 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

3 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"]);
}