Iterators

Iterators are a powerful abstraction in Rust, enabling developers to process sequences of data in a functional, efficient, and composable way. They are the foundation of many collection-related operations and provide a clean and expressive alternative to traditional loops.

In this challenge, you will implement two functions that utilize iterators to perform specific operations:

Filtering out even numbers from a sequence of integers.
Converting strings to uppercase from a sequence of string slices.

Using Rust's iterator methods such as filter, map, and collect, you'll create concise, functional implementations that demonstrate the elegance and power of iterators.

Your Task

Write the following two functions:

filter_even_numbers:
Takes an iterator of integers and filters out even numbers, returning a vector of the remaining odd numbers.
uppercase_strings:
Takes an iterator of string slices and converts each string to uppercase, returning a vector of the transformed strings.

Read the main() function carefully to understand how the functions will be used and what is expected from them.

Hints

Click here to reveal hints

Use the filter method for filtering elements based on a condition.
Make sure you dereference the values when using them in the closure. For example:
```
.filter(|&x| x % 2 != 0)
```
Or
```
.filter(|x| *x % 2 != 0)
```
Use the collect method to gather results from an iterator into a vector.
Use the map method for transforming elements in an iterator.
Use the to_uppercase method to convert a string to uppercase.
Define lifetimes for the input and output types in the function signature.

Editor not available on Mobile!

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

Solutions

ycgw

2 days ago

5.10ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|i| i % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|i| i.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Maintain

duonghb53

4 days ago

4.00ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect::<Vec<i32>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item =  &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Prafful

iamsahu

5 days ago

4.14ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect::<Vec<i32>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String>{
    iter.map(| x | x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

ikatlinsky

5 days ago

4.18ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|e| e % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|e| e.to_string()).map(|e| e.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Seth Wood

seth-wood

7 days ago

6.33ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|even| even % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

diucicd

7 days ago

4.03ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|&v| v % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings(iter: impl Iterator<Item = &'static str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}

Sergey Matyash

matiaspub

11 days ago

5.61ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|it| it % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|t| t.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

LeonardoPinheiro23

16 days ago

5.05ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|&number| number % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|string| string.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Tommytto

21 days ago

4.34ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|a| a % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a, 'b>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

sjmellor

24 days ago

5.74ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Nicolai

Posmac

a month ago

7.00ms

95.28kb


pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let result = iter.filter(|&x| x % 2 != 0);
    result.collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter : impl Iterator<Item = &'a str> ) -> Vec<String>  {
    let result = iter.map(|x| {
        x.to_uppercase()
    });
    result.collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    //Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

ggnne

a month ago

4.55ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|n| n % 2 != 0).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase().to_string()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Elizabeth Doughty

Thymelizabeth

a month ago

4.96ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|i| *i % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

roboquaternion

a month ago

5.35ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|&x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(input: impl Iterator<Item = &'a str>) -> Vec<String> {
    input
        .map(|s| s.to_uppercase())
        .collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Nguyen Vo Hoang Son

sonmessia

a month ago

8.08ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|&x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Health-Care-Movie

a month ago

3.92ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|&x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Splatrac

splatrac

a month ago

6.43ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let mut odd = Vec::new();
    for num in iter {
        if num % 2 != 0 {
            odd.push(num)
        }
    }
    odd
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    let mut up_words = Vec::new();
    for word in iter {
        up_words.push(word.to_uppercase());
    }
    up_words
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Splatrac

splatrac

a month ago

4.88ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let mut odd = Vec::new();
    for num in iter {
        if num % 2 != 0 {
            odd.push(num)
        }
    }
    odd
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    let mut up_words = Vec::new();
    for word in iter {
        up_words.push(word.to_uppercase());
    }
    up_words
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Trịnh Chấn Duy

Duyyy123

2 months ago

5.98ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Trịnh Chấn Duy

Duyyy123

2 months ago

7.04ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x.abs() % 2 == 1).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Liyqq

2 months ago

5.62ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|n| n % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Nathan GAUD

Natchica

2 months ago

5.02ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|&num| num % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|word| word.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

shibu-t

2 months ago

4.73ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|s| s % 2 != 0 ).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(str: impl Iterator<Item = &'a str>) -> Vec<String> {
    str.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Assylbek Razakhbergenov

asylbek27

2 months ago

5.31ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|&x| x % 2 != 0).collect::<Vec<_>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect::<Vec<String>>()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

mishbah

2 months ago

5.11ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Jason

Jason-fy-wang

2 months ago

4.29ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    
    iter.filter(|itm| itm% 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl IntoIterator<Item = &'a str>) -> Vec<String> {
    iter.into_iter().map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

VerweyFr

2 months ago

5.27ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    let mut even_numbers = Vec::new();
    for i in iter {
        if i % 2 != 0 {
          even_numbers.push(i)
        }
    }
    even_numbers
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    let mut uppercase_strings: Vec<String> = Vec::new();
    for s in iter {
        uppercase_strings.push(s.to_uppercase());
    }
    uppercase_strings
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

vijayabhaskar badireddi

ptcte

2 months ago

4.85ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|number| number % 2 != 0).collect::<Vec<i32>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|f| f.to_uppercase()).collect::<Vec<String>>()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Suresh Kumar

toddlers

3 months ago

5.33ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|number| number % 2 != 0).collect::<Vec<i32>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item= &'a str>) -> Vec<String> {
    iter.map(|f| f.to_uppercase()).collect::<Vec<String>>()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Jason

chenjie1219

3 months ago

4.98ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|num| num % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|str| str.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

lugtester

3 months ago

12.57ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|i| i%2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item=&'a str>) -> Vec<String> {
    iter.map(|i| i.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

lugtester

3 months ago

7.28ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|i| i%2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item=&'a str>) -> Vec<String> {
    iter.map(|i| i.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Yixian Du

duyixian1234

3 months ago

4.78ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|num| num % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Aurimas Kuniutis

auriku

3 months ago

5.09ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|num| num % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

gsspdev

3 months ago

4.85ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|x| (x % 2 != 0)).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Artem

tich31337

3 months ago

6.84ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x%2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Anna Komarova

Vlasanya

3 months ago

4.70ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|x| x % 2 != 0).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

AnKarl

Zythophilus

3 months ago

6.89ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Paulo Lins

pblins

3 months ago

4.89ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|n| n % 2 != 0).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Paulo Lins

pblins

3 months ago

5.83ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|n| n % 2 != 0).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Icarus

IcarusxB

3 months ago

5.19ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|&num| num %2 != 0).collect()
}
pub fn uppercase_strings(iter: impl Iterator<Item = &'static str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Hung Dinh

nhdinh

3 months ago

5.72ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|&x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings(iter: impl IntoIterator<Item = &'static str>) -> Vec<String> {
    iter.into_iter().map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Matthew Li

circles-png

3 months ago

4.52ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|n| n.rem_euclid(2) == 1).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase().to_string()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Zeiion

4 months ago

4.86ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Viktor Merkurev

fennr

4 months ago

5.71ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|num| (num % 2).abs() == 1).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|word| word.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Guilherme Cesário Strachan

strachan

4 months ago

4.92ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Kentaro Abe

abekem

4 months ago

4.18ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|s| s.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

amaneru

7ma8no9

4 months ago

6.04ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Anıl Şenay

anilsenay

4 months ago

4.40ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|x| x % 2 != 0).collect()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_uppercase()).collect()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Romain Grimau

Herrgrim0

4 months ago

4.78ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|x| x % 2 != 0).collect::<Vec<i32>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|x| x.to_string().to_uppercase()).collect::<Vec<String>>()
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [1, 3, 5]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}