रेगेक्स

Question

का उपयोग करके दो दस्तावेज़ों की तुलना करना मैं लाइन ब्रेक के बावजूद दो दस्तावेज़ों की तुलना करना चाहता हूं। यदि सामग्री समान है लेकिन लाइन ब्रेक की स्थिति और मात्रा अलग है, तो मैं लाइनों को एक दस्तावेज़ में दूसरे में लाइनों में मैप करना चाहता हूं।

को देखते हुए:

दस्तावेज़ 1

I went to Paris in July 15, where I met some nice people. 
And I came back 
to NY in Aug 15. 
I am planning 
to go there soon 
after I finish what I do. 

दस्तावेज़ 2

I went 
to Paris 
in July 15, 
where I met 
some nice people. 
And I came back to NY in Aug 15. 
I am planning to go 
there soon after I finish what I do. 

मैं एक एल्गोरिथ्म दस्तावेज़ 1 में है कि रेखा 1 का निर्धारण करने में सक्षम चाहते 1 के माध्यम से 5 लाइनों के रूप में एक ही पाठ होता है दस्तावेज़ 2 में, दस्तावेज़ 1 में 2 और 3 पंक्तियों में दस्तावेज़ 2 में पंक्ति 6 ​​के समान टेक्स्ट होता है।

1 = 1,2,3,4,5 
2,3 = 6 
4,5,6 = 7,8 

क्या प्रत्येक दस्तावेज़ में प्रत्येक पंक्ति से मिलान करने के लिए रेगेक्स के साथ कोई तरीका है यदि यह अन्य दस्तावेजों में एकाधिक लाइनों पर फैला हुआ है?

Answer 1

आप doc1 की प्रत्येक पंक्ति के माध्यम से पुनरावृति और कुछ इस तरह कर सकते हैं:

searchstring = line.replace(' ', '[ |\n]')

तब यह खोज स्ट्रिंग का उपयोग doc2 पर एक खोज करते हैं।

match = re.search(searchstring, contents)

तो matchNULL है, तो कोई मैच था। वरना, match.group(0) आप दस्तावेज़ 2. का मिलान सामग्री

'I went\nto Paris\nin July 15,\nwhere I met\nsome nice people.'

तो यह बंटवारे का एक सरल व्यायाम है कि द्वारा '\ n' और doc2 में जो लाइनों पता लगाना है कि वे से आया है दे देंगे।

Answer 2

मैं एक पायथन प्रोग्रामर नहीं हूं, लेकिन यह किसी समस्या की तरह नहीं दिखता है जिसे रेगेक्स के साथ हल किया जा सकता है।

इसके बजाय, आप पहले यह सुनिश्चित करने के लिए दस्तावेज़ों की तुलना करना चाहते हैं कि सामग्री समान है (अस्थायी रूप से सभी न्यूलाइन पहले से हटा दें)। मुझे नहीं पता कि अगर आप ऐसा नहीं करना चाहते हैं, तो मैं इसे संबोधित नहीं कर रहा हूं।

बुलाया linemappings

एक पाश शुरू पूर्णांक संग्रह का एक संग्रह बनाएँ। लूप एक साथ प्रत्येक दस्तावेज़ में प्रत्येक चरित्र के माध्यम से कदम होगा। आपको चार काउंटर वैरिएबल की आवश्यकता होगी। charindex1 दस्तावेज़ 1 में वर्तमान चरित्र सूचकांक में शामिल होंगे और charindex2 दस्तावेज़ 2. lineindex1 में वर्तमान charater सूचकांक शामिल दस्तावेज़ 1 में वर्तमान पंक्ति सूचकांक में शामिल होंगे जाएगा और lineindex2 दस्तावेज में वर्तमान पंक्ति सूचकांक में शामिल होंगे 2.

साथ प्रारंभ चार इंडेक्स वैरिएबल 0 और लाइन इंडेक्स वैरिएबल 1 से शुरू हो गए हैं।

प्रारंभ लूप:

प्रत्येक दस्तावेज़ से वर्तमान चरित्र प्राप्त करें: दस्तावेज़ 2. से दस्तावेज़ 1 से char1 और char2

char1 और char2 दोनों नई पंक्तियां हैं या न तो नई-पंक्तियों हैं, तो charindex1 और charindex2 दोनों को अग्रिम करें अन्य यदि char1 एक नई लाइन है, तो अग्रिम charindex1 से 1.
वरना तो char2 एक नई पंक्ति है, तब तक 1.

या तो char1 या char2 एक नई पंक्ति है charindex2 अग्रिम, तो linemappings संग्रह में एक नया रिकार्ड (अंत में परिणाम कुछ हो जाएगा डालने जैसे [[1,1],[1,2],[1,3],[1,4],[1,5],[2,6],[3,6],[4,7],[5,7],[6,7],[6,8])

तो char1 एक नई पंक्ति है, द्वारा 1.
तो char2 एक नई पंक्ति है lineindex1 अग्रिम, 1.

द्वारा lineindex2 अग्रिम

इनपुट के अंत तक लूप तक पहुंच गया है।

(मैं वास्तव में के बाद से मैं एक अजगर प्रोग्रामर नहीं कर रहा हूँ इस परीक्षण कर सकते हैं नहीं है, लेकिन उम्मीद है कि आप प्राप्त सार है और यह अपनी आवश्यकताओं फिट करने के लिए संशोधित कर सकते हैं।)

Answer 3

import java.io.File; 
import java.io.IOException; 
import java.util.ArrayList; 
import org.apache.commons.io.FileUtils; 

public class Compare { 
    public static void main(String[] args) throws IOException { 
     String doc1 = FileUtils.readFileToString(new File("Doc1.txt")); 
     String doc2 = FileUtils.readFileToString(new File("Doc2.txt")); 
     String[] array1 = doc1.split("\n"); 
     String[] array2 = doc2.split("\n"); 
     int[] count1 = new int[array1.length]; 
     int[] count2 = new int[array2.length]; 
     int sum1 = 0; 
     int sum2 = 0; 
     for (int i=0;i<count1.length;i++) { 
      count1[i] = sum1 + array1[i].split(" ").length; 
      sum1 = count1[i]; 
     } 
     for (int i=0;i<count2.length;i++) { 
      count2[i] = sum2 + array2[i].split(" ").length; 
      sum2 = count2[i]; 
     } 
     ArrayList<Integer> result1 = new ArrayList<Integer>(); 
     ArrayList<Integer> result2 = new ArrayList<Integer>(); 
     for (int j=0; j<count1.length;) { 
      for (int k=0; k<count2.length;) { 
       if (count1[j]==count2[k]) { 
        result1.add(j+1); 
        result2.add(k+1); 
        System.out.println(result1.toString()+" = "+result2.toString()); 
        result1 = new ArrayList<Integer>(); 
        result2 = new ArrayList<Integer>(); 
        j++;k++; 
       } else if (count1[j]>count2[k]) { 
        result2.add(k+1); 
        k++; 
       } else { 
        result1.add(j+1); 
        j++; 
       } 
      } 
     } 
    } 
} 

नमूना उत्पादन:

[1] = [1, 2, 3, 4, 5] 
[2, 3] = [6] 
[4, 5, 6] = [7, 8] 

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

विचार यह है कि हम प्रत्येक दस्तावेज़ के लिए एक सरणी बनाते हैं। सरणी का आकार प्रत्येक दस्तावेज़ में रेखाओं की संख्या के बराबर है। सरणी का nth तत्व दस्तावेज़ की nth पंक्ति तक देखे गए शब्दों की संख्या को संग्रहीत करता है। फिर हम दोनों सरणी में उन बराबर तत्वों की पहचान करते हैं, जिनके सूचकांक आउटपुट की श्रेणियों को परिभाषित करते हैं।