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

amaneru

7ma8no9

7 hours 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

19 hours 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

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

AKA.MoneyTaker

M4Bo2

3 days ago

5.19ms

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

manuelmj

5 days ago

7.41ms

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() 
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String>{
    iter.map(|number| number.to_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"]
}

automata-studio

5 days ago

4.20ms

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

Dyaa Adel

dyaa-adel

6 days ago

8.27ms

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> {
    // 1. Finish the function
    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"]
}

Ayushman Rathore

Spartan09

8 days ago

5.03ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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"]
}

Jun Huang

leemars

10 days ago

8.55ms

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

Algorab

11 days ago

4.46ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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"]
}

iamforgettable

11 days ago

5.75ms

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, 4, 6, 4, 8];
    let odd_numbers = filter_even_numbers(numbers.into_iter());
    println!("{:?}", odd_numbers); // Should print: [2, 4, 6,4,8]
    // Converting strings to uppercase
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Kyle Diaz

kylediaz

12 days ago

5.21ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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"]
}

Jordan

Jordan-Haidee

12 days ago

5.20ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let res: Vec<i32> = iter.filter(|x| x % 2 != 0).collect();
    res
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    let res: Vec<String> = iter.map(|x| x.to_uppercase()).collect();
    res
}
// 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"]
}

Nikita Smirnov

Nismirno

13 days ago

4.33ms

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

Kenneth Love

kennethlove

14 days ago

4.27ms

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

ludovicknecht

14 days ago

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

Muhammad-Dennis

14 days ago

4.87ms

95.28kb

pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    let uppercased= iter.map(|word| word.to_string().to_uppercase()).collect();
    uppercased
}
pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|&num| num % 2 != 0).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"]
}

alemack17

15 days ago

4.76ms

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

Marco-Normal

15 days ago

5.42ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|z| z % 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"]
}

Christopher Nielson

c-nielson

16 days ago

4.17ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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"]
}

Shafer Hess

shafer-hess

16 days ago

4.58ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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().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"]
}

rawar089

18 days ago

4.40ms

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

kosay

sarub0b0

19 days ago

4.96ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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"]
}

Denis SOURON

Brack0

20 days ago

5.28ms

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(str::to_uppercase).collect()
}

Elliott Draper

ejdraper

21 days ago

4.33ms

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

Oebelus

oebelus

21 days 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![-2, -1, -3];
    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"]
}

Justin Maillet

justy777

23 days ago

4.65ms

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

Jim Lawton

jimlawton

23 days ago

4.17ms

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

Jonathan Voss

jvoss

24 days ago

4.21ms

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

エヴァンゲリオン

Lu-zihang

24 days ago

5.35ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|it| (it % 2).abs() == 1).collect::<Vec<_>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|it| it.to_uppercase()).collect::<Vec<_>>()
}
// 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"]
}

Stefan Roas

sroas

24 days ago

5.03ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter.filter(|it| (it % 2).abs() == 1).collect::<Vec<_>>()
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|it| it.to_uppercase()).collect::<Vec<_>>()
}
// 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"]
}

TaiPoole

a month ago

4.72ms

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

dawwestk

a month ago

5.49ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    iter
        .filter(|x| x & 1 == 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"]
}

PangoSea

kapaseker

a month ago

5.95ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    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(|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"]
}