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

tzmijewski

a day ago

3.81ms

87.96kb

// Finish the function
//pub fn filter_starts_with (list: &Vec<String>, keyword: &str) -> impl Iterator<Item=&String> + '_ {
    pub fn filter_starts_with<'a> (list: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item=&'a String> + 'a {
   // let mut vec: Vec::<_> = vec![];
    //let filteredList: Vec<_> = list.iter()
    list.iter()
        .filter(move  |item | item.starts_with(keyword))//.collect::<Vec<String>>();
        
        //.collect::<Vec<_>>()
        //        .into_iter();
    //filteredList.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"]
}

amaneru

7ma8no9

a day ago

4.77ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a[String], key: &'a str) -> impl Iterator<Item = &'a String> {
    strings.iter().filter(move | string | string.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"]
}

Suraj Vijayan

its-me-sv

a day ago

3.85ms

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 |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"]
}

TiagONTOP

2 days ago

3.45ms

87.96kb

// Retourne un itérateur au lieu d'un Vec<&String>
pub fn filter_starts_with<'a>(
    string_slice: &'a [String], 
    keyword: &'a str
) -> impl Iterator<Item = &'a String> {
    string_slice
        .iter()
        .filter(move |x| x.starts_with(keyword)) // Retourne un itérateur filtré
}
// Exemple d'utilisation
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    // `.collect()` est exécuté après l'appel de la fonction
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

AKA.MoneyTaker

M4Bo2

4 days ago

3.99ms

87.96kb

// Finish the functionAccepts two arguments:
// A slice of String
// A &str keyword
// Returns an iterator that filters and yields only the strings starting with the given keyword.
pub fn filter_starts_with<'a>(
    strings: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    strings.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"]
}

Muhammad-Dennis

4 days ago

10.94ms

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 |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"]
}

Dyaa Adel

dyaa-adel

6 days ago

3.47ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(vec: &'a [String], prefix: &'a str) -> impl Iterator<Item = &'a String> {
    vec.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"]
}

Anıl Şenay

anilsenay

6 days ago

10.33ms

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 |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"]
}

Guilherme Cesário Strachan

strachan

8 days ago

3.78ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    elements: &'a [String],
    keyword: &'a str,
) -> impl Iterator<Item = &'a String> {
    elements.iter().filter(move |x| x.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"]
}

manuelmj

8 days ago

3.73ms

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 |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"]
}

Kentaro Abe

abekem

9 days ago

4.13ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(inputs: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    inputs.iter().filter(move |input| input.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"]
}

norabbito

9 days ago

3.57ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a Vec<String>, prefix: &'a str) -> impl Iterator<Item = &'a String> + 'a {
    input.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"]
}

Ayushman Rathore

Spartan09

9 days ago

4.30ms

87.96kb


pub fn filter_starts_with<'a>(slice: &'a [String], keyword: &'a str) -> impl Iterator<Item=&'a String> + 'a {
    slice
        .iter()
        .filter(move |sentence| sentence.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"]
}

Jordan

Jordan-Haidee

12 days ago

5.22ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s: &'a [String], p: &'a str) -> impl Iterator<Item = &'a String> {
    s.iter().filter(move |v| v.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"]
}

Jordan

Jordan-Haidee

12 days ago

4.44ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s: &'a [String], p: &'a str) -> impl Iterator<Item = &'a String> {
    s.iter().filter(move |v| v.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"]
}

Jordan

Jordan-Haidee

12 days ago

3.40ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s: &'a [String], p: &'a str) -> impl Iterator<Item = &'a String> {
    s.iter().filter(move |v| v.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"]
}

Jun Huang

leemars

13 days ago

3.47ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(s: &'a [String], t: &'a str) -> impl Iterator<Item=&'a String> {
    s.iter().filter(move |x| x.starts_with(t))
}
// 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"]
}

Kyle Diaz

kylediaz

14 days ago

3.24ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a [String], prefix: &'a str) -> impl Iterator<Item=&'a String> {
    input.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"]
}

Kenneth Love

kennethlove

15 days ago

4.89ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(haystack: &'a Vec<String>, needle: &'a str) -> impl Iterator<Item=&'a String> {
    haystack.iter().filter(move |hay| hay.starts_with(needle)).into_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"]
}

Viktor Merkurev

fennr

15 days ago

5.03ms

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 |x| x.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"]
}

Romain Grimau

Herrgrim0

16 days ago

5.29ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slc: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    slc.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"]
}

alemack17

17 days ago

3.44ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(list: &'a Vec<String>, key: &'a str) -> impl Iterator<Item = &'a String>{
    list.iter().filter(move |x| x.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"]
}

Marco-Normal

17 days ago

3.62ms

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 |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"]
}

ludovicknecht

17 days ago

3.44ms

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"]
}

Denis SOURON

Brack0

17 days ago

3.94ms

87.96kb

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

delxs

18 days ago

4.85ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(slice: &'a Vec<String>, keyword: &'a str) ->impl Iterator<Item = &'a String> {
    slice.iter()
        .filter(move |x|x.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"]
}

RiyadDz22

18 days ago

3.90ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input:&'a Vec<String>, target: &'a str) -> impl Iterator<Item=&'a String>{
    let new_vec = input.iter().filter(move |&s| s.starts_with(target));
    new_vec
}
// 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"]
}

Algorab

18 days ago

3.45ms

87.96kb

pub fn filter_starts_with<'a>(input:&'a Vec<String>, key: &'a str) -> impl Iterator<Item=&'a String> {
    input.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"]
}

Dmitriy

Sh1nenium

19 days ago

3.53ms

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 |x| x.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"]
}

kosay

sarub0b0

19 days ago

4.42ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    input: &'a [String],
    prefix: &'a str,
) -> impl Iterator<Item = &'a String> {
    input.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"]
}

automata-studio

20 days ago

3.71ms

87.96kb

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

iamforgettable

20 days ago

3.49ms

87.96kb

// Finish the function
// Task instructions incorrect here
pub fn filter_starts_with<'a>(stuff: &'a [String], prefix: &'a str) ->  impl Iterator<Item = &'a String> {
    stuff.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"]
}

Nikita Smirnov

Nismirno

21 days ago

3.61ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(
    input: &'a [String],
    exp: &'a str,
) -> impl Iterator<Item = &'a String> {
    input.iter().filter(move |val| val.starts_with(exp))
}
// 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"]
}

rawar089

21 days ago

3.75ms

87.96kb

pub fn filter_starts_with<'a>(v: &'a [String], key: &'a str) -> impl Iterator<Item = &'a String> {
    v.iter().filter(  move |k| k.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"]
}

Elliott Draper

ejdraper

22 days ago

3.74ms

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 |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"]
}

Justin Maillet

justy777

23 days ago

4.03ms

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 |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"]
}

Oebelus

oebelus

24 days ago

7.18ms

87.96kb

pub fn filter_starts_with<'a>(s: &'a [String], keyword: &'a str) -> impl Iterator<Item = &'a String> {
    s.iter().filter(move |x| x.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"]
}

Jim Lawton

jimlawton

24 days ago

4.21ms

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 |value| value.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"]
}

Stefan Roas

sroas

24 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 |it| it.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"]
}

zahrajavar

25 days ago

3.28ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(input: &'a [String], key: &'a str) -> impl Iterator<Item = &'a String> + 'a {
       input
        .iter() // Iterate over references to the strings in the slice
        .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"]
}

Shafer Hess

shafer-hess

25 days ago

3.72ms

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 |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"]
}

Jonathan Voss

jvoss

a month ago

3.51ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    strings.iter().filter(move |x| x.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"]
}

TaiPoole

a month ago

12.68ms

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 |&x| x.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"]
}

dawwestk

a month ago

3.32ms

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 |w| w.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"]
}

Christopher Nielson

c-nielson

a month ago

4.01ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a Vec<String>, keyword: &'a str) -> impl Iterator<Item = &'a String> {
    strings.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"]
}

PangoSea

kapaseker

a month ago

3.12ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(a: &'a[String], b: &'a str) -> impl Iterator<Item = &'a String> {
    a.iter().filter(move |s| { s.starts_with(b) })
}
// 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"]
}