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

muemart

2 hours ago

5.49ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(strings: &'a[String], keyword: &'a str) -> impl std::iter::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"]
}

amdfxlucas

5 days ago

3.42ms

87.96kb

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

RaDo

rado31

6 days ago

3.44ms

87.51kb

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

StevenCanDrink

7 days ago

4.74ms

87.51kb

pub fn filter_starts_with<'a>(
    i: &'a Vec<String>,
    filter: &'a str
) -> Box<dyn Iterator<Item = &'a String> + 'a> {
    let iter = i.iter().filter(move |v| v.starts_with(filter));
    Box::new(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"]
}

Jai

jsat97

8 days ago

4.58ms

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

Chih Ying Yen

xavierforge

9 days ago

3.63ms

87.96kb

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

baschdik

11 days ago

5.56ms

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

undefeated_

boyboi86

11 days ago

3.71ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(arr: &'a [String], prefix: &'a str) -> impl Iterator<Item = &'a String>{
    // change of ownership from vector using move
    arr.iter().filter(move |letter| letter.starts_with(prefix))
}
// Example usage
pub fn main() {
    let input = vec![
        String::from("apple"),
        String::from("apricot"),
        String::from("banana"),
        String::from("cherry"),
    ];
    // because the collection occurs out of func lifetime
    let filtered: Vec<&String> = filter_starts_with(&input, "ap").collect();
    println!("{:?}", filtered); // Expected output: ["apple", "apricot"]
}

GunGraveCpp

14 days ago

3.27ms

87.96kb

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

David Rasch

dcrasch

14 days ago

3.62ms

87.96kb

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

Lvfalue

16 days ago

3.38ms

87.96kb

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

visanr

17 days ago

4.61ms

87.96kb

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

Artem Nistuley

artemnistuley

18 days ago

3.35ms

87.96kb

// Finish the function
pub fn filter_starts_with<'a>(words: &'a Vec<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"]
}

Jean-baptiste JOFFRE

Indy79

19 days ago

4.04ms

87.96kb

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

toto

19 days ago

3.36ms

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

shahab-tplus

20 days ago

3.64ms

87.96kb

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

Gurneet singh

GS-Jatt

20 days ago

3.28ms

87.96kb

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

bzdula

21 days ago

3.81ms

87.96kb

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

Luka Bračun

lbracun

23 days ago

3.34ms

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

Ranjith Thangavel

RanjithECE24

23 days ago

3.77ms

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

Wouter

WouterMartens

a month ago

3.63ms

87.96kb

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

Wouter

WouterMartens

a month ago

4.68ms

87.96kb

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

Daniel Mestas

miel-codeai

a month ago

3.22ms

87.96kb

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

Andy Randrianirina

andyslash

a month ago

4.00ms

87.96kb

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

chkolbe

a month ago

3.35ms

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

thriller08

a month ago

3.23ms

87.96kb

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

Evgenii Uglanov

winchest3r

a month ago

4.05ms

87.96kb

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

manu3618

a month ago

3.59ms

87.96kb

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

Fatih

0fatih

a month ago

4.24ms

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

slaws

a month ago

3.51ms

87.96kb

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

Evrins Hu

evrins

a month ago

3.56ms

87.96kb

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

Blaze

Divakar-2508

a month ago

3.46ms

87.96kb

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

johndoe30bc

a month ago

3.45ms

87.96kb

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

Simon Noetzlin

sainoe

a month ago

4.24ms

87.96kb

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

Baron Curtin

baroncurtin2

a month ago

3.83ms

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

m1031

monorail103

a month ago

4.25ms

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

xxxxsk

a month ago

4.56ms

87.96kb

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

Evgenii Grigorenko

grevgeny

a month ago

3.80ms

87.96kb

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

Evgenii Grigorenko

grevgeny

a month ago

3.78ms

87.96kb

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

FredoPo

2 months ago

3.49ms

87.96kb

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

Procybit

2 months ago

3.11ms

87.96kb

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

brucecox01

2 months ago

3.24ms

87.96kb

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

Karol Płatkowski

spoohie

2 months ago

3.34ms

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

Franklin Chen

FranklinChen

2 months ago

3.58ms

87.96kb

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

Krzysztof Atłasik

katlasik

2 months ago

3.52ms

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

Rocky.C

cloki0610

2 months ago

3.50ms

87.96kb

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

AtlasVakyrie

2 months ago

4.19ms

87.96kb

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

Miguel Ángel Allende

maallende

2 months ago

4.20ms

87.96kb

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

medzernik

2 months ago

4.02ms

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

Herman effendi

hrmneffdii

2 months ago

3.30ms

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