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

Philippe Massicotte

PMassicotte

20 hours ago

4.96ms

89.84kb

// 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>,
{
    // add code here
    let mut hs = HashSet::new();
    for item in items {
        let trimmed = item.as_ref().trim();
        if !trimmed.is_empty() {
            hs.insert(trimmed.to_string());
        }
    }
    let mut v: Vec<String> = hs.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"]);
}

Kr0wZ

2 days ago

4.03ms

89.55kb

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

Ushakov Andrey

stdstring

4 days ago

4.35ms

89.55kb

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

Herman effendi

hrmneffdii

4 days ago

4.29ms

89.55kb

/// Example usage
pub fn unique_items<T>(iter : impl Iterator<Item = T>) -> Vec<String> 
where 
    T : AsRef<str>,
{
    let mut v = iter
        .map(|e| e.as_ref().trim().to_string())
        .filter(|e| !e.is_empty())
        .collect::<Vec<_>>();
    v.sort();
    v.dedup();
    return 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"]);
}

vanos001

5 days ago

4.52ms

89.55kb

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

alexsavio

6 days ago

4.03ms

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 unique = items
        .map(|s| s.as_ref().trim().to_owned())
        .filter(|s| !s.is_empty())
        .collect::<HashSet<String>>();
    let mut sorted = Vec::from_iter(unique.into_iter());
    sorted.sort();
    sorted
    // let mut all = items
    //     .map(|s| s.as_ref().trim().to_owned())
    //     .filter(|s| !s.is_empty())
    //     .collect::<Vec<String>>();
    // all.sort();
    // all.dedup();
    // all
}
/// 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"]);
}

Prafful

iamsahu

6 days ago

3.78ms

89.55kb

// 1. Finish the function
pub fn unique_items<S>(input: impl Iterator<Item = S>) -> Vec<String>
where S : AsRef<str>
{
    
    let mut st = input.map(|s| s.as_ref().trim().to_owned())
        .filter(|s| !s.is_empty())
        .collect::<Vec<String>>();
    st.sort();
    st.dedup();
    st
}
/// 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"]);
}

0x0f1

Paul4673

6 days ago

3.99ms

89.55kb

pub fn unique_items<S>(iter : impl Iterator<Item = S>) -> Vec<String> 
where S : AsRef<str> {
    let mut st = iter.map(|s| s.as_ref().trim().to_owned())
        .filter(|s| !s.is_empty())
        .collect::<Vec<String>>();
    st.sort();
    st.dedup();
    st
}
/// 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"]);
}

Enes

enesscevik

10 days ago

4.51ms

89.55kb

// 1. Finish the function
pub fn unique_items<'a, S>(iter: impl Iterator<Item = S>) -> Vec<String>
where S: AsRef<str> {
    let mut strs: Vec<String> = iter
        .map(|st| st.as_ref().trim().to_owned())
        .filter(|st| !st.is_empty())
        .collect(); 
    strs.sort_unstable();
    strs.dedup();
    strs
}
/// 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"]);
}

whhc

12 days ago

4.07ms

89.55kb

pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    // let mut set: HashSet<String> = HashSet::new();
    // iter.for_each(|s| {
    //     let s2 = s.as_ref().trim();
    //     if !set.contains(s2) && !s2.is_empty() {
    //         set.insert(s2.to_string());
    //     }
    // });
    // let mut v = set.into_iter().collect::<Vec<String>>();
    // v.sort();
    // v
    let mut strings: Vec<String> = iter
        .map(|s| s.as_ref().trim().to_owned())
        .filter(|s| !s.is_empty())
        .collect();
    strings.sort_unstable();
    strings.dedup();
    strings
}
/// 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"]);
}

whhc

12 days ago

5.77ms

89.73kb

use std::collections::HashSet;
pub fn unique_items<I, T>(iter: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut set: HashSet<String> = HashSet::new();
    iter.for_each(|s| {
        let s2 = s.as_ref().trim();
        if !set.contains(s2) && !s2.is_empty() {
            set.insert(s2.to_string());
        }
    });
    let mut v = set.into_iter().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"]);
}

Luigi Terrone

LuigiTer

13 days ago

4.22ms

89.80kb

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

Maintain

duonghb53

17 days ago

5.09ms

89.80kb

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

ikatlinsky

18 days ago

5.40ms

89.80kb

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

diucicd

19 days ago

4.02ms

89.66kb

// 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 = std::collections::BTreeSet::new();
    for item in iter {
        let cur = item.as_ref().trim().to_string();
        if cur == "" {
            continue;
        }
        set.insert(cur);
    }
    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"]);
}

Seth Wood

seth-wood

20 days ago

4.88ms

89.80kb

// 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 = Vec::new();
    let mut seen = std::collections::HashSet::new();
    //Use the iterator here
    for item in items {
        let trimmed = item.as_ref().trim();
        if !trimmed.is_empty() && !seen.contains(trimmed) {
            seen.insert(trimmed.to_string());
            unique_items.push(trimmed.to_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"]);
}

Sergey Matyash

matiaspub

24 days ago

5.21ms

89.68kb

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

LeonardoPinheiro23

a month ago

4.50ms

89.55kb

// 1. Finish the function
pub fn unique_items<'a, S>(iter: impl Iterator<Item = S>) -> Vec<String>
where S: AsRef<str> {
    let mut strings: Vec<String> = iter
        .map(|string| string.as_ref().trim().to_owned())
        .filter(|string| !string.is_empty())
        .collect(); 
    strings.sort_unstable();
    strings.dedup();
    strings
}
/// 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"]);
}

Tommytto

a month ago

4.07ms

89.68kb

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

sjmellor

a month ago

4.31ms

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

Nicolai

Posmac

a month ago

4.59ms

89.84kb


use std::{collections::HashSet, hash::Hash};
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
      I: Iterator<Item = T>,
      T: AsRef<str>, 
      T: Eq,
      T: Hash,
      T: Clone
{
    let mut unique_strings = HashSet::new();
    for item in items {
        let trimmed = item.as_ref().trim();
        if trimmed.is_empty() {
            continue;
        }
        unique_strings.insert(trimmed.to_string());
    }
    let mut result: Vec<String> = unique_strings.into_iter().collect();
    result.sort();
    return result;
}
// 1. Finish the function
// pub fn 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"]);
}

ggnne

a month ago

6.34ms

89.68kb

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

Elizabeth Doughty

Thymelizabeth

a month ago

4.85ms

89.68kb

// 1. Finish the function
pub fn unique_items(iter: impl Iterator<Item = impl AsRef<str>>) -> Vec<String> {
    let mut result = iter.filter_map(|item| (!item.as_ref().trim().is_empty()).then_some(item.as_ref().trim().to_string())).collect::<std::collections::HashSet<_>>().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"]);
}

Nguyen Vo Hoang Son

sonmessia

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

3 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

3 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

3 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

3 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

3 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

3 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

3 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

4 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

4 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

4 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

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