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

StevenCanDrink

3 days ago

4.09ms

89.82kb

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

Chih Ying Yen

xavierforge

3 days ago

3.73ms

89.63kb

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

Chih Ying Yen

xavierforge

3 days ago

4.14ms

89.55kb


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

amdfxlucas

5 days ago

3.78ms

89.55kb

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

GunGraveCpp

6 days ago

4.82ms

89.55kb


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

undefeated_

boyboi86

9 days ago

4.42ms

89.55kb

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

undefeated_

boyboi86

9 days ago

3.82ms

89.55kb

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

toto

12 days ago

4.06ms

89.68kb

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

aghia98

12 days ago

3.97ms

89.68kb

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

aghia98

12 days ago

4.21ms

89.68kb

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

manu3618

13 days ago

4.62ms

89.68kb

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

Lvfalue

14 days ago

3.89ms

89.78kb

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

visanr

17 days ago

3.56ms

89.78kb

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

Luka Bračun

lbracun

22 days ago

3.81ms

89.55kb

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

bzdula

23 days ago

3.79ms

89.68kb

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

Wouter

WouterMartens

a month ago

4.79ms

89.78kb

use std::collections::HashSet;
pub fn unique_items<I, T>(product_ids: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut seen = HashSet::new();
    let mut unique_ids = product_ids
        .filter_map(|id| {
            let trimmed = id.as_ref().trim();
            if !trimmed.is_empty() && seen.insert(trimmed.to_string()) {
                Some(trimmed.to_string())
            } else {
                None
            }
        })
        .collect::<Vec<String>>();
    unique_ids.sort();
    unique_ids
}
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"]);
}

AtlasVakyrie

a month ago

4.12ms

89.55kb

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

Daniel Mestas

miel-codeai

a month ago

3.60ms

89.55kb

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

m1031

monorail103

a month ago

5.48ms

89.81kb

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 seen = HashSet::new();
    let mut result = Vec::new();
    for item in items {
        let s = item.as_ref().trim().to_string();
        if s.is_empty() {
            continue;
        }
        if seen.insert(s.clone()) {
            result.push(s);
        }
    }
    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"]);
}

Daniel Mestas

miel-codeai

a month ago

3.97ms

89.79kb

use std::collections::HashSet;
// 1. Finish the function
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    let mut seen_items: HashSet<String> = HashSet::new();
    let mut filtered_items: Vec<String> = items
        .filter_map(|item| {
            let trimmed_str = item.as_ref().trim();
            if trimmed_str.is_empty() {
                None
            } else {
                Some(trimmed_str.to_string())
            }
        })
        .filter(|s| seen_items.insert(s.clone()))
        .collect();
    filtered_items.sort();
    filtered_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"]);
}

Rocky.C

cloki0610

a month ago

4.13ms

89.78kb

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

slaws

a month ago

4.42ms

89.78kb

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

Baron Curtin

baroncurtin2

a month ago

4.17ms

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

Evrins Hu

evrins

a month ago

3.88ms

89.71kb

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

Heino Mortensen

hmortensen83

a month ago

3.30ms

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>,
{
    BTreeSet::from_iter(
        items
            .map(|x| x.as_ref().trim().to_string())
            .filter(|x| !x.is_empty()),
    )
    .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"]);
}

johndoe30bc

a month ago

4.57ms

89.71kb

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

johndoe30bc

a month ago

3.91ms

89.71kb

use std::collections::BTreeSet;
pub fn unique_items<I, T>(items: I) -> Vec<String>
where
    I: Iterator<Item = T>,
    T: AsRef<str>,
{
    BTreeSet::from_iter(
        items
            .map(|x| x.as_ref().trim().to_string())
            .filter(|x| !x.is_empty()),
    )
    .iter()
    .cloned()
    .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"]);
}

Cristian Prieto

cprieto

a month ago

4.40ms

89.52kb

// 1. Finish the function
pub fn unique_items<I>(iter: I) -> Vec<String>
where
    I: Iterator,
    I::Item: AsRef<str>,
{
    let mut found = Vec::with_capacity(iter.size_hint().0);
    iter.for_each(|item| {
        let trimmed = item.as_ref().trim().to_string();
        if !(trimmed.len() == 0 || found.contains(&trimmed)) {
            found.push(trimmed);
        }
    });
    found.sort();
    found
}
/// 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"]);
}

Cristian Prieto

cprieto

a month ago

5.10ms

89.52kb

// 1. Finish the function
pub fn unique_items<I>(iter: I) -> Vec<String>
where
    I: Iterator,
    I::Item: AsRef<str>,
{
    let mut found = Vec::with_capacity(iter.size_hint().0);
    iter.for_each(|item| {
        let trimmed = item.as_ref().trim().to_string();
        let is_empty = trimmed.len() == 0;
        let is_duplicate = found.contains(&trimmed);
        if !(is_empty || is_duplicate) {
            found.push(trimmed);
        }
    });
    found.sort();
    found
}
/// 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"]);
}

Cristian Prieto

cprieto

a month ago

5.06ms

89.50kb

// 1. Finish the function
pub fn unique_items<I>(iter: I) -> Vec<String>
where
    I: Iterator,
    I::Item: AsRef<str>,
{
    let mut found = Vec::with_capacity(iter.size_hint().0);
    iter.for_each(|item| {
        let trimmed = item.as_ref().trim();
        let is_empty = trimmed.len() == 0;
        let is_duplicate = found.contains(&trimmed.to_string());
        if !(is_empty || is_duplicate) {
            found.push(trimmed.to_string());
        }
    });
    found.sort();
    found
}
/// 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"]);
}

Cristian Prieto

cprieto

a month ago

4.85ms

89.84kb

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

Cristian Prieto

cprieto

a month ago

4.20ms

89.50kb

// 1. Finish the function
pub fn unique_items<I>(iter: I) -> Vec<String>
where
    I: Iterator,
    I::Item: AsRef<str>,
{
    let mut found = Vec::with_capacity(iter.size_hint().0);
    iter.for_each(|item| {
        let trimmed = item.as_ref().trim();
        let is_empty = trimmed.len() == 0;
        let is_duplicate = found.contains(&trimmed.to_string());
        if !(is_empty || is_duplicate) {
            found.push(trimmed.to_string());
        }
    });
    found.sort();
    found
}
/// 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"]);
}

xxxxsk

a month ago

6.42ms

89.69kb

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

medzernik

a month ago

4.71ms

89.55kb

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

FredoPo

a month ago

4.08ms

89.47kb

// 1. Finish the function
// pub fn unique_items ...
pub fn unique_items<I: Iterator<Item = T>, T: AsRef<str>>(iter: I) -> Vec<String> {
    let mut result: Vec<String> = vec![];
    iter.for_each(|val| if !result.contains(&val.as_ref().trim().to_string()) && val.as_ref().to_string().trim() != "" {result.push(val.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"]);
}

Evgenii Grigorenko

grevgeny

a month ago

4.90ms

89.55kb

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

Miguel Ángel Allende

maallende

a month ago

4.03ms

89.55kb

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

Procybit

a month ago

4.64ms

89.55kb

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

brucecox01

2 months ago

4.10ms

89.55kb

// 1. Finish the function
pub fn unique_items<T: AsRef<str>>(iter: impl Iterator<Item = T>) -> Vec<String> {
    let mut list = iter
        .map(|s| s.as_ref().trim().to_string())
        .filter(|s| !s.is_empty())
        .collect::<Vec<String>>();
    list.sort();
    list.chunk_by(|a, b| a == b).map(|a| a[0].clone()).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"]);
}

Krzysztof Atłasik

katlasik

2 months ago

4.39ms

89.55kb

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

Tengz Mao

MaoX-Yu

2 months ago

4.05ms

89.55kb

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

Philippe Massicotte

PMassicotte

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

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

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

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

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

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

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

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