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

Nguyen Vo Hoang Son

sonmessia

3 days ago

5.30ms

89.71kb

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

Health-Care-Movie

8 days ago

4.13ms

89.71kb

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

Splatrac

splatrac

8 days ago

8.54ms

89.47kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<T: AsRef<str>>(mut iter: impl Iterator<Item = T>) -> Vec<String> 
{
    let mut result: Vec<String> = Vec::new();
    while let Some(x) = iter.next() {
        if x.as_ref().trim().len() > 0 && !result.contains(&x.as_ref().trim().to_string()) {
            result.push(x.as_ref().trim().to_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"]);
}

Trịnh Chấn Duy

Duyyy123

12 days ago

4.85ms

89.67kb

use std::collections::BTreeSet;
// 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 map = BTreeSet::new();
    items.for_each(|s| {
        let trimmed = s.as_ref().trim();
        if !trimmed.is_empty() && map.get(trimmed).is_none() {
            map.insert(trimmed.to_string());
            Some(trimmed.to_string());
        }
    });
    map.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"]);
}

Liyqq

13 days ago

4.33ms

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.filter_map(|item| {
        let item = item.as_ref().trim();
        (!item.is_empty()).then(|| item.to_string())
    }).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"]);
}

Liyqq

13 days ago

7.15ms

89.78kb

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 unique_set = HashSet::new();
    let mut unique_vec: Vec<String> = items.filter_map(|item| {
        let item = item.as_ref().trim();
        (!item.is_empty() && unique_set.insert(item.to_string())).then(|| item.to_string())
    }).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"]);
}

Nathan GAUD

Natchica

18 days ago

4.21ms

89.71kb

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

shibu-t

21 days ago

4.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 filtered = items.filter_map(|item| {
        let item_str = item.as_ref().trim().to_string();
        if !item_str.is_empty() {
            Some(item_str)
        } else {
            None
        }
    });
    let mut set = HashSet::new();
    filtered.for_each(|item| {
        set.insert(item);
    });
    let mut ret = set.into_iter().collect::<Vec<String>>();
    ret.sort();
    return ret;
}
/// 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"]);
}

Assylbek Razakhbergenov

asylbek27

23 days ago

4.52ms

89.78kb

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> + ToString + std::cmp::Eq + std::hash::Hash
{
    let mut cache = HashSet::new();
    let mut result = items.filter(|x| {
        let trimmed = x.as_ref().trim().to_string();
        !trimmed.is_empty() && cache.insert(trimmed)
    })
    .map(|x| x.as_ref().trim().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"]);
}

mishbah

a month ago

4.78ms

89.69kb

use std::collections::HashSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut seen = HashSet::new();
    items.filter(|i| i.as_ref().trim().len() > 0).for_each(|i| {
        seen.insert(i.as_ref().trim().to_string());
    });
    let mut result = seen.into_iter().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"]);
}

Jason

Jason-fy-wang

a month ago

3.94ms

89.69kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<'a>(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    let mut uniq:HashSet<String> = HashSet::new();
    iter.filter(|it| {
        !it.as_ref().is_empty() && it.as_ref().trim().len() > 0
    }).for_each(|it| {
        uniq.insert(it.as_ref().trim().to_string());
    });
    
    let mut result: Vec<String> = uniq.into_iter().collect();
    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"]);
}

VerweyFr

a month ago

4.30ms

89.68kb


pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut unique_vec: Vec<_> = iter
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<std::collections::HashSet<_>>()
        .into_iter()
        .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"]);
}

vijayabhaskar badireddi

ptcte

a month ago

5.30ms

89.47kb

// 1. Finish the function
pub fn unique_items(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    let mut result = Vec::new();
    for item in iter {
        // if !item.is_empty() {
        let temp_temp = item.as_ref().trim().to_string();
        if !temp_temp.is_empty() && !result.contains(&temp_temp) {
            result.push(temp_temp);
        }
        // }
    }
    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"]);
}

Suresh Kumar

toddlers

a month ago

11.87ms

89.47kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String>{
    let mut result = Vec::new();
    for item in iter {
        // if !item.is_empty() {
        let temp_temp = item.as_ref().trim().to_string();
        if !temp_temp.is_empty() && !result.contains(&temp_temp) {
            result.push(temp_temp);
        }
        // }
    }
    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"]);
    // dbg!(unique_ids);
}

lugtester

a month ago

4.21ms

89.75kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(my_items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>
{
    let mut my_hashset: HashSet<&str>;
    let v: Vec<String> = my_items
      .filter_map(|x| if x.as_ref().trim().is_empty() {None} else {Some(x.as_ref().trim().to_string())} )
      .collect();
    let my_hashset: HashSet<String> = HashSet::from_iter(v.iter().cloned());
    let mut v: Vec<String> = my_hashset.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"]);
}

Jason

chenjie1219

a month ago

4.83ms

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 set = HashSet::new();
    let mut result: Vec<String> = items
        .filter_map(|item| {
            let trimmed = item.as_ref().trim();
            match trimmed {
                s if s.is_empty() => None,
                s => {
                    let string_value = s.to_string();
                    if set.insert(string_value.clone()) {
                        Some(string_value)
                    } else {
                        None
                    }
                }
            }
        })
        .collect();
    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"]);
}

Yixian Du

duyixian1234

2 months ago

7.62ms

89.47kb

// // 1. Finish the function
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut output = vec![];
    // iter.for_each(|item| {
    //     let candidate = item.as_ref().trim();
    //     if !candidate.is_empty() && !output.iter().any(|unique_item| unique_item == candidate) {
    //         output.push(candidate.to_string());
    //     }
    // });
    for item in iter {
        let candidate = item.as_ref().trim();
        if candidate.is_empty(){
            continue;
        }
        if !output.iter().any(|unique_item| unique_item == candidate) {
            output.push(candidate.to_string());
        }
    }
    output.sort();
    output
}
/// 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"]);
}

Aurimas Kuniutis

auriku

2 months ago

4.69ms

89.47kb

// // 1. Finish the function
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut output = vec![];
    // iter.for_each(|item| {
    //     let candidate = item.as_ref().trim();
    //     if !candidate.is_empty() && !output.iter().any(|unique_item| unique_item == candidate) {
    //         output.push(candidate.to_string());
    //     }
    // });
    for item in iter {
        let candidate = item.as_ref().trim();
        if candidate.is_empty(){
            continue;
        }
        if !output.iter().any(|unique_item| unique_item == candidate) {
            output.push(candidate.to_string());
        }
    }
    output.sort();
    output
}
/// 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"]);
}

Aurimas Kuniutis

auriku

2 months ago

5.59ms

89.47kb

// // 1. Finish the function
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut output = vec![];
    iter.for_each(|item| {
        let candidate = item.as_ref().trim();
        if !candidate.is_empty() && !output.iter().any(|unique_item| unique_item == candidate) {
            output.push(candidate.to_string());
        }
    });
    output.sort();
    output
}
/// 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

tich31337

2 months ago

8.71ms

89.79kb

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 v = HashSet::new();
    let mut res = iter.
        map(|x| x.as_ref().trim().to_string()).
        filter(|x| !x.is_empty()).
        filter(|x| v.insert(x.clone())).
        collect::<Vec<_>>();
    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"]);
}

Artem

tich31337

2 months ago

4.95ms

89.79kb

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 v = HashSet::new();
    let mut res = iter.
        map(|x| x.as_ref().trim().to_string()).
        filter(|x| !x.is_empty()).
        filter_map(|x| if v.insert(x.clone()) {Some(x)} else {None}).
        collect::<Vec<_>>();
    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"]);
}

Anna Komarova

Vlasanya

2 months ago

4.49ms

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 result: Vec<String> = items
        .filter_map(|item| {
            let trimmed = item.as_ref().trim();
            if trimmed.is_empty() {
                None
            } else if set.insert(trimmed.to_string()) {
                Some(trimmed.to_string())
            } else {
                None
            }
        })
        .collect();
    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"]);
}

AnKarl

Zythophilus

2 months ago

8.68ms

89.79kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<'a, T: AsRef<str> + 'a>(iter: impl Iterator<Item=T>) -> Vec<String> {
    let mut seen = HashSet::new();  
    let mut result: Vec<String> = iter.map(|x| x.as_ref().trim().to_string()).filter(|x| !x.is_empty() && seen.insert(x.clone())).collect();
    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"]);
}

Paulo Lins

pblins

2 months ago

5.38ms

89.78kb

pub fn unique_items<'a>(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    let mut h = std::collections::HashSet::new();
    let mut v: Vec<_> = iter
        .filter(|s| h.insert(s.as_ref().trim().to_string()) && !s.as_ref().trim().is_empty())
        .map(|s| s.as_ref().trim().to_string())
        .collect();
    v.sort_unstable();
    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"]);
}

Denis SOURON

Brack0

2 months ago

4.29ms

89.71kb

use std::collections::BTreeSet;
pub fn unique_items<T>(items: impl Iterator<Item = T>) -> Vec<String>
where
    T: AsRef<str>,
{
    items
        .map(|item| item.as_ref().trim().to_string())
        .filter(|item| !item.is_empty())
        .collect::<BTreeSet<String>>()
        .into_iter()
        .collect()
}

Icarus

IcarusxB

2 months ago

5.59ms

89.71kb

use std::collections::BTreeSet;
pub fn unique_items(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    iter.map(|s| s.as_ref().trim().to_string()) 
        .filter(|s| !s.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"]);
}

Icarus

IcarusxB

2 months ago

4.53ms

89.71kb

use std::collections::BTreeSet;
pub fn unique_items(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    iter.map(|s| s.as_ref().trim().to_string()) 
        .filter(|s| !s.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"]);
}

Hung Dinh

nhdinh

2 months ago

5.29ms

89.61kb

// 1. Finish the function
pub fn unique_items<T: AsRef<str>>(items: impl Iterator<Item = T>) -> Vec<String> {
    let mut unique = vec![];
    let mut seen = vec![];
    for item in items {
        let item_str = item.as_ref().trim().to_string();
        if item_str != "" {
            if !seen.contains(&item_str) {
                seen.push(item_str);
                unique.push(item.as_ref().trim().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"]);
}

Matthew Li

circles-png

2 months ago

3.84ms

89.47kb

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

Zeiion

2 months ago

4.35ms

89.59kb

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 ls: Vec<String> = items.map(|x| x.as_ref().trim().to_string()).collect::<HashSet<_>>().into_iter().collect();
    ls.retain(|x| !x.is_empty());
    ls.sort();
    ls
}
/// 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"]);
}

Guilherme Cesário Strachan

strachan

2 months ago

5.72ms

89.59kb

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

Viktor Merkurev

fennr

3 months ago

4.51ms

89.68kb

// 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 lst: Vec<String> = items
        .map(|item| item
            .as_ref()
            .trim()
            .to_string())
        .filter(|item| !item.is_empty())
        .collect::<HashSet<_>>()
        .into_iter()
        .collect();
    lst.sort();
    lst
}
/// 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"]);
}

Romain Grimau

Herrgrim0

3 months ago

4.60ms

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 unique: Vec<String> = 
        items.map(|item| item.as_ref().trim().to_string())
             .filter(|item| !item.is_empty())
             .collect::<HashSet<_>>()
             .into_iter()
             .collect();
    
    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"]);
}

Kentaro Abe

abekem

3 months ago

4.00ms

89.68kb

use std::collections::HashSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut list: Vec<String> = items
        .map(|i| i.as_ref().trim().to_string())
        .filter(|i| !i.is_empty())
        .collect::<HashSet<_>>()
        .into_iter()
        .collect();
    list.sort();
    list
}
/// 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"]);
}

Anıl Şenay

anilsenay

3 months ago

5.13ms

89.68kb

use std::{collections::HashSet, hash::Hash};
// 1. Finish the function
pub fn unique_items<T: AsRef<str> + Eq + Hash>(iter: impl Iterator<Item = T>) -> Vec<String> {
 let mut result: Vec<String> = iter
        .filter_map(|x| {
            let trimmed = x.as_ref().trim();
            if trimmed.is_empty() {
                None
            } else {
                Some(trimmed.to_string())
            }
        })
        .collect::<HashSet<_>>()
        .into_iter()
        .collect();
    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"]);
}

amaneru

7ma8no9

3 months ago

4.41ms

89.55kb

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

AKA.MoneyTaker

M4Bo2

3 months ago

4.61ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(item: I) -> Vec<String>
where 
    I :  Iterator<Item = T >, 
    T :  AsRef<str> {
    let set: HashSet<String> = item.filter_map(|element|{
        let element_str = element.as_ref().trim();
        if !element_str.is_empty() {Some(element_str.to_string())}
        else {None}
        })
        .collect();
    
    let mut new_vec: Vec<String> = set.into_iter().collect();
    new_vec.sort();
    new_vec
    }
// 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.
/// 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"]);
}

Manuel Manjarres R.

manuelmj

3 months ago

4.98ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(item: I) -> Vec<String>
where 
    I :  Iterator<Item = T >, 
    T :  AsRef<str> {
    let set: HashSet<String> = item.filter_map(|element|{
        let element_str = element.as_ref().trim();
        if !element_str.is_empty() {Some(element_str.to_string())}
        else {None}
        })
        .collect();
    
    let mut new_vec: Vec<String> = set.into_iter().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"]);
}

automata-studio

3 months ago

4.22ms

89.68kb

// 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 result: Vec<_> = iter.map(|item| item.as_ref().trim().to_string())
    .filter(|item| !item.is_empty())
    .collect::<HashSet<String>>()
    .into_iter()
    .collect();
    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"]);
}

Dyaa Adel

dyaa-adel

3 months ago

11.91ms

89.68kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<T : Eq + std::hash::Hash + AsRef<str>>(iter : impl Iterator<Item = T>) -> Vec<String> {
    let mut seen = iter
    .map(|item| item.as_ref().trim().to_string())
    .filter(|item| !item.is_empty())
    .collect::<HashSet<String>>()
    .into_iter()
    .collect::<Vec<String>>();
    seen.sort();
    seen
}
/// 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"]);
}

Ayushman Rathore

Spartan09

3 months ago

10.51ms

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

Marco-Normal

3 months ago

4.05ms

89.59kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, R>(item: I) -> Vec<String>
    where
         I: Iterator<Item=R>,
         R: AsRef<str>
         {
                let mut normalized: Vec<String> = item.into_iter()
        .map(|item| item.as_ref().trim().to_string())
        .collect::<HashSet<String>>().into_iter().collect();
    normalized.retain(|item| !item.is_empty());
    normalized.sort();
    normalized
         }
/// 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"]);
}

ludovicknecht

3 months ago

3.97ms

89.70kb

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 set = HashSet::<String>::new();
    for item in iter {
        let trimmed_item = &item.as_ref().trim();
        if *trimmed_item != "" {
            set.insert(trimmed_item.to_string());
        }   
    }
    let mut vec = set.into_iter().collect::<Vec<String>>();
    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"]);
}

Jun Huang

leemars

3 months ago

4.26ms

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

Algorab

3 months ago

4.29ms

89.59kb

use std::collections::HashSet;
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I, T>(list: I) -> Vec<String>
where I: Iterator<Item=T>,
      T: AsRef<str>
{
    let mut normalized: Vec<String> = list.into_iter()
        .map(|item| item.as_ref().trim().to_string())
        .collect::<HashSet<String>>().into_iter().collect();
    normalized.retain(|item| !item.is_empty());
    normalized.sort();
    normalized
}
/// 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"]);
}

iamforgettable

3 months ago

4.20ms

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 set: HashSet<String> = HashSet::new();
    for item in items {
        let s = item.as_ref().trim().to_string();
        if s.is_empty() 
            || s.chars().all(|c| c == ' ') {
            continue;
        }
        if !set.contains(&s) {
            set.insert(s);
        }
    }
    
    // Convert set to vec
    let mut v: Vec<String> = set.drain().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"]);
}

Jordan

Jordan-Haidee

3 months ago

4.78ms

89.76kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<T>(iter: impl Iterator<Item = T>) -> Vec<String>
where 
    T : AsRef<str>
{
    let preprocessed: Vec<String> = iter.map(|s| s.as_ref().trim().to_string()).filter(|s|!s.is_empty()).collect();
    let mut set: HashSet<String> = HashSet::new();
    for e in preprocessed {
        set.insert(e);
    }
    let mut res: Vec<String> = set.into_iter().collect();
    res.sort();
    // println!("{:?}", res);
    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 x = product_ids.into_iter();
    let unique_ids = unique_items(x);
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Jordan

Jordan-Haidee

3 months ago

4.12ms

89.76kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<T>(iter: impl Iterator<Item = T>) -> Vec<String>
where 
    T : AsRef<str>
{
    let preprocessed: Vec<String> = iter.map(|s| s.as_ref().trim().to_string()).filter(|s|!s.is_empty()).collect();
    let mut set: HashSet<String> = HashSet::new();
    for e in preprocessed {
        set.insert(e);
    }
    let mut res: Vec<String> = set.into_iter().collect();
    res.sort();
    // println!("{:?}", res);
    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 x = product_ids.into_iter();
    let unique_ids = unique_items(x);
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Jordan

Jordan-Haidee

3 months ago

4.26ms

89.76kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<T>(iter: impl Iterator<Item = T>) -> Vec<String>
where 
    T : AsRef<str> + std::cmp::Eq + std::hash::Hash + Clone + Ord
{
    let preprocessed: Vec<String> = iter.map(|s| s.as_ref().trim().to_string()).filter(|s|!s.is_empty()).collect();
    let mut set: HashSet<String> = HashSet::new();
    for e in preprocessed {
        set.insert(e);
    }
    let mut res: Vec<String> = set.into_iter().collect();
    res.sort();
    // println!("{:?}", res);
    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 x = product_ids.into_iter();
    let unique_ids = unique_items(x);
    assert_eq!(unique_ids, vec!["abc123", "def456", "ghi789"]);
}

Nikita Smirnov

Nismirno

3 months ago

3.74ms

89.70kb

use std::{collections::HashSet, ops::Deref};
// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    let mut found: HashSet<String> = HashSet::new();
    let mut result = iter
        .map(|s| s.as_ref().trim().to_string())
        .filter(|s| {
            if s.is_empty() {
                return false;
            }
            if found.contains(s) {
                return false;
            }
            found.insert(s.to_string());
            true
        })
        .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"]);
}