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

jpruitt77

19 hours ago

4.30ms

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

Ugo VENTURE

Swymn

a day ago

3.82ms

89.45kb

// 1. Define the struct
pub struct TextFinder<'a>(Vec<&'a str>);
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self(text.split('\n').collect())
    }
    pub fn find_first(&self, text_to_find: &str) -> Option<&str> {
        self.0
            .iter()
            .find(|line| line.contains(text_to_find))
            .copied()
    }
    pub fn find_many(&self, text_to_find: &str) -> Vec<&str> {
        self.0
            .iter()
            .filter(|line| line.contains(text_to_find))
            .copied()
            .collect()
    }
}

StevenCanDrink

5 days ago

4.69ms

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(i: &'a str) -> Self {
        Self { slice: i }
    }
    pub fn find_first(&self, i: &str) -> Option<&'a str> {
        if let Some(index) = self.slice.find(i) {
            self.slice
                .lines()
                .filter(|v| v.contains(i))
                .next()
        } else {
            None
        }
    }
    pub fn find_many(&self, i: &str) -> Vec<&str> {
        self.slice
            .lines()
            .filter(|v| v.contains(i))
            .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."]
}

Abeautifulsnow

6 days ago

4.24ms

90.36kb

pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        TextFinder { text: 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()
    }
}

Atanas Krondev

AtanasKrondev

8 days ago

3.61ms

90.60kb

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

zibuyu28

8 days ago

3.98ms

89.49kb

// 1. Define the struct
pub struct TextFinder {
    pub s: Vec<String>
}
impl TextFinder {
    pub fn new(x: &str) -> TextFinder {
        let p = x.lines().map(|item| {
            item.to_string()
        }).collect();
        TextFinder { s: p }
    }
    pub fn find_first(&self, f: &str)-> Option<&str> {
        for item in &self.s {
            if item.contains(f) {
                return Some(item)
            }
        }
        None
    }
    pub fn find_many(&self, f: &str) -> Vec<&str> {
        let mut v = Vec::new();
        for item in &self.s {
            if item.contains(f) {
                v.push(item.as_str());
            }
        }
        v
    }
}
// 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."]
}

gtakacse

9 days ago

4.50ms

89.45kb

pub struct TextFinder<'a> {
    lines: Vec<&'a str>,
}
// 2. Implement the struct and define the methods
impl<'a> TextFinder<'a> {
    pub fn new(text: &'a str) -> Self {
        Self {
            lines: text.split('\n').collect(),
        }
    }
    pub fn find_first(&self, pattern: &str) -> Option<&str> {
        self.lines
            .iter()
            .find(|line| line.contains(pattern))
            .map(|v| *v)
    }
    pub fn find_many(&self, pattern: &str) -> Vec<&str> {
        self.lines
            .iter()
            .filter(|line| line.contains(pattern))
            .map(|v| *v)
            .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."]
}

mihaya

mihaya03

11 days ago

3.82ms

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

Artyom Chebotarev

Derik117

12 days ago

3.91ms

89.33kb

// 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, w: &str) -> Option<&str> {
        match self.find_many(w) {
            v if !v.is_empty() => Some(v[0]),
            _ => None,
        }
    }
    pub fn find_many(&self, w: &str) -> Vec<&str> {
        self.text.lines().filter(|x| x.contains(w)).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."]
}

jcarey9149

16 days ago

3.79ms

89.33kb

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

Ignat S.

Igonato

20 days ago

3.82ms

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

Luiz Pinheiro

lgabriellp

21 days ago

4.56ms

90.36kb

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

Özgür

AyikOzgur

22 days ago

4.23ms

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(input: &'a str) -> Self {
        Self{
            text: input
        }
    }
    pub fn find_first(&self, key: &str) -> Option<&str> {
        if key.chars().count() == 0 {
            return self.text.lines().next();
        }
        for line in self.text.lines() {
            if let Some(lineContains) = line.find(key) {
                return Some(line);
            }
        }
        None
    }
    pub fn find_many(&self, key: &str) -> Vec<&str> {
        let mut result: Vec<&str> = Vec::new();
        for line in self.text.lines() {
            if let Some(lineContains) = line.find(key) {
                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."]
}

Egu0

egu0

24 days ago

4.20ms

90.36kb

pub struct TextFinder<'a> {
    pub s: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self {
        Self { s }
    }
    pub fn find_first(&self, keyword: &'a str) -> Option<&'a str> {
        self.s.lines().find(|&i| i.contains(keyword))
    }
    pub fn find_many(&self, keyword: &str) -> Vec<&str> {
        self.s.lines().filter(|i| i.contains(keyword)).collect()
    }
}

Egu0

egu0

24 days ago

3.98ms

89.42kb

pub struct TextFinder<'a> {
    pub s: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self {
        Self { s }
    }
    pub fn find_first(&self, keyword: &'a str) -> Option<&'a str> {
        self.s
            .split('\n')
            .collect::<Vec<_>>()
            .iter()
            .find(|&i| i.contains(keyword))
            .map(|v| v as _)
    }
    pub fn find_many(&self, keyword: &'a str) -> Vec<&'a str> {
        let mut res: Vec<&'a str> = vec![];
        let v = self.s.split('\n').collect::<Vec<_>>();
        for i in v.iter() {
            if i.contains(keyword) {
                res.push(i);
            }
        }
        res
    }
}

azmahflameheart

a month ago

4.04ms

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

Yashwanth

Yash981

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

Snoweuph

snoweuph

a month ago

5.14ms

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

Snoweuph

snoweuph

a month ago

6.78ms

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

vqk-2003

a month ago

4.29ms

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

ffrie

a month ago

3.84ms

90.44kb

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

Ramon Silva

rsilva1

a month ago

3.94ms

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, pat: &str) -> Option<&'a str> {
        self.text.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()
    }
}
// 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."]
}

LawisChen

a month ago

4.05ms

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

reborn3d

a month ago

3.94ms

90.36kb

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

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

4.25ms

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

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

5.00ms

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

SpontaneousOverthrow

a month ago

10.43ms

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

SpontaneousOverthrow

a month ago

3.96ms

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

SpontaneousOverthrow

a month ago

4.57ms

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

makinpaper

a month ago

3.66ms

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

<YoungAncient/>

youngancient

a month ago

4.51ms

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

Dan Wayne

danwayne-me

a month ago

3.86ms

90.44kb

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

Asrul Firdaus

AsrulF

a month ago

4.12ms

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

kasaxpong

a month ago

5.00ms

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

Dharm Singh

dharmvr1

2 months ago

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

Mykhailo Huzhvii

Ymkavi

2 months ago

5.89ms

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

银雀Sparrxw

Sparr0www820

2 months ago

3.91ms

90.36kb

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

Kishan

wdcs-kishansudani

2 months ago

11.94ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text: &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(text: &str) -> TextFinder {
        TextFinder { 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."]
}

Rocky.C

cloki0610

2 months ago

4.35ms

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

Yummy-Yums

2 months ago

5.16ms

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

Vincent SAMY

vsamy

2 months ago

38.32ms

90.36kb

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

Ari Karim

arikarim

2 months ago

4.53ms

90.36kb

pub struct TextFinder<'a> {
    pub content: &'a str
}
impl<'a> TextFinder<'a> {
    pub fn new(content: &'a str) -> Self {
        Self {
            content: content
         }
    }
    pub fn find_first(&self, pat: &str) -> Option<&str> {
        self.content
        .split('\n')
        .find(|el| el.contains(pat))
    }
    pub fn find_many(&self, pat: &str) -> Vec<&str> {
        self.content
            .split("\n")
            .filter(|el| el.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."]
}

Francisco Alejandro

francisco-alejandro

2 months ago

4.59ms

90.36kb

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

Abhishek Sharma

0xAbhiDev

2 months ago

5.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 (value:&'a str) -> Self 
     {
         TextFinder {
            text: value,
         }
    }
  pub fn find_first  (& 'a self , key:& 'a str)-> Option <&'a str> {
       self.text.lines().find(|line| line.contains(&key) )
    }
   pub fn find_many (& 'a self , key:& 'a 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."]
}

nojae15

2 months ago

5.64ms

90.44kb

// 1. Define the struct
pub struct TextFinder<'a>{
    text : &'a str,    
}
impl<'a> TextFinder<'a>{
    pub fn new(t :&'a str) -> Self{
        Self{text: t}
    }
    pub fn find_first(&self, f : &str) -> Option<&'a str>{
        for line in self.text.lines(){
            if line.contains(f){
                return Some(line)
            }
        }
        None
    }
    pub fn find_many(&self, f : &str) -> Vec::<&'a str>{
        let mut res_vec = vec![];
        for line in self.text.lines(){
            if line.contains(f){
                res_vec.push(line) ;
            }
        }
        res_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."]
}

Jai

jsat97

2 months ago

5.10ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a> {
    text : &'a str,
}
impl<'a> TextFinder<'a> {
    pub fn new(s: &'a str) -> Self {
        TextFinder{text: s}
    }
    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> {
       let v= 
       self.text.lines()
       .filter(|line| line.contains(key))
       .collect();
       v
    }
}
// 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."]
}

jfloresremar

2 months ago

4.17ms

90.36kb

// 1. Define the struct
pub struct TextFinder<'a>(&'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.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()
    }
}
// 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."]
}

QuJohan

2 months ago

3.90ms

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

ghoti225

3 months ago

4.80ms

90.44kb

// 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, key : &str) -> Option<&'a str> {
        
        for line in self.text.lines() {
            if line.contains(key) {
                return Some(line);
            }
        }
        // key not found in any lines
        return None
    }
    // TODO: COULD USE ITERATORS .find() or .filter() with closures instead here... 
    /*
    pub fn find_first(&self, keyword: &str) -> Option<&'a str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    */
    pub fn find_many(&self, key : &str) ->  Vec<&'a str> {
        
        let mut output = vec![];
        for line in self.text.lines() {
            if line.contains(key) {
                output.push(line);
            }
        }
        output
    }
    // TODO: COULD USE ITERATORS .find() or .filter() with closures instead here... 
    /*
    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."]
}

Omar

OmniKobra

3 months ago

3.95ms

90.36kb

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