Structs and references

In Rust, structs can store references in addition to owned values. This allows you to create powerful and memory-efficient abstractions by reusing data rather than duplicating it. However, using references in structs requires careful attention to lifetimes to ensure that the references remain valid.

In this challenge, you will create a struct named TextFinder that holds a reference to a string slice (&str). This struct will be used to perform search operations on the string slice by finding lines that contain a given keyword.

Your Task

Create a struct called TextFinder that holds a reference to a string slice.
The struct should have a constructor new() that takes a string slice and returns a TextFinder instance.
The struct should have a method called find_first that returns the first line containing the keyword, or None if no match is found.
The struct should have a method called find_many that returns a vector of all lines containing the keyword.
The search functionality should be case-sensitive.
Ensure you return references to the original string slice rather than creating new owned strings.

Hints

If you're stuck, you may find the following hints useful:

Click here to reveal hints

Lifetime Annotations: Use a lifetime annotation to link the struct's lifetime to the lifetime of the string slice it references. e.g.
```
pub struct TextFinder<'a> {
    text: &'a str,
}
```
String Methods: You can use .lines() on a &str to split it into lines and .contains() to check if a string contains a substring.
Iterators: Iterators like .find() or .filter() can simplify search operations.

Editor not available on Mobile!

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

Solutions

shahab-tplus

14 hours ago

4.35ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    s: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self {
        Self{s}
    }
    pub fn find_first(&self, a: &str) -> Option<&'a str> {
        let mut lines = self.s.lines();
        lines.find(|l| l.contains(a))
        
    }
    pub fn find_many(&self, a: &str) -> Vec<&'a str> {
        self.s.lines().filter(|l| l.contains(a)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

StevenCanDrink

5 days ago

4.17ms

90.36kb

// 1. Define the struct
pub trait TF<'a> {
    fn find_first(&self, word: &str) -> Option<&'a str>;
    fn find_many(&self, word: &str) -> Vec<&'a str>; // Changed to return Vec
}
pub struct TextFinder<'a> {
    pub slices: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TF<'a> for TextFinder<'a> {
    fn find_first(&self, word: &str) -> Option<&'a str> {
        self.slices.lines().find(|l| l.contains(word))
    }
    fn find_many(&self, word: &str) -> Vec<&'a str> {
        // Changed to return Vec
        self.slices
            .lines()
            .filter(|l| l.contains(word))
            .collect() // Collect all lines into a Vec
    }
}
impl<'a> TextFinder<'a> {
    pub fn new(x: &'a str) -> Self {
        Self {
            slices: x,
        }
    }
}
// Example usage
pub fn main() {
    let text =
        "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

shahab-tplus

5 days ago

29.50ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    s: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self {
        Self{s}
    }
    pub fn find_first(&self, a: &str) -> Option<&'a str> {
        let mut lines = self.s.lines();
        lines.find(|l| l.contains(a))
    }
    pub fn find_many(&self, a: &str) -> Vec<&'a str> {
        self.s.lines().filter(|l| l.contains(a)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

amdfxlucas

5 days ago

6.76ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>
{
    pub text: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self{
        Self{text: s}
    }
    pub fn find_first(&self, s: &str) -> Option<&str>
    {
        // self.text.lines().contains(s)
        self.text.lines().find_map( |x| { if x.contains(s){ Some(x) } else {None}  } )
    }
    pub fn find_many(&self, s: &str) -> Vec<&str>
    {
        self.text.lines().filter(|x| x.contains(s) ).collect::<Vec<&str>>() // .map(|x|x.unwrap())
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Chih Ying Yen

xavierforge

7 days ago

3.96ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, key: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(key))
    }
    pub fn find_many(&self, key:&str) -> Vec<&str> {
        self.text.lines().filter(|line| line.contains(key)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

undefeated_

boyboi86

9 days ago

4.26ms

90.36kb

// 1. Define the struct as a tuple, only access as .0
// Better: Indicates it's line-oriented
pub struct TextFinder<'a>(&'a str);
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a>{
    pub fn new(text: &'a str) -> Self {
        Self(text)
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(keyword)) 
        
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.0.lines().filter(|line| line.contains(keyword)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

toto

12 days ago

4.19ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>(&'a str);
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self(text)
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.0
            .lines()
            .filter(|line| line.contains(keyword))
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

GunGraveCpp

12 days ago

3.96ms

90.36kb

pub struct TextFinder<'a>{
    text: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder<'a>{
        TextFinder { text }
    } 
    pub  fn find_first(&self, pattern: &str)-> Option<&'a str>{
        self.text.lines().find(|x| x.contains(pattern))
    }
    pub fn find_many(&self, pattern: &str) -> Vec<&'a str>{
        self.text.lines().filter(|x| x.contains(pattern)).collect()
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

manu3618

14 days ago

3.96ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&'a self, word: &'a str) -> Option<&'a str> {
        for l in self.text.lines() {
            if l.contains(&word) {
                return Some(&l);
            }
        }
        return None;
    }
    pub fn find_many(&'a self, word: &'a str) -> Vec<&'a str> {
        self.text.lines().filter(|&l| l.contains(&word)).collect::<Vec<_>>()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Lvfalue

15 days ago

3.73ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>(&'a str);
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(t: &'a str) -> Self {
        TextFinder(t)
    }
    pub fn find_first(&self, target: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(target))
    }
    pub fn find_many(&self, target: &str) -> Vec<&str> {
        self.0.lines().filter(|line| line.contains(target)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Jean-baptiste JOFFRE

Indy79

15 days ago

4.01ms

90.36kb

use std::io::Lines;
// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder {
        TextFinder { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&'a str> {
        self.text.lines().filter(|line| line.contains(keyword)).next()
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&'a str> {
        self.text.lines().filter(|line| line.contains(keyword)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

visanr

17 days ago

4.63ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder {
        TextFinder{text}
    }
    pub fn find_first(&self, keyword: &str) -> Option<&'a str> {
        self.text.lines().filter(|s| s.contains(keyword)).next()
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&'a str> {
        self.text.lines().filter(|s| s.contains(keyword)).collect()
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Ranjith Thangavel

RanjithECE24

19 days ago

4.32ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(string: &'a str) -> Self {
        Self { text: string }
    }
    pub fn find_first(&self, keyword: &'a str) -> Option<&'a str> {
        self.text.lines().filter(|line| line.contains(keyword)).next()
    }
    pub fn find_many(&self, keyword: &'a str) -> Vec<&'a str> {
        self.text.lines().filter(|line| line.contains(keyword)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

aghia98

20 days ago

4.81ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>{
    pub slice: &'a str
}
impl<'a> TextFinder<'a>{
    pub fn new(slice: &'a str)-> Self{
        Self { slice: slice }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&'a str>{
       self.slice.lines().filter(|line| line.contains(keyword)).next()
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&'a str> {
      self.slice.lines().filter(|line| line.contains(keyword)).collect()
      
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Luka Bračun

lbracun

22 days ago

4.07ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>(&'a str);
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self(text)
    }
    pub fn find_first(&self, needle: &str) -> Option<&'a str> {
        self.0.lines().find(|line| line.contains(needle))
    }
    pub fn find_many(&self, needle: &str) -> Vec<&'a str> {
        self.0.lines().filter(|line| line.contains(needle)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

bzdula

23 days ago

5.15ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, key: &'a str) -> Option<&str> {
        self.text.split("\n").find(|spl| spl.contains(key))
    }
    pub fn find_many(&self, key: &'a str) -> Vec<&str> {
        self.text
            .split("\n")
            .filter(|split| split.contains(key))
            .collect()
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Wouter

WouterMartens

a month ago

3.96ms

90.36kb


pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, reference: &str) -> Option<&str> {
        self.text
            .lines()
            .find(|line| line.contains(reference))
    }
    pub fn find_many(&self, reference: &str) -> Vec<&str> {
        self.text
            .lines()
            .filter(|line| line.contains(reference))
            .collect()
    }
}
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Daniel Mestas

miel-codeai

a month ago

4.14ms

90.36kb

pub struct TextFinder<'a> {
    pub text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text
            .lines()
            .filter(|line| line.contains(keyword))
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Andy Randrianirina

andyslash

a month ago

4.41ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>{
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(slc: &'a str) -> Self{
        TextFinder{text: slc,}
    }
    pub fn find_first(&'a self, keyword: &str) -> Option<&'a str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&'a self, key: &str) -> Vec<&'a str> {
    self.text
        .lines()
        .filter(|line| line.contains(key))
        .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

m1031

monorail103

a month ago

3.91ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(t: &'a str) -> Self {
        Self{
            text: t
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&'a str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&'a str> {
        self.text.lines().filter(|line| line.contains(keyword)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

slaws

a month ago

3.84ms

89.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(t: &'a str) -> Self {
        Self { text: t }
    } 
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        let vec: Vec<&str> = self.text.split('\n').collect();
        if let Some(l) = vec.iter().find(|v| v.contains(kw) ) {
            Some(l)
        } else {
            None
        }
    }
    pub fn find_many(&self, kw: &str) -> Vec<&str> {
        let mut v :Vec<&str> = Vec::new();
        for l in self.text.split("\n") {
            if l.contains(kw) {
                v.push(l);
            }
        }
        v
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

slaws

a month ago

4.15ms

90.44kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(t: &'a str) -> Self {
        Self { text: t }
    } 
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        for l in self.text.split("\n") {
            if l.contains(kw) {
                return Some(l);
            }
        }
        None
    }
    pub fn find_many(&self, kw: &str) -> Vec<&str> {
        let mut v :Vec<&str> = Vec::new();
        for l in self.text.split("\n") {
            if l.contains(kw) {
                v.push(l);
            }
        }
        v
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Fatih

0fatih

a month ago

3.92ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>{
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a>{
    pub fn new(s: &'a str) -> Self {
        Self {
            text: s
        }
    }
    pub fn find_first(&self, k: &'a str) -> Option<&'a str> {
        self.text.lines().find(|l| l.contains(k))
    }
    pub fn find_many(&self, k: &'a str) -> Vec<&'a str> {
        self.text.lines().filter(|l| l.contains(k)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Evrins Hu

evrins

a month ago

4.76ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder<'a> {
        TextFinder { text }
    }
    pub fn find_first(&self, s: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(s))
    }
    pub fn find_many(&self, s: &str) -> Vec<&str> {
        self.text
            .lines()
            .filter(|line| line.contains(s))
            .collect::<Vec<&str>>()
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Heino Mortensen

hmortensen83

a month ago

4.46ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    string: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(string: &'a str) -> Self {
        Self { string }
    }
    pub fn find_first(&self, word: &str) -> Option<&str> {
        self.string.lines().find(|line| line.contains(word))
    }
    pub fn find_many(&self, word: &str) -> Vec<&str> {
        self.string
            .lines()
            .filter(|line| line.contains(word))
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Baron Curtin

baroncurtin2

a month ago

5.68ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&'a str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&'a str> {
        self.text
            .lines()
            .filter(|line| line.contains(keyword))
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Baron Curtin

baroncurtin2

a month ago

3.69ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text
            .lines()
            .filter(|line| line.contains(keyword))
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

johndoe30bc

a month ago

4.08ms

90.36kb

pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text
            .lines()
            .filter(|line| line.contains(keyword))
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

AtlasVakyrie

a month ago

91.11ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl TextFinder<'_> {
    pub fn new(text: &str) -> TextFinder {
        TextFinder{text}
    }
    
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|s| s.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text.lines().filter(|s| s.contains(keyword)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

xxxxsk

a month ago

4.40ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder { text }
    }
    pub fn find_first(&self, query: &str) -> Option<&'a str> {
        self.text.split("\n").find(|i| i.contains(query))
    }
    
    pub fn find_many(&self, query: &str) -> Vec<&'a str> {
        self.text.split("\n").filter(|i| i.contains(query)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

bernardoLY19

a month ago

3.87ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>{
    text: &'a str,
}
impl<'a> TextFinder<'a>{
    pub fn new(re: &'a str) -> Self{
        return Self { text: re }
    }
    pub fn find_first(&self, word: &'a str) -> Option<&'a str> {
        self.text
        .split('\n')
        .find(|line| line.contains(word))
    }
    pub fn find_many(&self, word: &'a str) -> Vec<&str>{
        self.text
        .split('\n')
        .filter(|line| line.contains(word)).collect()
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Evgenii Grigorenko

grevgeny

a month ago

3.99ms

90.33kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&self, substr: &str) -> Option<&str> {
        self.text.lines().find(|l| l.contains(substr))
    }
    pub fn find_many(&self, substr: &str) -> Vec<&str> {
        self.text.lines().filter(|l| l.contains(substr)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

FredoPo

2 months ago

3.73ms

89.42kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&self, word: &'a str) -> Option<&'a str> {
        let vector: Vec<&str> = self.text.split("\n").collect();
        if let Some(line) = vector.iter().find(|val| val.contains(word)) {
            return Some(line);
        }
        None
    }
    pub fn find_many(&self, word: &'a str) -> Vec<&str> {
        let vector: Vec<&str> = self.text.split("\n").collect();
        let mut lines:Vec<&str> = vec![];
        vector.iter().for_each(|val| {
            if val.contains(word) {
                lines.push(val);
            }
        });
        lines
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

FredoPo

2 months ago

4.50ms

89.42kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&self, word: &'a str) -> Option<&'a str> {
        let vector: Vec<&str> = self.text.split("\n").collect();
        if let Some(line) = vector.iter().find(|val| val.contains(word)) {
            return Some(line);
        }
        None
    }
    pub fn find_many(&self, word: &'a str) -> Vec<&str> {
        let vector: Vec<&str> = self.text.split("\n").collect();
        let mut lines:Vec<&str> = vec![];
        vector.iter().for_each(|val| {
            if val.contains(word) {
                lines.push(val);
            }
        });
        lines
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Procybit

2 months ago

4.71ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text: text }
    }
    pub fn find_first(&self, key: &str) -> Option<&str> {
        self.text.lines().find(|l| l.contains(key))
    }
    pub fn find_many(&self, key: &str) -> Vec<&str> {
        self.text.lines().filter(|l| l.contains(key)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

brucecox01

2 months ago

3.78ms

90.44kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str,
}
impl TextFinder<'_> {
    pub fn new<'a>(text: &'a str) -> TextFinder<'a> {
        TextFinder { text }
    }
    pub fn find_first<'a>(&'a self, key: &str) -> Option<&'a str> {
        let mut lines = self.text.lines();
        while let Some(l) = lines.next() {
            if l.contains(key) {
                return Some(l)
            }
        }
        None
    }
    pub fn find_many<'a>(&'a self, key: &str) -> Vec<&'a str> {
        let mut lines = self.text.lines();
        let mut matches = vec![];
        while let Some(l) = lines.next() {
            if l.contains(key) {
                matches.push(l);
            }
        }
        matches
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Miguel Ángel Allende

maallende

2 months ago

4.30ms

90.44kb

// 1. Define the struct
pub struct TextFinder<'a>{
    content : &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(content: &'a str) -> Self {
        TextFinder { content }
    }
    pub fn find_first(&self, text: &str) -> Option<&str> {
        for line in self.content.lines() {
            if line.contains(text) {
                return Some(line);
            }
        }
        None
    }
    pub fn find_many(&self, text: &str) -> Vec<&str> {
        let mut results = Vec::new();
        for line in self.content.lines() {
            if line.contains(text) {
                results.push(line);
            }
        }
        results
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Krzysztof Atłasik

katlasik

2 months ago

3.93ms

90.36kb

// 1. Define the struct
pub struct TextFinder <'a> {
  text: &'a str
}
impl TextFinder<'_> {
  pub fn new (text: &str) -> TextFinder {
    TextFinder { text }
  }
  pub fn find_first(&self, pattern: &str) -> Option<&str> {
    self.text.lines().find(|line| line.contains(pattern))
  }
  pub fn find_many(&self, pattern: &str) -> Vec<&str> {
    self.text.lines().filter(|line| line.contains(pattern)).collect()
  }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

coreyralph

2 months ago

3.97ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|l| l.contains(&keyword) )
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text.lines().filter(|l| l.contains(&keyword) ).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

medzernik

2 months ago

3.62ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    slice: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(slice: &'a str) -> Self {
        Self {
            slice
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&'a str> {
        self.slice.lines().find(|x| x.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&'a str> {
        self.slice.lines().filter(|x| x.contains(keyword)).collect::<Vec<_>>()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Kr0wZ

2 months ago

5.48ms

90.44kb

// 1. Define the struct
pub struct TextFinder<'a> {
    string: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(string: &'a str) -> Self {
        Self {
            string,
        }
    }
    pub fn find_first(&self, string: &'a str) -> Option<&'a str> {
        for line in self.string.lines() {
            if line.contains(string) {
                return Some(line);
            }
        }
        None
    }
    pub fn find_many(&self, string: &'a str) -> Vec<&'a str> {
        let mut vector = Vec::new();
        for line in self.string.lines() {
            if line.contains(string) {
                vector.push(line);
            }
        }
        
        vector
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Philippe Massicotte

PMassicotte

2 months ago

4.37ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder { text }
    }
    // No need to add lifetime due to elision rules
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(kw))
    }
    // No need to add lifetime due to elision rules
    pub fn find_many(&self, kw: &str) -> Vec<&str> {
        self.text.lines().filter(|line| line.contains(kw)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

esl

esl07

2 months ago

4.11ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, key: &str) -> Option<&'a str> {
        self.text.lines().find(|line| line.contains(key))
    }
    pub fn find_many(&self, key: &str) -> Vec<&'a str> {
        self.text
            .lines()
            .filter(|line| line.contains(key))
            .collect()
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

gsspdev

2 months ago

3.99ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder{text}
    }
    pub fn find_first(&self, keyword: &'a str) -> Option<&'a str> {
        self.text
        .lines()
        .find(|x| x.contains(keyword))
    }
    pub fn find_many(&self, keyword: &'a str) -> Vec<&str> {
        self.text
        .lines()
        .filter(|x| x.contains(keyword))
        .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Herman effendi

hrmneffdii

2 months ago

3.93ms

89.45kb

pub struct TextFinder<'a> {
    pub lines: Vec<&'a str>,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self {
            lines: text.split("\n").collect(),
        }
    }
    pub fn find_first(&self, query: &str) -> Option<&str> {
        self.lines
            .iter()
            .find(|line| line.contains(query))
            .map(|v| &**v)
    }
    pub fn find_many(&self, query: &str) -> Vec<&str> {
        self.lines
            .iter()
            .filter(|line| line.contains(query))
            .cloned()
            .collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Ushakov Andrey

stdstring

2 months ago

4.51ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder{text}
    }
    pub fn find_first(&self, search: &str) -> Option<&'a str> {
        self.text.lines().find(|x| x.contains(search))
    }
    pub fn find_many(&self, search: &str) -> Vec<&'a str> {
        let result: Vec<&str> = self.text.lines().filter(|x| x.contains(search)).collect();
        result
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

vanos001

2 months ago

4.48ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>{
    pub text : &'a str,
}
impl<'a> TextFinder<'a>{
    pub fn new(t : &'a str) -> Self{
        return Self{
            text : t,
        };
    }
    pub fn find_first(&self,t : &str) -> Option<&'a str>{
        return self.text
            .lines()
            .find(move |e| e.contains(t));
    }
    pub fn find_many(&self,t : &str) -> Vec<&'a str>{
        return self.text
            .lines()
            .filter(move |e| e.contains(t))
            .collect::<Vec<_>>();
    }
}
// 2. Implement the struct and define the methods
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

alexsavio

2 months ago

3.70ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
// 2. Implement the struct and define the methods
impl <'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|s| s.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text.lines().filter(|s| s.contains(keyword)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

Tengz Mao

MaoX-Yu

2 months ago

3.92ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    slice: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(slice: &'a str) -> Self {
        Self { slice }
    }
    pub fn find_first(&self, a: &str) -> Option<&str> {
        self.slice.lines().find(|s| s.contains(a))
    }
    pub fn find_many(&self, a: &str) -> Vec<&str> {
        self.slice.lines().filter(|s| s.contains(a)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

0x0f1

Paul4673

2 months ago

4.62ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text : &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(slice : &'a str) -> Self {
        Self {
            text : slice
        }
    }
    pub fn find_first(&self, slice : &str) -> Option<& str>{
        self.text.lines().find(|l| l.contains(&slice))
    }
    pub fn find_many(&self, slice : &str) -> Vec<& str>{
        self.text.lines().filter(|l| l.contains(&slice)).collect()
    }
}
// Example usage
pub fn main() {
    let text = "Rust is fast and memory-efficient.\nOwnership is key to Rust's safety.\nRustaceans love the borrow checker.";
    let finder = TextFinder::new(text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}