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

Sander Boelhouwers

sander-b-postnl

4 hours ago

4.12ms

95.28kb

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

Ugo VENTURE

Swymn

a day ago

4.21ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|num| num % 2 != 0).collect()
    // 1. Finish the function
}
// 2. Finish the function here
pub fn uppercase_strings<T: AsRef<str>>(iter: impl Iterator<Item = T>) -> Vec<String> {
    iter.map(|word| word.as_ref().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"]
}

alexlazebwork

2 days ago

4.43ms

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

Abeautifulsnow

5 days ago

6.02ms

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

zibuyu28

8 days ago

39.01ms

95.28kb


pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let res = iter.filter(|num| {
        num % 2 != 0
    }).collect();
    res
}
// 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"]
}

Atanas Krondev

AtanasKrondev

8 days ago

5.19ms

95.28kb

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

sorero2

11 days ago

13.50ms

95.28kb

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

Özgür

AyikOzgur

11 days ago

4.31ms

95.28kb

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

mihaya

mihaya03

11 days ago

5.10ms

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

Artyom Chebotarev

Derik117

12 days ago

3.94ms

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

jcarey9149

16 days ago

5.01ms

95.28kb

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

Marouan Boulahtouf

MBoulahtouf

18 days ago

3.90ms

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

Ignat S.

Igonato

20 days ago

5.33ms

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

Luiz Pinheiro

lgabriellp

21 days ago

6.89ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|value| value % 2 != 0).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item=&'a str>) -> Vec<String> {
    iter.map(|text| text.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"]
}

Luiz Pinheiro

lgabriellp

21 days ago

5.48ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|value| value % 2 != 0).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item=&'a str>) -> Vec<String> {
    iter.map(|text| text.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"]
}

Léa Narzis

lean-apple

23 days ago

4.09ms

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

Léa Narzis

lean-apple

23 days ago

49.03ms

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

Egu0

egu0

24 days ago

5.06ms

95.28kb

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

azmahflameheart

a month ago

4.10ms

95.28kb

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

LawisChen

a month ago

6.02ms

95.28kb

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

Snoweuph

snoweuph

a month ago

5.16ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    iter.filter(|n| n.abs() % 2 == 1).collect()
}
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    iter.map(|text| text.to_uppercase()).collect()
}

Yashwanth

Yash981

a month ago

4.31ms

95.28kb

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

vqk-2003

a month ago

4.12ms

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

ffrie

a month ago

4.87ms

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

reborn3d

a month ago

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

Ramon Silva

rsilva1

a month ago

4.38ms

95.28kb

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

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

3.99ms

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

SpontaneousOverthrow

a month ago

4.56ms

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

makinpaper

a month ago

4.02ms

95.28kb

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

<YoungAncient/>

youngancient

a month ago

6.57ms

95.28kb

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

Dan Wayne

danwayne-me

a month ago

4.29ms

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

Asrul Firdaus

AsrulF

a month ago

4.11ms

95.28kb

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

noname

random1106

a month ago

4.23ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let mut v:Vec<i32> = Vec::new();
    for num in iter {
        if num % 2 != 0 {
            v.push(num);
        }
    }
    v
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String> {
    let mut v:Vec<String> = Vec::new();
    for s in iter {
        v.push(s.to_uppercase());
    }
    v
}
// 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"]
}

kasaxpong

a month ago

4.94ms

95.28kb

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

Kishan

wdcs-kishansudani

2 months ago

3.78ms

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()
}
pub fn main() {
    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]
    let words = vec!["hello", "world"];
    let uppercase_words = uppercase_strings(words.into_iter());
    println!("{:?}", uppercase_words); // Should print: ["HELLO", "WORLD"]
}

Dharm Singh

dharmvr1

2 months ago

4.89ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let res = iter.filter(|x| x%2!=0 ).collect::<Vec<_>>();
    res
}
// 2. Finish the function here
pub fn uppercase_strings<'a> (words:impl Iterator<Item = &'a str >)-> Vec<String> {
     let res = words.map(|word| word.to_uppercase() ).collect::<Vec<String>>();
      res
}
// Example usage
pub fn main() {
    // Filtering even numbers
    let numbers = vec![1, 2, 3, 4, 5,-1];
    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"]
}

Mykhailo Huzhvii

Ymkavi

2 months ago

4.93ms

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

银雀Sparrxw

Sparr0www820

2 months ago

4.26ms

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

Yummy-Yums

2 months ago

4.34ms

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

Ari Karim

arikarim

2 months ago

4.99ms

95.28kb

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

Vincent SAMY

vsamy

2 months ago

5.26ms

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

Jai

jsat97

2 months ago

7.99ms

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::<Vec<i32>>()
}
// 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"]
}

Abhishek Sharma

0xAbhiDev

2 months ago

43.31ms

95.28kb

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

nojae15

2 months ago

4.75ms

95.28kb

pub fn filter_even_numbers(iter: impl Iterator<Item = i32>) -> Vec<i32> {
    // 1. Finish the function
    let mut res = vec![];
    for i in iter{
       if i % 2 == 1|| i %2 == -1{
            res.push(i);
       } 
    }
    res
}
// 2. Finish the function here
pub fn uppercase_strings<'a>(iter: impl Iterator<Item = &'a str>) -> Vec<String>{
    let mut res = vec![];
    for i in iter{
        res.push(i.to_uppercase());
    }
    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"]
}

jfloresremar

2 months ago

4.96ms

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

QuJohan

2 months 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).abs() == 1).collect::<Vec<i32>>()
}
// 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"]
}

ghoti225

2 months ago

4.36ms

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>(sitr: impl Iterator<Item = &'a str>) -> Vec<String> {
    sitr.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"]
}

Gurneet singh

GS-Jatt

3 months ago

4.56ms

95.28kb

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

Omar

OmniKobra

3 months ago

5.03ms

95.28kb

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

msned

3 months ago

4.21ms

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