Mutable Struct References

Rust allows structs to hold mutable references to owned data, enabling them to modify the data in-place. This requires a deep understanding of lifetimes and Rust's borrowing rules to ensure memory safety.

Your Task

In this challenge, you will implement a struct named MutableTextFinder that holds a mutable reference to a String. This struct will allow for both searching and modifying the content of the String.

The MutableTextFinder struct should provide the following functionality:

new: Creates a new instance of MutableTextFinder with the given content.
find_first: Searches for the first line containing a given keyword and returns it as an immutable reference (Option<&str>).
replace_lines: Replaces all lines containing a given keyword with a replacement string.
get_text: Returns the reference to the content.
Searches should be case-sensitive.

Editor not available on Mobile!

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

Solutions

StevenCanDrink

4 days ago

4.98ms

129.59kb

//
//                       _oo0oo_
//                      o8888888o
//                      88" . "88
//                      (| -_- |)
//                      0\  =  /0
//                    ___/`---'\___
//                  .' \\|     |// '.
//                 / \\|||  :  |||// \
//                / _||||| -:- |||||- \
//               |   | \\\  -  /// |   |
//               | \_|  ''\---/''  |_/ |
//               \  .-\__  '-'  ___/-. /
//             ___'. .'  /--.--\  `. .'___
//          ."" '<  `.___\_<|>_/___.' >' "".
//         | | :  `- \`.;`\ _ /`;.`/ - ` : | |
//         \  \ `_.   \_ __\ /__ _/   .-` /  /
//     =====`-.____`.___ \_____/___.-`___.-'=====
//                       `=---='
//
//
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//Phật độ hộ trì Hoàng Huỳnh ĐẸP TRAI | code không bao giờ BUG
//     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// 1. Finish the struct definition
pub trait MutableTextFinderTrait<'a> {
    fn new(str: &'a mut String) -> MutableTextFinder<'a>;
    fn find_first(&self, word: &str) -> Option<&str>;
    fn replace_lines(&mut self, find_word: &str, word: &str) -> ();
    fn get_text(&self) -> String;
}
pub struct MutableTextFinder<'a> {
    pub slices: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinderTrait<'a> for MutableTextFinder<'a> {
    fn new(str: &'a mut String) -> MutableTextFinder<'a> {
        Self {
            slices: str,
        }
    }
    fn find_first(&self, word: &str) -> Option<&str> {
        self.slices.lines().find(|l| l.contains(word))
    }
    fn replace_lines(&mut self, find_word: &str, word: &str) -> () {
        println!("find_word: {}", find_word);
        println!("word: {}", word);
        let new_text = self.slices
            .lines()
            .map(|l| if l.contains(find_word) { word.to_string() } else { l.to_string() })
            .into_iter()
            .collect::<Vec<String>>() // collect into a Vec first
            .join("\n"); // then join
        *self.slices = new_text;
    }
    fn get_text(&self) -> String {
        self.slices.to_string()
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

amdfxlucas

5 days ago

6.47ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>
{
    pub text: &'a mut String
}
impl<'a> MutableTextFinder<'a>
{
    pub fn new(s: &'a mut String) -> Self
    {
        Self{text: s}
    }
    pub fn find_first(&self, s: &str) ->Option<&str>
    {
        self.text.lines().find_map(|x|  if x.contains(s) {Some(x)} else {None})
    }
    pub fn replace_lines(&mut self, s: &str, t: &str)
    {
        *self.text = self.text.lines().map(|old_line| if old_line.contains(s) {t} else {old_line}).collect::<Vec<_>>().join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Chih Ying Yen

xavierforge

7 days ago

4.70ms

89.37kb

// 0. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, key: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(key))
    }
    pub fn replace_lines(&mut self, key: &str, new_line: &str) {
        *self.text = self.text.lines().map(|old_line| if old_line.contains(key) {new_line} else {old_line}).collect::<Vec<_>>().join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

undefeated_

boyboi86

9 days ago

4.48ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>(&'a mut String);
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self(text)
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, new_text: &str ) {
        *self.0 = self.0.lines().map(|line| {
            if line.contains(keyword) {
                new_text
            } else {
                line
            }
        })
        .collect::<Vec<_>>()
        .join("\n")
    }
    pub fn get_text(&self) -> &String {
        self.0
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

toto

12 days ago

4.75ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>(&'a mut String);
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self(text)
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &str) {
        *self.0 = self
            .0
            .split("\n")
            .map(|line| {
                if line.contains(keyword) {
                    replacement
                } else {
                    line
                }
            })
            .collect::<Vec<&str>>()
            .join("\n")
    }
    pub fn get_text(&self) -> &String {
        &self.0
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

GunGraveCpp

12 days ago

5.75ms

89.37kb

pub struct MutableTextFinder<'a>(&'a mut String);
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> MutableTextFinder<'a> {
        MutableTextFinder(text)
    }
    pub fn find_first(&'a self, pattern: &str) -> Option<&'a str> {
        self.0.lines().find(|x| x.contains(pattern))
    }
    pub fn replace_lines(&mut self, repl: &str, val: &str) {
        *self.0 = self
            .0
            .lines()
            .map(|x| {
                if x.contains(repl) {
                    val
                } else {
                    x
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
    }
     pub fn get_text(&'a self) -> &str {
        &self.0
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

manu3618

14 days ago

5.02ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the struct and define the methods
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&'a self, word: &str) -> Option<&'a str> {
        for l in self.text.lines() {
            if l.contains(&word) {
                return Some(&l);
            }
        }
        return None;
    }
    pub fn replace_lines(&mut self, word: &str, replacement: &str) {
        *self.text = self.text
                            .lines()
                            .map(|l| if l.contains(word) { replacement } else { l })
                            .collect::<Vec<_>>()
                            .join("\n"); 
    }
    pub fn get_text(&'a self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Lvfalue

15 days ago

5.27ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>(&'a mut String);
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        MutableTextFinder(text)
    }
    pub fn find_first(&self, target: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(target))
    }
    
    pub fn replace_lines(&mut self, target: &str, with: &str) {
        *self.0 = self.0
            .lines()
            .map(|line| if line.contains(target) { with } else { line })
            .collect::<Vec<_>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.0
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Jean-baptiste JOFFRE

Indy79

15 days ago

4.71ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> MutableTextFinder {
        MutableTextFinder { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().filter(|line| line.contains(keyword)).next()
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &str) {
        *self.text = self.text.lines().map(|line| {
            if line.contains(keyword) {
                return replacement;
            }
            line
        }).collect::<Vec<_>>().join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

aghia98

16 days ago

5.17ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(content: &'a mut String) -> Self {
        Self {
            text: content
        }
    }
    pub fn get_text(&self) -> &String {
        self.text
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str>{
        self.text.lines().find(|elm| elm.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &'a str) {
        *self.text = self.text.lines().map(|line| if line.contains(keyword) {replacement} else {line}).collect::<Vec<_>>().join("\n");
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

visanr

17 days ago

4.79ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: &'a mut String
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> MutableTextFinder<'a> {
        Self {text}
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().filter(|s| s.contains(keyword)).next()
    }
    pub fn replace_lines(&mut self, keyword: &str, repl: &str) {
        let repl_text = self.text
            .lines()
            .map(|s| {
                if s.contains(keyword) {
                    repl
                } else {
                    s
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
        self.text.clear();
        self.text.push_str(&repl_text);
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Ranjith Thangavel

RanjithECE24

19 days ago

4.59ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(string: &'a mut String) -> Self {
        Self { text: string }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, from: &str, to: &str) {
        *self.text = self.text.lines().map(|line| {
            if line.contains(from) {
                to
            } else {
                line
            }
        }).collect::<Vec<&str>>().join("\n")
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Luka Bračun

lbracun

22 days ago

4.93ms

99.22kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>(&'a mut String);
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self(text)
    }
    pub fn find_first(&self, needle: &str) -> Option<&str> {
        self.0.lines().find(|line| line.contains(needle))
    }
    pub fn replace_lines(&mut self, needle: &str, replacement: &str) {
        *self.0 = self
            .0
            .lines()
            .map(|line| {
                if line.contains(needle) {
                    replacement.to_string()
                } else {
                    line.to_string()
                }
            })
            .collect::<Vec<String>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.0
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

bzdula

23 days ago

4.84ms

89.37kb

// 1. Define the struct
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, key: &str) -> Option<&str> {
        self.text.lines().find(|spl| spl.contains(key))
    }
    pub fn replace_lines(&mut self, from: &str, to: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| if line.contains(from) { to } else { line })
            .collect::<Vec<&str>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Wouter

WouterMartens

a month ago

5.23ms

89.37kb

pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, reference: &str) -> Option<&str> {
        self.text
            .lines()
            .find(|line| line.contains(reference))
    }
    pub fn replace_lines(&mut self, reference: &str, replace: &str) {
        *self.text = self.text
            .lines()
            .map(|line| {
                if line.contains(reference) {
                    replace
                } else {
                    line
                }
            }).collect::<Vec<&str>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &String {
        self.text
    }
}
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Andy Randrianirina

andyslash

a month ago

4.41ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>{
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text: text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replace_line: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(keyword) {
                    replace_line
                } else {
                    line
                }
            })
            .collect::<Vec<&str>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
     println!("{}", finder.get_text()); // Should print the modified text
}

Andy Randrianirina

andyslash

a month ago

5.47ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>{
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text: text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replace_line: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(keyword) {
                    replace_line
                } else {
                    line
                }
            })
            .collect::<Vec<&str>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
     println!("{}", finder.get_text()); // Should print the modified text
}

m1031

monorail103

a month ago

4.80ms

94.22kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(content: &'a mut String) -> Self {
        Self {text: content}
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &str) {
        let mut lines: Vec<String> = self.text.lines().map(|line| line.to_string()).collect();
        for line in &mut lines { 
            if line.contains(keyword) {
                *line = replacement.to_string();
            }
        }
        *self.text = lines.join("\n");
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Daniel Mestas

miel-codeai

a month ago

5.63ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text: text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replace_line: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(keyword) {
                    replace_line
                } else {
                    line
                }
            })
            .collect::<Vec<&str>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Rocky.C

cloki0610

a month ago

6.27ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: &'a mut String, 
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(t: &'a mut String) -> Self {
        Self {
            text: t
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str>{
        self.text.split("\n").into_iter().find(move |x| x.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, repl: &str) {
        *self.text = self.text.split("\n").into_iter().map(|mut x| {
            if x.contains(keyword) { x = repl; }
            x
        }).collect::<Vec<&str>>().join("\n");
    }
    pub fn get_text(&self) -> &String{
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

slaws

a month ago

5.18ms

89.89kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        MutableTextFinder { text: text }
    } 
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        let v: Vec<&str> = self.text.split("\n").collect();
        if let Some(v) = v.iter().find(|x| x.contains(kw) ){
            Some(v)
        } else {
            None
        }
    }
    pub fn replace_lines(&mut self, kw: &str, repl: &str) {
        println!("before : {}",self.text);
        let mut v: Vec<&str> = self.text.split("\n").collect();
        for s in v.iter_mut() {
            if s.contains(kw) {
                *s = repl;
            } 
        }
        *self.text = v.join("\n");
        println!("after : {}",self.text);
    }
    pub fn get_text(&self) -> &String {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

slaws

a month ago

28.95ms

89.89kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        MutableTextFinder { text: text }
    } 
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        let v: Vec<&str> = self.text.split("\n").collect();
        if let Some(v) = v.iter().find(|x| x.contains(kw) ){
            Some(v)
        } else {
            None
        }
    }
    pub fn replace_lines(&mut self, kw: &str, repl: &str) {
        println!("before : {}",self.text);
        let mut v: Vec<&str> = self.text.split("\n").collect();
        for s in v.iter_mut() {
            if s.contains(kw) {
                *s = repl;
            } 
        }
        *self.text = v.join("\n");
        println!("after : {}",self.text);
    }
    pub fn get_text(&self) -> &String {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Evrins Hu

evrins

a month ago

4.20ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> MutableTextFinder<'a> {
        MutableTextFinder { text }
    }
    pub fn find_first(&self, s: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(s))
    }
    pub fn replace_lines(&mut self, key: &str, s: &str) {
        *self.text = self
            .text
            .lines()
            .map(|l| if l.contains(key) { s } else { l })
            .collect::<Vec<_>>()
            .join("\n")
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Heino Mortensen

hmortensen83

a month ago

5.50ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, word: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(word))
    }
    pub fn replace_lines(&mut self, word: &str, replacement: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(word) {
                    replacement
                } else {
                    line
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Baron Curtin

baroncurtin2

a month ago

5.16ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(kw))
    }
    pub fn replace_lines(&mut self, kw: &str, repl: &str) {
        if !self.text.contains(kw) {
            return;
        }
        *self.text = self.text
            .lines()
            .map(|line| {
                if line.contains(kw) {
                    repl
                } else {
                    line
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
    } 
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Baron Curtin

baroncurtin2

a month ago

5.06ms

119.27kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(kw))
    }
    pub fn replace_lines(&mut self, kw: &str, repl: &str) {
        if !self.text.contains(kw) {
            return;
        }
        // Use String::with_capacity to pre-allocate
        let estimated_capacity = self.text.len() + (repl.len() * 2); // rough estimate
        let mut result = String::with_capacity(estimated_capacity);
        let mut first_line = true;
        for line in self.text.lines() {
            if !first_line {
                result.push('\n');
            }
            first_line = false;
            if line.contains(kw) {
                result.push_str(repl);
            } else {
                result.push_str(line);
            }
        }
        *self.text = result;
    } 
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Baron Curtin

baroncurtin2

a month ago

4.74ms

99.22kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(kw))
    }
    pub fn replace_lines(&mut self, kw: &str, repl: &str) {
        let lines: Vec<String> = self.text
            .lines()
            .map(|line| {
                if line.contains(kw) {
                    repl.to_string()
                } else {
                    line.to_string()
                }
            })
            .collect();
        *self.text = lines.join("\n");
    } 
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

johndoe30bc

a month ago

6.19ms

89.37kb

pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|line| line.contains(keyword))
    }
    pub fn replace_lines(&mut self, old_str: &str, new_str: &str) {
        let new_text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(old_str) {
                    new_str
                } else {
                    line
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
        self.text.clear();
        self.text.push_str(&new_text);
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

AtlasVakyrie

a month ago

4.57ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl MutableTextFinder<'_> {
    pub fn new(text: &mut String) -> MutableTextFinder {
        MutableTextFinder{text}
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|s| s.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &str) {
        let lines = self.text.lines();
        //let replacement_line = replacement.to_string() + "\n";
        let mut new_lines: Vec<&str> = Vec::new();
        for line in lines {
            if line.contains(keyword) {
                new_lines.push(replacement);
            } else {
                new_lines.push(line);
            }
        }
        *self.text = new_lines.join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Cristian Prieto

cprieto

a month ago

4.79ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, pattern: &str) -> Option<&str> {
        for item in self.text.lines() {
            if item.contains(pattern) {
                return Some(item);
            }
        }
        None
    }
    pub fn get_text(&self) -> &str {
        self.text.as_str()
    }
    pub fn replace_lines(&mut self, pattern: &str, text: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(pattern) {
                    text
                } else {
                    line
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Cristian Prieto

cprieto

a month ago

4.86ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, pattern: &str) -> Option<&str> {
        for item in self.text.lines() {
            if item.contains(pattern) {
                return Some(item);
            }
        }
        None
    }
    pub fn get_text(&self) -> &str {
        self.text.as_str()
    }
    pub fn replace_lines(&mut self, pattern: &str, text: &str) {
        *self.text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(pattern) {
                    text
                } else {
                    line
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

xxxxsk

a month ago

4.87ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self {text}
    }
    pub fn find_first(&self, query: &str) -> Option<&str> {
        self.text.split("\n").find(|line| line.contains(query))
    }
    
    pub fn replace_lines(&mut self, current: &str, new: &str) {
        *self.text = self.text.split("\n").map(|line| {
            if line.contains(current) {
                new
            } else {
                line
            }
        }).collect::<Vec<_>>().join("\n");
    } 
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

FredoPo

a month ago

6.16ms

119.30kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&self, word: &'a str) -> Option<&str> {
        let vector: Vec<&str> = self.text.split("\n").collect();
        if let Some(line) = vector.iter().find(|val| val.contains(word)) {
            return Some(line);
        }
        None
    }
    pub fn replace_lines(&mut self, word: &'a str, text: &str) {
        let mut vector: Vec<&str> = self.text.split("\n").collect();
        vector.iter_mut().for_each(|val| {
            if val.contains(word) {
                *val = text;
            }
        });
        *self.text = vector.join("\n")
    }
    pub fn get_text(&self) -> String {
        self.text.clone()
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Evgenii Grigorenko

grevgeny

a month ago

4.56ms

89.37kb

pub struct MutableTextFinder<'a> {
    pub text: &'a mut String
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self {
            text
        }
    }
    pub fn find_first(&self, substr: &str) -> Option<&str> {
        self.text.lines().find(|l| l.contains(substr))
    }
    pub fn replace_lines(&mut self, old: &str, new: &str) {
        let mut new_lines = Vec::new();
        for line in &mut self.text.lines() {
            if line.contains(old) {
                new_lines.push(new);
            } else {
                new_lines.push(line);
            }
        }
        *self.text = new_lines.join("\n");
    }
    pub fn get_text(&self) -> &str {
        &self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

bernardoLY19

a month ago

5.79ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>{
    text: &'a mut String
}
impl<'a> MutableTextFinder<'a>{
    pub fn new(text: &'a mut String) -> Self{
        Self { text: text }
    }
    pub fn find_first(&self, word: &'a str) -> Option<&str>{
        self.text
        .split('\n')
        .find(|line| line.contains(word))
    }
    pub fn replace_lines(&mut self, search: &str, replace: &str) {
        *self.text = self.text
            .lines()
            .map(|l| if l.contains(&search) { replace } else { l } )
            .collect::<Vec<_>>()
            .join("\n")
    }
    pub fn get_text(&self) -> &str{
        self.text
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Procybit

2 months ago

4.95ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self { text: text }
    }
    pub fn find_first(&self, key: &str) -> Option<&str> {
        self.text.lines().find(|l| l.contains(key))
    }
    pub fn replace_lines(&mut self, key: &str, to: &str) {
        *self.text = self
            .text
            .lines()
            .map(|l| if l.contains(key) { to } else { l })
            .collect::<Vec<_>>()
            .join("\n")
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

brucecox01

2 months ago

4.91ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: &'a mut String,
}
impl MutableTextFinder<'_> {
    pub fn new<'a>(text: &'a mut String) -> MutableTextFinder<'a> {
        MutableTextFinder { text }
    }
    pub fn find_first<'a>(&'a self, key: &str) -> Option<&'a str> {
        let mut lines = self.text.lines();
        while let Some(l) = lines.next() {
            if l.contains(key) {
                return Some(l);
            }
        }
        None
    }
    pub fn replace_lines<'a>(&'a mut self, key: &str, replace: &str) {
        *self.text = self.text.lines()
            .map(|l| if l.contains(key) { replace } else { l })
            .collect::<Vec<_>>()
            .join("\n");
    }
    pub fn get_text<'a>(&'a self) -> &'a str {
        self.text
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Miguel Ángel Allende

maallende

2 months ago

4.96ms

129.22kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>{
    content : &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a>  MutableTextFinder<'a> {
    pub fn new(content: &'a mut String) -> Self {
        MutableTextFinder { content }
    }
    pub fn find_first(&self, text: &str) -> Option<&str> {
        for line in self.content.lines() {
            if line.contains(text) {
                return Some(line);
            }
        }
        None
    }
    pub fn get_text(&self) -> &str {
        self.content.as_str()
    }
    pub fn replace_lines(&mut self, pattern: &str, replacement: &str) {
        let mut new_content = String::new();
        for line in self.content.lines() {
            if line.contains(pattern) {
                new_content.push_str(replacement);
            } else {
                new_content.push_str(line);
            }
            new_content.push('\n');
        }
        // Remove the last newline for consistency with original
        if new_content.ends_with('\n') {
            new_content.pop();
        }
        *self.content = new_content;
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Krzysztof Atłasik

katlasik

2 months ago

4.77ms

89.37kb

pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self{ text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(move |l| l.contains(&keyword))
    }
    pub fn replace_lines(&mut self, search: &str, replace: &str) {
        *self.text = self.text
            .lines()
            .map(|l| if l.contains(&search) { replace } else { l } )
            .collect::<Vec<_>>()
            .join("\n")
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

coreyralph

2 months ago

4.88ms

89.37kb

pub struct MutableTextFinder<'a> {
    text: &'a mut String
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        Self{ text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(move |l| l.contains(&keyword))
    }
    pub fn replace_lines(&mut self, search: &str, replace: &str) {
        *self.text = self.text
            .lines()
            .map(|l| if l.contains(&search) { replace } else { l } )
            .collect::<Vec<_>>()
            .join("\n")
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

medzernik

2 months ago

4.09ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    reference: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(reference: &'a mut String) -> Self {
        Self {
            reference
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.reference.lines().find(move |x| x.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &str) {
        *self.reference = self.reference
            .lines()
            .map(|l| {
                if l.contains(keyword) {
                    replacement
                }
                else {
                    l
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.reference.as_ref()
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

medzernik

2 months ago

4.44ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    reference: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(reference: &'a mut String) -> Self {
        Self {
            reference
        }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.reference.lines().find(move |x| x.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &str, replacement: &str) {
        let new_string = self.reference
            .lines()
            .map(|l| {
                if l.contains(keyword) {
                    replacement
                }
                else {
                    l
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
        *self.reference = new_string;
    }
    pub fn get_text(&self) -> &str {
        self.reference.as_ref()
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Kr0wZ

2 months ago

4.70ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    string: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(string: &'a mut String) -> Self {
        Self {
            string,
        }
    }
    pub fn find_first(&'a self, keyword: &'a str) -> Option<&'a str> {
        self.string
        .lines()
        .find(|l| l.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword: &'a str, replacement: &'a str) {
        let new_string = self.string
        .lines()
        .map(|l| {
            if l.contains(keyword) {
                replacement
            }
            else {
                l
            }
        })
        .collect::<Vec<_>>()
        .join("\n");
        *self.string = new_string;
    }
    pub fn get_text(&self) -> &String {
        self.string
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Philippe Massicotte

PMassicotte

2 months ago

6.39ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    // Usually never have to mark field as mutable, except if holding a reference
    text: &'a mut String,
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: &'a mut String) -> Self {
        MutableTextFinder { text }
    }
    pub fn get_text(&self) -> &str {
        self.text
    }
    pub fn find_first(&self, kw: &str) -> Option<&str> {
        self.text.lines().find(|l| l.contains(kw))
    }
    pub fn replace_lines(&mut self, pattern: &str, replacement: &str) {
        let new_text = self
            .text
            .lines()
            .map(|line| {
                if line.contains(pattern) {
                    replacement
                } else {
                    line
                }
            })
            .collect::<Vec<_>>()
            .join("\n");
        *self.text = new_text;
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Herman effendi

hrmneffdii

2 months ago

6.60ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: & 'a mut String,
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: & 'a mut String) -> Self {
        Self{text}
    }
    pub fn find_first(& 'a self, search: &str) -> Option<& 'a str> {
        self.text.lines().find(|x| x.contains(search))
    }
    pub fn replace_lines(&mut self, search: &str, replace: &str) {
        *self.text = self.text.lines().map(|x| if x.contains(search) { replace } else { x }).collect::<Vec<&str>>().join("\n");
    }
    pub fn get_text(& 'a self) -> & 'a str {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Ushakov Andrey

stdstring

2 months ago

5.06ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    pub text: & 'a mut String,
}
impl<'a> MutableTextFinder<'a> {
    pub fn new(text: & 'a mut String) -> Self {
        Self{text}
    }
    pub fn find_first(& 'a self, search: &str) -> Option<& 'a str> {
        self.text.lines().find(|x| x.contains(search))
    }
    pub fn replace_lines(&mut self, search: &str, replace: &str) {
        *self.text = self.text.lines().map(|x| if x.contains(search) { replace } else { x }).collect::<Vec<&str>>().join("\n");
    }
    pub fn get_text(& 'a self) -> & 'a str {
        self.text
    }
}
// 2. Implement the methods for the struct
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

vanos001

2 months ago

4.34ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a>{
    pub text : &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a>{
    pub fn new(t : &'a mut String) -> Self{
        return Self{
            text : t,
        }
    }
    pub fn find_first(&self,pat : &str) -> Option<&str>{
        return self.text
            .lines()
            .find(|e| e.contains(pat));
    }
    pub fn replace_lines(&mut self,pat : &str,to : &str){
        *self.text = self.text.lines().map(|x| if x.contains(pat) {to} else {x}).collect::<Vec<_>>().join("\n");
    }
    pub fn get_text(&self) -> &String{
        return self.text;
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

alexsavio

2 months ago

5.21ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    text: &'a mut String,
}
// 2. Implement the methods for the struct
impl <'a> MutableTextFinder<'a>  {
    pub fn new(text: &'a mut String) -> Self {
        Self { text }
    }
    pub fn find_first(&self, keyword: &str) -> Option<&str> {
        self.text.lines().find(|s| s.contains(keyword))
    }
    pub fn replace_lines(&mut self, keyword :&str, substitute : &str) {
        *self.text = self.text.lines()
            .map(|x| if x.contains(keyword) { substitute } else { x })
            .collect::<Vec<_>>().join("\n");
    }
    pub fn get_text(&self) -> &String {
        self.text
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

Tengz Mao

MaoX-Yu

2 months ago

6.88ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    slice: &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new(slice: &'a mut String) -> Self {
        Self { slice }
    }
    pub fn find_first(&self, a: &str) -> Option<&str> {
        self.slice.lines().find(|s| s.contains(a))
    }
    pub fn replace_lines(&mut self, a: &str, b: &str) {
        *self.slice = self
            .slice
            .lines()
            .map(|s| if s.contains(a) { b } else { s })
            .collect::<Vec<_>>()
            .join("\n");
    }
    pub fn get_text(&self) -> &str {
        self.slice
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}

0x0f1

Paul4673

2 months ago

4.87ms

89.37kb

// 1. Finish the struct definition
pub struct MutableTextFinder<'a> {
    content : &'a mut String,
}
// 2. Implement the methods for the struct
impl<'a> MutableTextFinder<'a> {
    pub fn new( text: &'a mut String) -> Self {
        MutableTextFinder {
            content : text,
        }
    }
    pub fn find_first(&self, text: &str) -> Option<&str> {
        self.content.lines().find(|x| x.contains(text))
    }
    pub fn replace_lines(&mut self, slice :&str, newslice : &str)-> &String{
        *self.content = self.content.lines()
            .map(|x| if x.contains(slice) { newslice } else { x })
            .collect::<Vec<_>>().join("\n");
        self.content
    }
    pub fn get_text(&self) -> &String {
        self.content
    }
}
// Example usage
pub fn main() {
    let mut text = String::from("Rust is awesome\nLearning Rust\nFun with Rustaceans");
    let mut finder = MutableTextFinder::new(&mut text);
    let first = finder.find_first("Rust");
    println!("{:?}", first); // Should print: Some("Rust is awesome")
    finder.replace_lines("Rust", "Programming in Rust");
    println!("{}", finder.get_text()); // Should print the modified text
}