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

Denis SOURON

Brack0

4 hours ago

4.00ms

90.36kb

pub struct TextFinder<'a> {
    pub text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder { text }
    }
    pub fn find_first(&self, text: &str) -> Option<&str> {
        self.text.split('\n').find(|line| line.contains(text))
    }
    pub fn find_many(&self, text: &str) -> Vec<&str> {
        self.text
            .split('\n')
            .filter(|line| line.contains(text))
            .collect()
    }
}

amaneru

7ma8no9

9 hours ago

4.01ms

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: &str) -> Option<&'a str> {
        self.text.lines().find(|x| x.contains(key))
    }
    
    pub fn find_many(&self, key: &str) -> Vec<&'a str> {
        self.text.lines().filter(|x| x.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."]
}

Kentaro Abe

abekem

11 hours ago

5.52ms

90.36kb

pub struct TextFinder<'a> {
    pub 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(|line| line.contains(keyword))
    }
    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."]
}

Guilherme Cesário Strachan

strachan

a day ago

9.63ms

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, s: &str) -> Option<&str> {
        self.text.lines().find(|x| x.contains(s))
    }
    pub fn find_many(&self, s: &str) -> Vec<&str> {
        self.text.lines().filter(|x| x.contains(s)).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."]
}

Anıl Şenay

anilsenay

2 days ago

4.01ms

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 {
        TextFinder { text }
    }
    pub fn find_first(&self, t: &'a str) -> Option<&'a str> {
        self.text.lines().find(|x| x.contains(t))
    }
    pub fn find_many(&self, t: &'a str) -> Vec<&'a str> {
        self.text.lines().filter(|x| x.contains(t)).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."]
}

Romain Grimau

Herrgrim0

2 days ago

3.72ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    slc: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(slc: &str) -> TextFinder {
        TextFinder {
            slc,
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.slc.lines().find(|x| x.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.slc.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."]
}

AKA.MoneyTaker

M4Bo2

3 days ago

4.08ms

90.36kb

pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    // Constructor to create a new TextFinder instance
    pub fn new(text: &'a str) -> Self {
        TextFinder { text }
    }
    // Find the first line containing the keyword
    pub fn find_first(&'a self, keyword: &str) -> Option<&'a str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    // Find all lines containing the keyword
    pub fn find_many(&'a 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);
    // Find the first line containing "Rust"
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is fast and memory-efficient.")
    // Find all lines containing "Rust"
    let matches = finder.find_many("Rust");
    println!("{:?}", matches); // Should print: ["Rust is fast and memory-efficient.", "Ownership is key to Rust's safety."]
}

automata-studio

5 days ago

4.37ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub slice: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(slice: &'a str) -> Self {
        TextFinder {
            slice
        }
    }
    pub fn find_first(&self, needle: &str) -> Option<&'a str>{
        self.slice.lines().filter(|line| line.contains(needle)).next()
    }
    pub fn find_many(&self, needle: &str) -> Vec<&str> {
        self.slice.lines().filter(|line| line.contains(needle)).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."]
}

Dyaa Adel

dyaa-adel

6 days ago

4.77ms

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(s : &'a str) -> Self {
        Self {
            text : s
        }
    }
    pub fn find_first(&self, pat : &str) -> Option<&'a str> {
        for line in self.text.lines() {
            if line.contains(pat) {
                return Some(line.into());
            }
        }
        None
    }
    pub fn find_many(&self, pat : &str) -> Vec<&'a str> {
        let mut res : Vec<&str> = Vec::new();
        for line in self.text.lines() {
            if line.contains(pat) {
               res.push(line.into());
            }
        }
        res
    }
}
// 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."]
}

manuelmj

7 days ago

4.96ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>{
    text_reference : &'a str
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder<'a> {
        TextFinder { text_reference: text }
    }
    pub fn find_first(&self, to_find: &str) -> Option<&'a str>{
        self.text_reference.lines().find(|line| line.contains(to_find))
    }
    pub fn find_many(&self, to_find: &str)-> Vec<&'a str>{
        self.text_reference.lines().filter(|line| line.contains(to_find)).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."]
}

Ayushman Rathore

Spartan09

9 days ago

3.93ms

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

Jun Huang

leemars

10 days ago

4.01ms

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, pattern: &str) -> Option<&str> {
        self.text.split("\n").find(|x| x.contains(pattern))
    }
    pub fn find_many(&self, pattern: &str) -> Vec<&str> {
        self.text.split("\n").filter(|x| x.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."]
}

Algorab

11 days ago

5.07ms

90.23kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder<'a> {
        TextFinder { text }
    }
    pub fn find_first(&self, text: &'a str) -> Option<&str> {
        self.text.split("\n").find(|&line| line.contains(text))
    }
    pub fn find_many(&self, text: &'a str) -> Vec<&str> {
        self.text.split("\n").fold(Vec::new(), |mut acc, line| {
            if line.contains(text) {
                acc.push(line);
            }
            acc
        })
    }
}
// 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."]
}

Jordan

Jordan-Haidee

12 days ago

6.35ms

90.44kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub content: &'a str, 
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(t: &'a str) -> Self {
        Self {
            content: t
        }
    }
    pub fn find_first(&self, target: &'a str) -> Option<&'a str> {
        for l in self.content.lines() {
            if l.contains(target) {
                return Some(l);
            }
        }
        return None;
    }
    
    pub fn find_many(&self, target: &'a str) -> Vec<&'a str> {
        let mut res = vec![];
        for l in self.content.lines() {
            if l.contains(target) {
                res.push(l);
            }
        }
        return res;
    }
}
// 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."]
}

Kyle Diaz

kylediaz

12 days ago

7.04ms

90.44kb

// 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: s,
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        for l in self.s.split("\n") {
            if l.contains(keyword) {
                return Some(l);
            }
        }
        return None;
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        let mut output = vec![];
        for l in self.s.split("\n") {
            if l.contains(keyword) {
                output.push(l);
            }
        }
        return output;
    }
}
// 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."]
    }
}

Kenneth Love

kennethlove

14 days ago

8.57ms

90.36kb

pub struct TextFinder<'a> {
    haystack: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> TextFinder {
        Self {
            haystack: text
        }
    }
    pub fn find_first(&self, needle: &str) -> Option<&str> {
        self.haystack.lines().find(|l| l.contains(needle))
    }
    pub fn find_many(&self, needle: &str) -> Vec<&str> {
        self.haystack.lines().filter(|l| l.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."]
}

Muhammad-Dennis

14 days ago

4.26ms

89.33kb

// 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: &str) -> Option<&str> {
    self.text.lines().filter(|s| s.contains(&word)).next()
}
    pub fn find_many(&self, word: &str) -> Vec<&'a str> {
         self.text.lines()
            .filter(|&w| w.to_lowercase()
            .contains(&word.to_lowercase())).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."]
}

Marco-Normal

15 days ago

4.26ms

89.33kb

// 1. Define the struct
pub struct TextFinder<'a> {
    s1: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(s1: &'a str) -> Self {
        Self {
            s1
        }
    }
    pub fn find_first(&self, s: &str) -> Option<&'a str> {
        self.s1.lines().filter(|sub| sub.contains(s)).collect::<Vec<_>>().get(0).copied()
    }
    pub fn find_many(&self, s: &str) -> Vec<&'a str> {
         self.s1.lines().filter(|sub| sub.contains(s)).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."]
}

Marco-Normal

15 days ago

9.38ms

89.33kb

// 1. Define the struct
pub struct TextFinder<'a> {
    s1: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(s1: &'a str) -> Self {
        Self {
            s1
        }
    }
    pub fn find_first(&self, s: &str) -> Option<&'a str> {
        self.s1.lines().filter(|sub| sub.contains(s)).collect::<Vec<_>>().get(0).copied()
    }
    pub fn find_many(&self, s: &str) -> Vec<&'a str> {
         self.s1.lines().filter(|sub| sub.contains(s)).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."]
}

ludovicknecht

15 days ago

3.95ms

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, keyword: &str) -> Option<&str> {
        self.text.lines().filter(|s| s.contains(&keyword)).next()
    }
    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."]
}

alemack17

16 days ago

3.72ms

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, text: &str)-> Option<&str>{
        self.text.lines().find(|t| t.contains(text))
    }
    pub fn find_many(&self, text: &str)->Vec<&str>{
        self.text.lines().filter(|t| t.contains(text)).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."]
}

Christopher Nielson

c-nielson

16 days ago

4.10ms

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, text: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(text))
    }
    
    pub fn find_many(&self, text: &str) -> Vec<&str> {
        self.text.lines().filter(|line| line.contains(text)).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."]
}

iamforgettable

16 days ago

3.96ms

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, pattern: &str) -> Option<&str> {
        self.slice.split('\n').find(|line| line.contains(pattern))
    }
    pub fn find_many(&self, pattern: &str) -> Vec<&str> {
        self.slice.split('\n').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."]
}

rawar089

19 days ago

5.18ms

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, pattern: &str) -> Option<&'a str> {
        for l in self.text.lines() {
            if l.contains(pattern) {
                return Some(l);
            }
        }
        None
    }
    pub fn find_many(&self, pattern: &str) -> Vec<&'a str> {
        self.text.lines().filter(|l| l.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."]
}

kosay

sarub0b0

19 days ago

5.83ms

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) -> TextFinder<'a> {
        TextFinder { 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."]
}

Nikita Smirnov

Nismirno

21 days ago

17.85ms

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, pat: &str) -> Option<&'a str> {
        let mut lines = self.text.lines();
        lines.find(|&line| line.contains(pat))
    }
    pub fn find_many(&self, pat: &str) -> Vec<&'a str> {
        self.text
            .lines()
            .filter(|line| line.contains(pat))
            .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."]
}

Nikita Smirnov

Nismirno

21 days ago

4.08ms

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(text: &'a str) -> Self {
        TextFinder { text }
    }
    pub fn find_first(&self, pat: &str) -> Option<&'a str> {
        let mut lines = self.text.lines();
        lines.find(|&line| line.contains(pat))
    }
    pub fn find_many(&self, pat: &str) -> Vec<&'a str> {
        let mut result = Vec::new();
        for line in self.text.lines() {
            if line.contains(pat) {
                result.push(line);
            }
        }
        result
    }
}
// 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."]
}

Elliott Draper

ejdraper

21 days ago

4.98ms

89.33kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self {
        TextFinder {
            text: s
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        let binding = self.find_many(keyword);
        let o = binding.first();
        match o {
            Some(s) => {
                return Some(*s);
            }
            None => None
        }
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        return 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."]
}

Oebelus

oebelus

22 days ago

4.26ms

90.44kb

// 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, keyword: &str) -> Option<&str> {
        match self.s.lines().find(|line| line.contains(keyword)) {
            Some(x) => Some(x),
            None => None,
        }
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        let mut sentences = vec![];
        for sen in self.s.lines() {
            if sen.contains(keyword) {
                sentences.push(sen);
            }
        }
        sentences
    }
}
// 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."]
}

TaiPoole

22 days ago

3.92ms

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, key: &'a str) -> Option<&'a str>{
        self.text.split("\n").find(|&x| x.contains(key))
    }
    pub fn find_many(&self, key: &'a str) -> Vec<&'a str>{
        self.text.split("\n").filter(|&x| x.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."]
}

Justin Maillet

justy777

23 days ago

4.13ms

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, slice: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(slice))
    }
    pub fn find_many(&self, slice: &str) -> Vec<&str> {
        self.text.lines().filter(|line| line.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."]
}

Jim Lawton

jimlawton

23 days ago

12.41ms

90.36kb

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: &str) -> Option<&str> {
        self.text.lines().find(|x| x.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.text.lines().filter(|x| x.contains(keyword)).collect::<Vec<&str>>()
    }
}
// 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."]
}

Shafer Hess

shafer-hess

24 days ago

5.77ms

90.44kb

// 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, keyword: &'a str) -> Option<&'a str> {
        //println!("S: {}, Keyword: {}", self.s, keyword);
        for line in self.s.split('\n') {
            if line.contains(&keyword) {
                return Some(line);
            }
        }
        None
    }
    pub fn find_many(&self, keyword: &'a str) -> Vec<&'a str> {
        let mut v = Vec::new();
        for line in self.s.split('\n') {
            if line.contains(&keyword) {
                v.push(line);
            }
        }
        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."]
}

Jonathan Voss

jvoss

24 days ago

4.53ms

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: &str) -> TextFinder {
        TextFinder{ text: text }
    }
    pub fn find_first(&self, string: &str) -> Option<&str> {
        self.text
            .lines()
            .find(|l| l.contains(string))
    }
    pub fn find_many(&self, string: &str) -> Vec<&str> {
        self.text
            .lines()
            .filter(|l| l.contains(string))
            .collect::<Vec<&str>>()
    }
}
// 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."]
}

Stefan Roas

sroas

24 days ago

4.33ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    pub inner: &'a str,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self { inner: text }
    }
    pub fn find_first(&self, search: &str) -> Option<&str> {
        self.inner.lines().find(|it| it.contains(search))
    }
    pub fn find_many(&self, search: &str) -> Vec<&str> {
        self.inner
            .lines()
            .filter(|it| it.contains(search))
            .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."]
}

dawwestk

a month ago

4.16ms

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(s: &'a str) -> Self {
        Self { text: s }
    }
    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."]
}

PangoSea

kapaseker

a month ago

4.53ms

89.42kb

// 1. Define the struct
// 1. Define the struct
pub struct TextFinder<'a>(&'a str);
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder(text)
    }
    pub fn find_first(&self, text: &str) -> Option<&'a str> {
        let lines = self.0.split('\n').collect::<Vec<&str>>();
        lines.iter().find(|line| line.contains(text)).map(|line| *line)
    }
    pub fn find_many(&self, text: &str) -> Vec<&'a str> {
        let lines = self.0.split('\n').collect::<Vec<&str>>();
        lines.iter().filter(|line| line.contains(text)).map(|line| *line).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."]
}