Returning impl Trait

Rust's impl Trait syntax allows for concise and flexible code, especially when returning iterators or other complex types. By using impl Trait, you can abstract away concrete types while ensuring optimal performance through Rust's zero-cost abstractions.

In this challenge, you will implement a function that filters strings from a slice, returning only those that start with a given keyword. The function will return an iterator over the filtered results. This approach demonstrates how to combine Rust's iterator combinators with the impl Trait syntax.

Your Task

Write a function named filter_starts_with that:

Accepts two arguments:
- A slice of String
- A &str keyword
Returns an iterator that filters and yields only the strings starting with the given keyword.

Hints

Click here to reveal hints

Use .iter() to iterate over references to the strings in the slice.
The filter method takes a closure to apply a filtering condition.
Use the starts_with method to check if a string starts with a keyword.
Use move in the closure to capture the keyword.

Editor not available on Mobile!

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

Solutions

Snoweuph

snoweuph

21 minutes ago

3.66ms

88.14kb

pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice
        .iter()
        .filter(move |item| item.starts_with(&keyword.to_string()))
}

Snoweuph

snoweuph

22 minutes ago

4.12ms

87.51kb

pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'static str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |item| {
        let y = keyword.to_string();
        item.starts_with(&y)
    })
}

Snoweuph

snoweuph

22 minutes ago

4.43ms

87.51kb

pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'static str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |item| item.starts_with(&keyword.to_string()))
}

Snoweuph

snoweuph

23 minutes ago

3.38ms

87.96kb

pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'static str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |item| item.starts_with(keyword))
}

Snoweuph

snoweuph

24 minutes ago

3.07ms

87.96kb

pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |item| item.starts_with(keyword))
}

azmahflameheart

21 hours ago

4.00ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(fruits: &'a [String], pattern: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    fruits.iter().filter(move|fruit| fruit.starts_with(pattern))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Marouan Boulahtouf

MBoulahtouf

a day ago

3.54ms

87.96kb

pub fn filter_starts_with<'a>(input: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    input.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

ffrie

3 days ago

4.47ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a [String], key: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |s| s.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Ramon Silva

rsilva1

3 days ago

3.40ms

87.96kb

use std::slice::Iter;
// Finish the function
pub fn filter_starts_with<'a>(slice: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |word| word.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

vqk-2003

4 days ago

3.60ms

87.51kb

// Finish the function
pub fn filter_starts_with<'a>(inputs: &'a [String], start_str: &'static str) -> impl Iterator<Item = &'a String> {
    inputs.iter().filter(|input| {
        let start_str = start_str.to_string();
        input.starts_with(&start_str)
    })
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

vqk-2003

4 days ago

3.25ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(inputs: &'a [String], start_str: &'static str) -> impl Iterator<Item = &'a String> {
    inputs.iter().filter(move |input| input.starts_with(start_str))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

LawisChen

5 days ago

4.15ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |word| word.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

ychanghe

8 days ago

3.22ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slicee: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slicee.iter().filter(move |i| i.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

makinpaper

9 days ago

3.15ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    input: &'a Vec<String>,
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |i| i.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

<YoungAncient/>

youngancient

11 days ago

3.34ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice : &'a Vec<String>, key : &'a str) -> impl Iterator<Item = &'a String>{
    slice.iter().filter(move |word| word.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

4.20ms

87.51kb

pub fn filter_starts_with<'a>(
    input: &'a [String],
    keyword: &str,
) -> impl Iterator<Item = &'a String> {
    let prefix = keyword.to_string();
    input.iter().filter(move |arg| arg.starts_with(&prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Omar Saber Talaat Abdelrahman

omar-s-ta

11 days ago

3.99ms

87.96kb

pub fn filter_starts_with<'a>(
    input: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a std::string::String> {
    input.iter().filter(move |arg| arg.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Dan Wayne

danwayne-me

11 days ago

3.31ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(list: &'a [String], key: &'a str) -> impl Iterator<Item = &'a String> + 'a{
    list.iter().filter(move |item| item.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Ignat S.

Igonato

12 days ago

3.75ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice : &'a [String], keyword : &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |string| string.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

SpontaneousOverthrow

13 days ago

4.07ms

87.96kb

// Finish the function
// Finish the function
pub fn filter_starts_with<'a>(s: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    let iter = s.iter();
    let filtered_iter = iter.filter(move |word| word.starts_with(keyword));
    filtered_iter
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

MöNir

Monir-Ruet

18 days ago

3.88ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strs: &'a [String], pat: &'a str) -> impl Iterator<Item = &'a String> {
    strs.iter().filter(move |s| s.starts_with(pat))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Dimas Avrian Fachriza

FForFachriza

18 days ago

4.65ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    let iter = s.iter();
    let filtered_iter = iter.filter(move |word| word.starts_with(keyword));
    filtered_iter
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Asrul Firdaus

AsrulF

20 days ago

5.08ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(words: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    words
        .iter()
        .filter(move |word| word.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Dharm Singh

dharmvr1

21 days ago

12.08ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s:&'a Vec<String>,k:&'a str) -> impl Iterator<Item = &'a String>{
    let output = s.iter().filter(move |x|{
        x.starts_with(k)
    });
    return output;
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

kasaxpong

21 days ago

3.56ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(ve: &'a[String], st: &'a str) -> impl Iterator<Item = &'a  String> + 'a {
    ve.iter().filter(move |x| x.starts_with(st))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Kishan

wdcs-kishansudani

22 days ago

4.05ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(ve:  &'a [String], st: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    ve.iter().filter(move |x| x.starts_with(st))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Dr. Frederik Lauber

FrederikLauber

23 days ago

3.34ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a { 
    slice.iter().filter(move |&single_string| {single_string.starts_with(keyword)})
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Mykhailo Huzhvii

Ymkavi

24 days ago

3.44ms

87.96kb

pub fn filter_starts_with<'a>(text: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    text.iter().filter(move |&elem| {
        elem.starts_with(keyword)
    })
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

银雀Sparrxw

Sparr0www820

a month ago

3.61ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    s.iter().filter(move |&elem| elem.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

/sam

samging

a month ago

3.91ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    s:&'a[String], 
    pattern:&'a str,
    ) -> impl Iterator<Item = &'a String> {
    let res = s.iter().filter(move |&element| element.starts_with(pattern));
    res
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Yashwanth

Yash981

a month ago

3.31ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s:&'a[String],pattern:&'a str)-> impl Iterator<Item=&'a String> {
    let res = s.iter().filter(move |&element| {
        element.starts_with(pattern)
    });
    res
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Ari Karim

arikarim

a month ago

4.36ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a [String], pat: &'a str) -> impl Iterator<Item= &'a String> + 'a {
    let res= slice.iter().filter(move |&el| {
        el.starts_with(pat)
    });
    res
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Yummy-Yums

a month ago

3.43ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    b: &'a [String],
    a: &'a str
) -> impl Iterator<Item=&'a String> {
    b.iter().filter(move |s| s.starts_with(a))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

SubZ69

a month ago

8.47ms

87.96kb

pub fn filter_starts_with<'a>(input: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

xexid84

a month ago

4.22ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a[String], keyword: &'a str) -> impl Iterator<Item=&'a String>
{
    strings.iter().filter(move |item| {item.starts_with(keyword)})
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

xexid84

a month ago

5.13ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a[String], keyword: &'a str) -> impl Iterator<Item=&'a String>
{
    strings.iter().filter(move |item: &&'a String| {item.starts_with(keyword)})
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Vincent SAMY

vsamy

a month ago

4.66ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a [String], key: &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |s| s.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

reborn3d

a month ago

4.59ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice : &'a [String], keyword : &'a str) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |string| string.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Abhishek Sharma

0xAbhiDev

a month ago

3.85ms

87.96kb

// Finish the function 
pub fn filter_starts_with <'a> (input:&'a[String] ,key:&'a str)->impl Iterator<Item = &'a String>{
  input.iter().filter(move |n| n.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

jfloresremar

a month ago

3.48ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    slice: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    slice.iter().filter(move |item| item.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

nojae15

a month ago

3.19ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input :&'a [String], keyword:&'a str)->impl Iterator<Item = &'a String> {
    input.iter().filter(move |s| s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Francisco Alejandro

francisco-alejandro

2 months ago

3.59ms

87.51kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a [String], keyword: & str) -> impl Iterator<Item = &'a String> {
    let preffix: String = keyword.into();
    input.iter().filter(move |val| val.starts_with(&preffix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Francisco Alejandro

francisco-alejandro

2 months ago

3.44ms

87.51kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a [String], keyword: & str) -> impl Iterator<Item = &'a String> {
    let preffix: String = keyword.into();
    input.iter().filter(move |val| val.starts_with(&preffix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

QuJohan

2 months ago

4.75ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(v: &'a [String], filter: &'a str) -> impl Iterator<Item = &'a String> {
    v.iter().filter(move |s| s.starts_with(filter))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

wytsier

2 months ago

3.75ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input_strings: &'a Vec<String>, prefix: &'a str) -> impl Iterator<Item = &'a String> {
    input_strings.iter().filter(move |s| s.starts_with(prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

ghoti225

2 months ago

3.43ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strvec: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> {
    strvec.iter().filter(move |x| x.starts_with(key))
}
///// OK ANS
/*
// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a{
    input.iter().filter(move |s|s.starts_with(keyword))
}
*/
///// BEST ANS -- USE HEAP
/*
// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, string: &'a str) -> Box<impl Iterator<Item = &'a String>> {
    Box::new(slice.iter().filter(move |item| item.starts_with(string)))
}
*/
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Omar

OmniKobra

2 months ago

3.53ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> + 'a{
    input.iter().filter(move |s|s.starts_with(keyword))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Yamami

Yamami1221

2 months ago

4.79ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(l: &'a [String], p: &'a str) -> impl Iterator<Item = &'a String> {
    l.iter().filter(move |s| s.starts_with(p))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

Abdul

aisiyoup

2 months ago

3.32ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String> + 'a{
    input.iter().filter(move |s| s.starts_with(key))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

kaazzziii

2 months ago

3.19ms

87.51kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, string: &'a str) -> Box<impl Iterator<Item = &'a String>> {
    Box::new(slice.iter().filter(move |item| item.starts_with(string)))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}