जंग में कैसे उत्परिवर्तित को इटरेटर तत्वों सबस्ट्रिंग

Question

मैं एक समारोह है कि निम्न करेगा बनाने के लिए कोशिश कर रहा हूँ उल्टा करने के लिए:
इनपुट: प्रपत्र "abc/डीईएफ़/GHI"
के मनमाने ढंग से लंबाई के एक String आउटपुट:String जहां "/" से अलग सभी सबस्ट्रिंग उलट दिए जाते हैं; इस उदाहरण में, आउटपुट "सीबीए/फेड/आईएचजी" होगा।

फ़ंक्शन से अधिक, मुझे split() फ़ंक्शन द्वारा उत्पन्न एक पुनरावर्तक को उत्परिवर्तित करने के पीछे सामान्य सिद्धांत की परवाह है।

fn reverse_string(input: &mut str) -> String { 
    input 
     .to_string() 
     .split('/') 
     .map(move |x| x.to_string().rev()) 
     .collect::<String>() 
} 

संकलक शिकायत है कि

error[E0599]: no method named `rev` found for type `std::string::String` in the current scope 
--> src/main.rs:5:37 
    | 
5 |   .map(move |x| x.to_string().rev()) 
    |          ^^^ 
    | 
    = note: the method `rev` exists but the following trait bounds were not satisfied: 
      `&mut std::string::String : std::iter::Iterator` 
      `&mut str : std::iter::Iterator` 

क्या मतलब है और कैसे मैं इस समस्या को हल कर सकते हैं करता है:

नीचे अपना सर्वश्रेष्ठ प्रयास है?

Answer 1

यदि आप इसे इटरेटर्स सीख रहे हैं, तो मैं पहले का निर्णय लेने का सुझाव देता हूं कि आप वास्तव में ऐसा करने से पहले क्या करना चाहते हैं।

उदाहरण के लिए, यहाँ एक भी स्मृति आवंटन के साथ एक उदाहरण है:

fn reverse_string(input: &str) -> String { 
    let mut result = String::with_capacity(input.len()); 

    for portion in input.split('/') { 
     if !result.is_empty() { 
      result.push('/'); 
     } 
     for c in portion.chars().rev() { 
      result.push(c); 
     } 
    } 

    result 
} 

Iterators आम तौर पर शुद्ध तरीकों जो अपने वातावरण को संशोधित नहीं पर ध्यान केंद्रित कर रहे हैं। दुर्भाग्यवश, इससे यहां अक्षमता हो सकती है क्योंकि यह String को बाएं और दाएं बनाने और छोड़ने का संकेत देगी।

अब, तकनीकी रूप से आप पर्यावरण map में उत्परिवर्तित कर सकते हैं (यह एक FnMut लेता है), यह सिर्फ पर सिकोड़ी है क्योंकि प्रथा के अनुसार पाठकों यह शुद्ध होने की उम्मीद।

एक परिणाम है, जब आप, में अतिरिक्त राज्य लाने के लिए Iterator::fold चाहते के रूप में जाने के लिए विधि है:

fn reverse_string(input: &str) -> String { 
    input 
     .split('/') 
     .fold(
      String::with_capacity(input.len()), 
      |mut acc, portion| { 
       if !acc.is_empty() { 
        acc.push('/'); 
       } 
       for c in portion.chars().rev() { 
        acc.push(c); 
       } 
       acc 
      } 
     ) 
} 

पहला तर्क एक संचायक, जो बंद होने की प्रत्येक मंगलाचरण, को पारित कर दिया है, जो फिर इसे वापस करें। अंत में, fold कॉल के अंत में, जमाकर्ता फिर वापस कर दिया जाता है।

यह तर्क और दक्षता दोनों के मामले में पहले कार्य के बराबर है, लेकिन ईमानदारी से मैं for संस्करण ईमानदार होने के लिए पसंद करता हूं।

Answer 2

यहाँ मेरी प्रयास है:

fn reverse_string(input: &mut str) -> String { 
    input.split('/') // split the input string by '/' 
     .map(|x| x.chars().rev().collect::<String>()) // reverse the sections and collect them 
     .collect::<Vec<String>>() // collect the reversed sections into a vector of Strings 
     .join("/") // join the strings so they are connected by '/' again 
} 

fn main() { 
    let mut s = String::from("abc/def/ghi"); 

    println!("{}", reverse_string(&mut s)); // cba/fed/ihg 
} 

अपने कोड में मुख्य त्रुटि है कि आप एक String पुनरावृति करने की कोशिश की थी, लेकिन यह Iterator को लागू नहीं करता है; इसे इसके .chars() या .bytes() पर फिर से चालू करने की आवश्यकता है।

Answer 3

.chars() द्वारा रिवर्सिंग कभी-कभी स्वीकार्य हो सकता है ... लेकिन यूक्रेन ऑस्ट्रेलिया क्यों बन गया?

println!("{}", reverse_string("abc/df/ghi")); // prints cba/fd/ihg 

(प्रत्येक झंडा इमोजी दो कोड अंक है कि एक देश कोड वर्तनी से बना है, और ऑस्ट्रेलिया के (एयू) यूक्रेन के (UA) के विपरीत है। अजीब बातें भी, गैर इमोजी के साथ हो सकता ñ की तरह ।)

सौभाग्य से, unicode-segmentation क्रेट के साथ ठीक करना आसान है; चलो बस Matthieu's solution ले, push_str साथ graphemes(true) और push साथ chars() की जगह:

extern crate unicode_segmentation; 
use unicode_segmentation::UnicodeSegmentation; 

fn reverse_string(input: &str) -> String { 
    let mut result = String::with_capacity(input.len()); 

    for portion in input.split('/') { 
     if !result.is_empty() { 
      result.push('/'); 
     } 
     for g in portion.graphemes(true).rev() { 
      result.push_str(g); 
     } 
    } 

    result 
} 

अब हमारे सभी झंडे सही फिर से (playground) देखो।