डेटा फीड

Question

में पूर्वानुमानित दोहराने वाले स्ट्रिंग पैटर्न के लिए डायनामिक रेगेक्स पीढ़ी मैं वर्तमान में कई डेटा फ़ीड्स को संसाधित करने की कोशिश कर रहा हूं जिन पर मेरा कोई नियंत्रण नहीं है, जहां मैं जानकारी निकालने के लिए सी # में नियमित अभिव्यक्तियों का उपयोग कर रहा हूं।

डेटा फ़ीड का उत्प्रेरक अपने डेटाबेस (जैसे उत्पाद का नाम, मूल्य, आदि) से मूल पंक्ति डेटा निकाल रहा है, और फिर उस डेटा को अंग्रेजी पाठ की पंक्तियों के भीतर स्वरूपित कर रहा है। प्रत्येक पंक्ति के लिए, कुछ पाठ स्थिर पाठ को दोहराया जाता है और कुछ डेटाबेस से गतिशील रूप से जेनरेट किए गए टेक्स्ट होते हैं।

जैसे

पैनासोनिक टीवी के साथ $ 20 अमेज़न एमपी 3 वाउचर

साथ मुफ्त डीवीडी प्लेयर + बॉक्स ऑफिस डीवीडी

केनवुड हाई-फाई यूनिट के साथ मुफ्त ब्लू-रे प्लेयर

सोनी टीवी

तो इस उदाहरण में प्रारूप है: उत्पादFRE के साथ EGIFT।

उत्पाद और FREEGIFT प्रत्येक पंक्ति के गतिशील हिस्से हैं, और "के साथ" पाठ स्थिर है। प्रत्येक फ़ीड में लगभग 2000 पंक्तियां होती हैं।

गतिशील भागों को निकालने के लिए एक नियमित अभिव्यक्ति बनाना छोटा है।

बिल्कुल नया Panasonic टीवी और:

समस्या

कि डेटा फीड के नियंत्रण में विपणन bods स्थिर पाठ की संरचना, आमतौर पर एक बार एक पखवाड़े बदलते रहता है, इसलिए इस सप्ताह मैं हो सकता है एक नि: शुल्क ब्लू-रे प्लेयर आप आदेश आज

बिल्कुल नया सोनी टीवी और एक मुफ्त डीवीडी प्लेयर + बॉक्स ऑफिस डीवीडी अगर अगर आप आज

बिल्कुल नया केनवुड हाई-फाई इकाई और एक $ 20 अमेज़न एमपी 3 वाउचर यदि आप आदेश आदेश आज

और अगले सप्ताह यह शायद कुछ अलग हो जाएगा, इसलिए मैं अपने रेगुलर एक्सप्रेशन को संशोधित रखने के लिए है ...

आप इससे कैसे निपटेंगे हैं?

तारों की दोहराने वाली पंक्तियों के भीतर स्थिर और परिवर्तनीय पाठ निर्धारित करने के लिए कोई एल्गोरिदम है? यदि हां, प्रोग्रामिंग रूप से गतिशील नियमित अभिव्यक्ति बनाने के लिए ऐसे एल्गोरिदम के आउटपुट का उपयोग करने का सबसे अच्छा तरीका क्या होगा?

किसी भी मदद या सलाह के लिए धन्यवाद।

Answer 1

मुझे लगता है कि यह एक एल्गोरिदम के साथ संभव होगा, लेकिन समय पर यह आपको नियमित रूप से नियमित अभिव्यक्ति करने के विरुद्ध कोड करने के लिए ले जाएगा, यह इसके लायक नहीं हो सकता है।

हालांकि आप अपनी बदलती प्रक्रिया को तेज़ी से बना सकते हैं। यदि आपके आवेदन के अंदर आपकी रेगेक्स स्ट्रिंग होने की बजाय, आप उसे कहीं भी एक टेक्स्ट फ़ाइल में डाल देंगे, तो आपको हर बार बदलाव करने और पुन: नियोजित करने की आवश्यकता नहीं होगी, आप बस टेक्स्ट फ़ाइल को संपादित कर सकते हैं।

आपके प्रोजेक्ट आकार और कार्यान्वयन के आधार पर, यह आपको एक उदार समय बचा सकता है।

Answer 2

यह कोड सही नहीं है, यह निश्चित रूप से कुशल नहीं है, और यह आपकी मदद करने में बहुत देर हो चुकी है, लेकिन यह काम करता है। यदि तारों का एक सेट दिया जाता है, तो यह सामान्य सामग्री को एक निश्चित लंबाई से ऊपर कर देगा।

हालांकि, जैसा कि अन्य ने उल्लेख किया है, एक एल्गोरिदम केवल आपको अनुमान लगा सकता है, क्योंकि आप एक खराब बैच मार सकते हैं जहां सभी उत्पादों का एक ही प्रारंभिक शब्द होता है, और फिर कोड गलती से उस सामग्री को स्थैतिक रूप से पहचान लेगा। जब गतिशील सामग्री स्थैतिक सामग्री के साथ मूल्य साझा करती है तो यह विसंगति भी उत्पन्न कर सकती है, लेकिन जैसे ही आप इसमें नमूनों के आकार को बढ़ाते हैं, त्रुटि का मौका कम हो जाएगा।

मैं (20000 पंक्तियों एक बुरा विचार होगा!) की जाँच अतिरिक्त विवेक के कुछ प्रकार

अंतिम चेतावनी (स्थिर तत्व आदि की अधिकतम संख्या) के साथ अपने डेटा के एक उपसमूह पर इस चल सलाह देते हैं: यह एक सही काम कर सकता है, लेकिन अगर ऐसा होता है, तो आप कैसे जानते हैं कि उत्पाद कौन सा आइटम है और कौन सा FREEGIFT है?

एल्गोरिथ्म

1. सेट में सभी स्ट्रिंग्स, एक ही अक्षर से आरंभ होने "वर्तमान मैच" सेट करने के लिए कि चरित्र जोड़ें, फिर सभी स्ट्रिंग्स
2. हैं पर ले जाने वाले चरित्र को निकाल देते हैं नहीं, उन सभी तारों से पहले अक्षर को हटा दें जिनके पहले x (न्यूनतम मिलान लंबाई) वर्ण अन्य सभी तारों में शामिल नहीं हैं
3. जैसे ही कोई मेलसमूह पहुंच जाता है (केस 2), यदि वर्तमान मिलान मिलता है तो वर्तमान मिलान प्राप्त करें लंबाई requme NT
4. जारी रखें जब तक सभी तार समाप्त हो

कार्यान्वयन

private static IEnumerable<string> FindCommonContent(string[] strings, int minimumMatchLength) 
{ 
    string sharedContent = ""; 

    while (strings.All(x => x.Length > 0)) 
    { 
     var item1FirstCharacter = strings[0][0]; 

     if (strings.All(x => x[0] == item1FirstCharacter)) 
     { 
      sharedContent += item1FirstCharacter; 

      for (int index = 0; index < strings.Length; index++) 
       strings[index] = strings[index].Substring(1); 

      continue; 
     } 

     if (sharedContent.Length >= minimumMatchLength) 
      yield return sharedContent; 

     sharedContent = ""; 

     // If the first minMatch characters of a string aren't in all the other strings, consume the first character of that string 
     for (int index = 0; index < strings.Length; index++) 
     { 
      string testBlock = strings[index].Substring(0, Math.Min(minimumMatchLength, strings[index].Length)); 

      if (!strings.All(x => x.Contains(testBlock))) 
       strings[index] = strings[index].Substring(1); 
     } 
    } 

    if (sharedContent.Length >= minimumMatchLength) 
     yield return sharedContent; 
} 

आउटपुट

सेट 1 (अपने उदाहरण से):

FindCommonContent(strings, 4); 
=> "with " 

सेट 2 (अपने उदाहरण से):

"{.*}" + string.Join("{.*}", FindCommonContent(strings, 4)) + "{.*}"; 
=> "^{.*}Brand new {.*}and a {.*}if you order today{.*}$" 

आप के लिए एल्गोरिथ्म को संशोधित कर सकता है हालांकि:

FindCommonContent(strings, 4); 
=> "Brand new ", "and a ", "if you order today" 

regex

यह रूप में सरल रूप में किया जाना चाहिए बिल्डिंग मैचों कहां हैं (स्थिर सामग्री के बीच या बाहर) के बारे में जानकारी लौटाएं, यह ठीक होगा, क्योंकि आप जानते हैं कि कुछ एम होगा वैसे भी शून्य लंबाई लंबाई तार।