सबसे तेज़ विकल्प खोज एल्गोरिथ्म क्या है?

Question

ठीक है, इसलिए मैं किसी बेवकूफ की तरह आवाज़ नहीं करता हूं, मैं समस्या / आवश्यकताओं को अधिक स्पष्ट रूप से बताने जा रहा हूं:

• सुई (पैटर्न) और हिस्टैक (खोज करने के लिए पाठ) दोनों सी-स्टाइल अशक्त-समाप्त स्ट्रिंग्स हैं। कोई लंबाई की जानकारी नहीं दी गई है; यदि आवश्यक हो, यह गणना की जानी चाहिए।
• फ़ंक्शन को पहले मैच के लिए एक सूचक लौटना चाहिए, या NULLयदि कोई मैच नहीं मिला है।
• विफलता के मामलों की अनुमति नहीं है। इसका मतलब है कि गैर-स्थिर (या बड़े स्थिर) भंडारण आवश्यकताओं के साथ किसी भी एल्गोरिथ्म को आवंटन विफलता के लिए एक कमबैक केस की आवश्यकता होगी (और फ़ॉलबैक देखभाल में प्रदर्शन जिससे सबसे खराब स्थिति में योगदान होता है)।
• कार्यान्वयन सी में होना है, हालांकि कोड के बिना एल्गोरिथ्म (या इस तरह के लिंक) का एक अच्छा विवरण भी ठीक है।

... साथ ही "सबसे तेज़" से मेरा क्या मतलब है:

• नियतात्मक O(n)जहाँ n= पाताल लंबाई। (लेकिन एल्गोरिदम से विचारों का उपयोग करना संभव हो सकता है जो सामान्य तौर पर होते हैं O(nm)(उदाहरण के लिए हैश रोलिंग) यदि वे निर्धारक O(n)परिणाम देने के लिए अधिक मजबूत एल्गोरिथ्म के साथ संयुक्त होते हैं )।
• कभी नहीं (औसत रूप से; if (!needle[1])आदि के लिए एक जोड़ी घड़ियां ठीक हैं) भोले जानवर बल एल्गोरिथ्म से भी बदतर हैं, खासकर बहुत छोटी सुइयों पर जो सबसे आम मामला है। (बिना शर्त भारी प्रीप्रोसेसिंग ओवरहेड खराब है, जैसा कि संभावित सुइयों की कीमत पर रोग संबंधी सुइयों के लिए रैखिक गुणांक में सुधार करने की कोशिश कर रहा है।)
• एक मनमाना सुई और हिस्टैक, तुलनीय या बेहतर प्रदर्शन (50% से अधिक लंबे खोज समय से अधिक) बनाम किसी भी अन्य व्यापक रूप से कार्यान्वित एल्गोरिथ्म को देखते हुए।
• इन स्थितियों के अलावा, मैं "सबसे तेज़" ओपन-एंड की परिभाषा छोड़ रहा हूं। एक अच्छे उत्तर से यह स्पष्ट होना चाहिए कि आप उस दृष्टिकोण पर क्यों विचार कर रहे हैं जो आप "सबसे तेज़" सुझा रहे हैं।

मेरा वर्तमान कार्यान्वयन लगभग 10% धीमे और 8 गुना तेज़ (इनपुट के आधार पर) के बीच ग्लिब्क के टू-वे के कार्यान्वयन से चलता है।

अद्यतन: मेरा वर्तमान इष्टतम एल्गोरिथ्म इस प्रकार है:

• लंबाई 1 की सुइयों के लिए, का उपयोग करें strchr।
• लंबाई 2-4 की सुइयों के लिए, एक बार में 2-4 बाइट्स की तुलना करने के लिए मशीन शब्दों का उपयोग करें: बिटहिफ्ट्स के साथ 16- या 32-बिट पूर्णांक में प्रीलोड करें और प्रत्येक पुनरावृत्ति में धड़ से पुराने बाइट आउट / नए बाइट्स को साइकिल करें। । हिस्टैक के हर बाइट को एक बार ठीक से पढ़ा जाता है और 0 (स्ट्रिंग के अंत) और एक 16- या 32-बिट की तुलना के खिलाफ एक चेक लगाता है।
• लंबाई> 4 की सुइयों के लिए, खराब शिफ्ट टेबल (जैसे बोयर-मूर) के साथ टू-वे एल्गोरिथ्म का उपयोग करें जो केवल खिड़की के अंतिम बाइट पर लागू होता है। 1kb तालिका को प्रारंभ करने के ओवरहेड से बचने के लिए, जो कि कई मध्यम-लंबाई वाली सुइयों के लिए शुद्ध नुकसान होगा, मैं एक बिट सरणी (32 बाइट्स) को चिह्नित करता हूं जो शिफ्ट तालिका में कौन सी प्रविष्टियां आरंभीकृत होती हैं। बिट्स जो कि परेशान हैं वे बाइट मूल्यों के अनुरूप हैं जो कभी भी सुई में नहीं दिखाई देते हैं, जिसके लिए एक पूर्ण-सुई-लंबाई शिफ्ट संभव है।

मेरे मन में बचे हुए बड़े प्रश्न हैं:

• क्या खराब शिफ्ट टेबल का बेहतर उपयोग करने का कोई तरीका है? बॉयर-मूर पीछे की ओर (दाएं-बाएं) स्कैन करके इसका सबसे अच्छा उपयोग करता है, लेकिन टू-वे को बाएं से दाएं स्कैन की आवश्यकता होती है।
• सामान्य मामले (नो-आउट-ऑफ-मेमोरी या क्वाड्रैटिक प्रदर्शन की स्थिति) के लिए मेरे द्वारा देखे गए केवल दो व्यवहार्य उम्मीदवार एल्गोरिदम ऑर्डर किए गए अक्षर पर दो-तरफ़ा और स्ट्रिंग मिलान हैं । लेकिन क्या आसानी से पता लगाने योग्य मामले हैं जहां विभिन्न एल्गोरिदम इष्टतम होंगे? अंतरिक्ष एल्गोरिदम में निश्चित रूप से कई O(m)(जहां mसुई की लंबाई है) का उपयोग m<100या तो किया जा सकता है । एल्गोरिदम का उपयोग करना भी संभव होगा जो सबसे खराब स्थिति वाले हैं यदि सुइयों के लिए एक आसान परीक्षण है, जिसमें केवल रैखिक समय की आवश्यकता होती है।

के लिए बोनस अंक:

• क्या आप यह मानकर प्रदर्शन में सुधार कर सकते हैं कि सुई और हिस्टैक दोनों अच्छी तरह से गठित UTF-8 हैं? (अलग-अलग बाइट लंबाई के पात्रों के साथ, अच्छी तरह से गठित-नेस सुई और हिस्टैक के बीच कुछ स्ट्रिंग संरेखण आवश्यकताओं को लगाता है और स्वचालित 2-4 बाइट शिफ्ट की अनुमति देता है जब एक बेमेल हेड बाइट का सामना करना पड़ता है। लेकिन क्या इन बाधाओं से आपको बहुत कुछ मिलता है / क्या परे है। अधिकतम प्रत्यय संगणना, अच्छी प्रत्यय पारियां, आदि पहले से ही आपको विभिन्न एल्गोरिदम के साथ देते हैं?)

नोट: मैं वहां के अधिकांश एल्गोरिदम से अच्छी तरह से वाकिफ हूं, सिर्फ इसलिए नहीं कि वे अभ्यास में कितना अच्छा प्रदर्शन करते हैं। यहाँ एक अच्छा संदर्भ है इसलिए लोग मुझे टिप्पणियों / उत्तरों के रूप में एल्गोरिदम पर संदर्भ नहीं देते हैं: http://www-igm.univ-mlv.fr/~lecroq/string/index.html

Comments

स्ट्रिंग्स पर एल्गोरिदम पर सूचीबद्ध स्ट्रिंग खोज एल्गोरिदम की काफी संख्या है । आप यह वर्णन करना चाह सकते हैं कि आपने इस सूची से किन एल्गोरिदम पर विचार किया है।

— ग्रेग हेवगिल

अंत में यह लिंक सोना है!

— कार्लोस

मुझे विश्वास नहीं हो रहा है कि आपने अभी भी एक उत्तर को स्वीकार नहीं किया है।

— user541686

@ मेहरदाद: मैं कहने वाला था कि कोई भी ऐसा जवाब नहीं है जो वास्तव में पूछे गए सवाल को संबोधित करता हो, लेकिन आपका लगता है। जिस समय आपने उत्तर दिया था कि मैं आगे बढ़ गया हूँ और strstrबाद में कुछ और सुधार किया है, इसलिए मैंने वास्तव में आपके द्वारा लिंक किए गए पेपर को ठीक से पढ़ने के लिए इधर-उधर नहीं किया है, लेकिन यह बहुत ही आशाजनक ध्वनि है। आपके वापस न आने के लिए धन्यवाद और खेद।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

Answer 1

संभावित सुई और haystacks का एक परीक्षण पुस्तकालय बनाएँ। क्रूर बल सहित कई खोज एल्गोरिदम पर परीक्षणों को प्रोफाइल करें। अपने डेटा के साथ सबसे अच्छा प्रदर्शन करने वाले को चुनें।

बॉयर-मूर एक अच्छे चरित्र तालिका के साथ एक खराब चरित्र तालिका का उपयोग करता है।

बॉयर-मूर-हॉर्सपूल एक खराब चरित्र तालिका का उपयोग करता है।

नूथ-मॉरिस-प्रैट एक आंशिक मिलान तालिका का उपयोग करता है।

राबिन-कार्प रनिंग हैश का उपयोग करते हैं।

वे सभी अलग-अलग हद तक तुलना करने के लिए ओवरहेड का व्यापार करते हैं, इसलिए वास्तविक दुनिया का प्रदर्शन सुई और हिस्टैक दोनों की औसत लंबाई पर निर्भर करेगा। अधिक प्रारंभिक ओवरहेड, बेहतर इनपुट के साथ। बहुत कम सुइयों के साथ, जानवर बल जीत सकता है।

संपादित करें:

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

निम्नलिखित छोटी तालिका के बारे में सोचें। प्रत्येक प्रश्न चिह्न में एक अलग सर्वश्रेष्ठ खोज एल्गोरिथ्म हो सकता है।

                 short needle     long needle
short haystack         ?               ?
long haystack          ?               ?

यह वास्तव में एक ग्राफ होना चाहिए, जिसमें प्रत्येक अक्ष पर छोटी से लंबी इनपुट होती है। यदि आप इस तरह के ग्राफ पर प्रत्येक एल्गोरिथ्म को प्लॉट करते हैं, तो प्रत्येक का एक अलग हस्ताक्षर होगा। कुछ एल्गोरिदम पैटर्न में बहुत अधिक दोहराव से ग्रस्त हैं, जो जीन की खोज जैसे उपयोगों को प्रभावित कर सकते हैं। समग्र प्रदर्शन को प्रभावित करने वाले कुछ अन्य कारक एक ही समय में एक ही पैटर्न की खोज कर रहे हैं और एक ही समय में विभिन्न पैटर्न खोज रहे हैं।

अगर मुझे एक सैंपल सेट की जरूरत है, तो मुझे लगता है कि मैं Google या विकिपीडिया जैसी साइट को स्क्रैप कर दूंगा, फिर सभी रिजल्ट पेज से html स्ट्रिप करूंगा। खोज साइट के लिए, किसी शब्द में टाइप करें फिर सुझाए गए खोज वाक्यांशों में से एक का उपयोग करें। यदि लागू हो तो कुछ अलग भाषाओं का चयन करें। वेब पृष्ठों का उपयोग करना, सभी ग्रंथों को मध्यम से छोटा करना होगा, इसलिए लंबे ग्रंथों को प्राप्त करने के लिए पर्याप्त पृष्ठों को मर्ज करें। आप सार्वजनिक डोमेन पुस्तकें, कानूनी रिकॉर्ड और पाठ के अन्य बड़े निकाय भी पा सकते हैं। या सिर्फ शब्दकोश से शब्द चुनकर यादृच्छिक सामग्री उत्पन्न करें। लेकिन प्रोफाइलिंग की बात यह है कि आप जिस प्रकार की सामग्री खोज रहे हैं, उसके विरुद्ध परीक्षण करना है, इसलिए यदि संभव हो तो वास्तविक दुनिया के नमूनों का उपयोग करें।

मैंने छोटी और लंबी अस्पष्ट छोड़ी। सुई के लिए, मैं 8 अक्षर से कम के बारे में सोचता हूं, मध्यम के रूप में 64 अक्षर के नीचे, और 1k के तहत लंबे समय तक। हिस्टैक के लिए, मैं 2 ^ 10 से कम के बारे में सोचता हूं, 2 ^ 20 के तहत मध्यम, और 2 ^ 30 अक्षर तक लंबा।

Comments

क्या आपके पास एक परीक्षण पुस्तकालय के लिए अच्छे सुझाव हैं? मैंने SO पर जो पिछला प्रश्न पूछा था, वह उससे संबंधित था और मुझे कभी कोई वास्तविक उत्तर नहीं मिला। (मेरे अपने को छोड़कर ...) यह व्यापक होना चाहिए। यहां तक ​​कि अगर मेरा स्ट्रैस के लिए एक आवेदन का विचार अंग्रेजी पाठ की खोज कर रहा है, तो किसी और को बेस जोड़ी अनुक्रमों में जीन की खोज हो सकती है ...

— R .. GitHub STOP HELPING ICE

यह शॉर्ट / लॉन्ग की तुलना में थोड़ा अधिक जटिल है। सुई के लिए, अधिकांश एल्गोरिदम के प्रदर्शन से संबंधित बड़े प्रश्न हैं: लंबाई? क्या कोई आवधिकता है? क्या सुई में सभी अद्वितीय अक्षर (कोई दोहराता नहीं) हैं? या सभी एक ही चरित्र? क्या हिस्टैक में बड़ी संख्या में ऐसे पात्र हैं जो सुई में कभी दिखाई नहीं देते हैं? क्या एक हमलावर द्वारा प्रदान की गई सुइयों से निपटने का मौका है जो आपके सिस्टम को अपंग करने के लिए सबसे खराब प्रदर्शन का शोषण करना चाहता है? आदि ..

— आर .. गिटहब स्टॉप हेल्पिंग आईसीई जूल

Answer 2

2011 में प्रकाशित, मेरा मानना ​​है कि यह बहुत अच्छी तरह से हो सकता है "सिंपल रियल-टाइम कॉन्सटेंट-स्पेस स्ट्रिंग मैचिंग" एल्गोरिथ्म डेनी ब्रेस्लेउर, रॉबर्टो ग्रॉसी और फिलिप्पो मिग्नोसी।

अपडेट करें:

2014 में लेखकों ने इस सुधार को प्रकाशित किया: टुवर्ड्स इष्टतम पैक्ड स्ट्रिंग मिलान ।

Comments

वाह धन्यवाद। मैं पेपर पढ़ रहा हूं। अगर यह मेरे पास से बेहतर होगा, तो मैं निश्चित रूप से आपके उत्तर को स्वीकार करूंगा।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

@ आर ..: ज़रूर! :) जिस पर बोलते हुए, यदि आप एल्गोरिथ्म को लागू करने का प्रबंधन करते हैं, तो कृपया इसे StackOverflow पर पोस्ट करने पर विचार करें, ताकि हर कोई इससे लाभ उठा सके! मुझे कहीं भी इसका कोई कार्यान्वयन नहीं मिला है और मैं शोध पत्र में पाएं गए एल्गोरिदम को लागू करने में अच्छा नहीं हूं।

— user541686

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

— आर .. गिटहब स्टॉप हेल्पिंग ICE

और आपने अभी भी @ मेहरदाद के उत्तर को स्वीकार नहीं किया है! :-)

— जीवनरक्षा

@ डेविडवैलस: क्या? इसमें कागजी शीर्षक और लेखक हैं। यहां तक ​​कि अगर लिंक मृत हो जाता है, तो आप कागजात पा सकते हैं। आप मुझसे क्या करने की उम्मीद कर रहे हैं, एल्गोरिथ्म के लिए pseudocode लिखें? आपको क्या लगता है कि मैं एल्गोरिथ्म को समझता हूं?

— user541686

Answer 3

Http://www-igm.univ-mlv.fr/~lecroq/string/index.html आप बात का बहुत अच्छा स्रोत है और सबसे प्रसिद्ध और शोध स्ट्रिंग मिलान एल्गोरिदम में से कुछ का सार है से लिंक।

अधिकांश खोज समस्याओं के समाधान में पूर्व-प्रसंस्करण ओवरहेड, समय और स्थान की आवश्यकताओं के संबंध में व्यापार बंद शामिल हैं। कोई भी एल्गोरिथ्म सभी मामलों में इष्टतम या व्यावहारिक नहीं होगा।

यदि आप उद्देश्य स्ट्रिंग खोज के लिए एक विशिष्ट एल्गोरिथ्म डिजाइन करना चाहते हैं, तो मुझे जो कहना है, उसके बाकी हिस्सों को अनदेखा करें, यदि आप सामान्यीकृत स्ट्रिंग खोज सेवा दिनचर्या विकसित करना चाहते हैं, तो निम्नलिखित का प्रयास करें:

आपके द्वारा पहले ही संदर्भित एल्गोरिदम की विशिष्ट ताकत और कमजोरियों की समीक्षा करने के लिए कुछ समय बिताएं। एल्गोरिदम का एक सेट खोजने के उद्देश्य से समीक्षा का संचालन करें जो आपके द्वारा रुचि रखने वाले स्ट्रिंग खोजों की सीमा और दायरे को कवर करता है। फिर, दिए गए इनपुट के लिए सर्वश्रेष्ठ एल्गोरिदम को लक्षित करने के लिए एक क्लासिफायर फ़ंक्शन के आधार पर फ्रंट एंड सर्च चयनकर्ता का निर्माण करें। इस तरह से आप काम करने के लिए सबसे कुशल एल्गोरिदम को नियोजित कर सकते हैं। यह विशेष रूप से प्रभावी होता है जब एक एल्गोरिथ्म कुछ खोजों के लिए बहुत अच्छा होता है लेकिन खराब तरीके से खराब हो जाता है। उदाहरण के लिए, ब्रूट बल संभवतः लंबाई 1 की सुइयों के लिए सबसे अच्छा है, लेकिन सुई की लंबाई बढ़ने के साथ जल्दी खराब हो जाती है, जिसके कारण साथ- सस्टिक-मूर अल्गोरिटिमअधिक कुशल (छोटे अक्षरों के ऊपर) बन सकता है, फिर लंबी सुइयों और बड़े अक्षरों के लिए, केएमपी या बॉयर-मूर एल्गोरिदम बेहतर हो सकते हैं। ये एक संभावित रणनीति को चित्रित करने के लिए सिर्फ उदाहरण हैं।

एकाधिक एल्गोरिथ्म एक नया विचार नहीं है। मेरा मानना ​​है कि यह कुछ वाणिज्यिक सॉर्ट / सर्च पैकेज द्वारा नियोजित किया गया है (जैसे SYNCSORT आमतौर पर मेनफ्रेम कई प्रकार के एल्गोरिदम का उपयोग करता है और दिए गए इनपुट के लिए "सर्वोत्तम" चुनने के लिए उत्तराधिकार का उपयोग करता है)

प्रत्येक खोज एल्गोरिथ्म कई रूपों में आता है जो इसके प्रदर्शन के लिए महत्वपूर्ण अंतर बना सकते हैं, उदाहरण के लिए, यह पेपर दिखाता है।

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

Comments

प्रतिक्रिया के लिए धन्यवाद, विशेष रूप से Sustik-Moore का लिंक जो मैंने पहले नहीं देखा था। कई एल्गोरिदम दृष्टिकोण निश्चित रूप से व्यापक उपयोग में है। Glibc मूल रूप से strchr करता है, खराब चरित्र पारी तालिका के बिना टू-वे, या सुई -लेन 1, <32, या> 32 के आधार पर, खराब चरित्र पारी तालिका के साथ Two-Way। मेरा वर्तमान दृष्टिकोण समान है सिवाय इसके कि मैं हमेशा शिफ्ट टेबल का उपयोग करता हूं; मैंने 1kb की जगह आवश्यक कर दिया ताकि एक 32 बाइट के साथ एक बिटसेट पर एक बिटसेट को चिह्नित करने के लिए उपयोग किया जा सके, जो कि तालिका के किन तत्वों को आरंभीकृत किया गया है, और मुझे छोटी सुई के लिए भी लाभ (लेकिन ओवरहेड नहीं) मिलता है।

— R .. गिटहब स्टॉप हेल्पिंग ICE

इसके बारे में सोचने के बाद, मैं वास्तव में उत्सुक हूं कि Sustik-Moore के लिए क्या इरादा है। छोटे अक्षरों के साथ, आपको कभी भी कोई महत्वपूर्ण बदलाव करने की ज़रूरत नहीं होगी (वर्णमाला के सभी वर्ण सुई के अंत में लगभग निश्चित रूप से दिखाई देते हैं) और परिमित ऑटोमेटा दृष्टिकोण बहुत कुशल (छोटे राज्य संक्रमण तालिका) हैं। इसलिए मैं किसी भी परिदृश्य की कल्पना नहीं कर सकता, जहां सुस्टिक-मूर इष्टतम हो सकते हैं ...

— R .. GitHub STOP HELPING ICE

महान प्रतिक्रिया - अगर मैं इस विशेष उत्तर को मैं कर सकता था।

— जेसन एस

@R .. sustik-moore एल्गोरिथ्म के पीछे सिद्धांत यह है कि यह आपको बड़ी औसत शिफ्ट मात्रा देनी चाहिए जब सुई अपेक्षाकृत बड़ी होती है और वर्णमाला अपेक्षाकृत छोटी होती है (जैसे डीएनए अनुक्रम की खोज)। इस मामले में बड़ा सिर्फ मूल बोयर-मूर एल्गोरिथ्म से बड़ा मतलब है जो एक ही इनपुट देगा। यह कितना अधिक कुशल है यह एक परिमित ऑटोमेटा दृष्टिकोण या किसी अन्य बॉयर-मूर भिन्नता के संबंध में है (जिनमें से कई हैं) कहना मुश्किल है। यही कारण है कि मैंने आपके उम्मीदवार एल्गोरिदम की विशिष्ट शक्तियों / कमजोरियों पर शोध करने के लिए कुछ समय बिताने पर जोर दिया।

— NealB

हम्म, मुझे लगता है मैं सिर्फ बॉय-मूर से खराब चरित्र बदलाव के अर्थ में बदलाव के बारे में सोच रहा था। हालांकि बीएम अच्छे प्रत्यय बदलाव पर सुधार के साथ, Sustik-Moore संभवतः डीएनए खोज के लिए DFA दृष्टिकोण से बेहतर प्रदर्शन कर सकता है। स्वच्छ सामान।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

Answer 4

इस चर्चा में उद्धृत हमारी तकनीकी रिपोर्ट को देखकर मुझे आश्चर्य हुआ; मैं एल्गोरिथ्म के लेखकों में से एक हूं जिसे ऊपर Sustik-Moore नाम दिया गया था। (हमने अपने पेपर में उस शब्द का इस्तेमाल नहीं किया।)

मैं यहां इस बात पर जोर देना चाहता था कि मेरे लिए एल्गोरिथ्म की सबसे दिलचस्प विशेषता यह है कि यह साबित करना काफी सरल है कि प्रत्येक पत्र की सबसे अधिक बार जांच की जाती है। पहले के बॉयर-मूर संस्करणों के लिए उन्होंने साबित किया कि प्रत्येक पत्र की अधिकतम 3 और बाद में 2 बार जांच की जाती है, और वे प्रमाण अधिक शामिल थे (कागज में उद्धृत देखें)। इसलिए मैं इस संस्करण को प्रस्तुत करने / अध्ययन करने में एक सामयिक मूल्य भी देखता हूं।

पेपर में हम आगे की विविधताओं का भी वर्णन करते हैं जो सैद्धांतिक गारंटी के साथ आराम करते हुए दक्षता की ओर बढ़ती हैं। यह एक छोटा पेपर है और सामग्री को मेरी राय में औसत हाई स्कूल स्नातक होना चाहिए।

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

Comments

क्या आपको पता है कि C या C ++ कार्यान्वयन उपलब्ध है? मैं कुछ dna रूपांकन खोज (सटीक मूल भाव मिलान) के लिए इसका उपयोग करने के बारे में सोच रहा हूं। यदि नहीं, तो शायद मैं खुद को एक कार्यान्वयन विकसित करने और एल्गोरिथ्म को बढ़ावा देने के लिए प्रस्तुत करने की कोशिश करूंगा

— JDiMatteo

कोई ज्ञात उपलब्ध कार्यान्वयन के साथ, Sustik-Moore / 2BLOCK एल्गोरिथ्म का उपयोग व्यवहार में होने की संभावना नहीं है और सारांश पत्रों जैसे "द

— एक्जैक्ट

Answer 5

सबसे तेज़ विकल्प खोज एल्गोरिथ्म संदर्भ पर निर्भर करने वाला है:

1. वर्णमाला के आकार (उदाहरण के लिए डीएनए बनाम अंग्रेजी)
2. सुई की लंबाई

2010 का पेपर "द एक्जैक्ट स्ट्रिंग मैचिंग प्रॉब्लम: एक कॉम्प्रिहेंसिव एक्सपेरिमेंटल इवैलुएशन" 51 एल्गोरिदम (विभिन्न वर्णमाला आकार और सुई लंबाई के साथ) के लिए रनटाइम्स के साथ टेबल देता है, इसलिए आप अपने संदर्भ के लिए सबसे अच्छा एल्गोरिथ्म चुन सकते हैं।

उन सभी एल्गोरिदम में सी कार्यान्वयन है, साथ ही एक परीक्षण सूट यहां है:

http://www.dmi.unict.it/~faro/smart/algorithms.php

Answer 6

एक बहुत अच्छा सवाल। बस कुछ छोटे टुकड़े जोड़ें ...

1. कोई डीएनए अनुक्रम मिलान के बारे में बात कर रहा था। लेकिन डीएनए अनुक्रम के लिए, हम आमतौर पर जो करते हैं वह हैस्टैक के लिए एक डेटा संरचना (जैसे प्रत्यय सरणी, प्रत्यय ट्री या एफएम-इंडेक्स) का निर्माण करना है और इसके खिलाफ कई सुइयों का मिलान करना है। यह एक अलग सवाल है।

2. यह वास्तव में बहुत अच्छा होगा अगर कोई विभिन्न एल्गोरिदम को बेंचमार्क करना चाहेगा। संपीड़न और प्रत्यय सरणियों के निर्माण पर बहुत अच्छे बेंचमार्क हैं, लेकिन मैंने स्ट्रिंग मिलान पर एक बेंचमार्क नहीं देखा है। संभावित अभ्यर्थी SACA बेंचमार्क से हो सकते हैं ।

3. कुछ दिनों पहले मैं आपके द्वारा सुझाए गए पृष्ठ से बॉयर-मूर कार्यान्वयन का परीक्षण कर रहा था (EDIT: मुझे एक फ़ंक्शन कॉल की आवश्यकता है जैसे मेमम (), लेकिन यह एक मानक फ़ंक्शन नहीं है, इसलिए मैंने इसे लागू करने का निर्णय लिया है)। मेरे बेंचमार्किंग प्रोग्राम में यादृच्छिक हिस्टैक का उपयोग किया जाता है। ऐसा लगता है कि उस पृष्ठ में बॉयर-मूर कार्यान्वयन ग्लिब्क के मेममेम () और मैक के स्ट्रैन्स्ट्र () की तुलना में कई गुना तेज है। यदि आप रुचि रखते हैं, तो कार्यान्वयन यहाँ है और बेंचमार्किंग कोड यहाँ है । यह निश्चित रूप से एक यथार्थवादी बेंचमार्क नहीं है, लेकिन यह एक शुरुआत है।

Comments

यदि आपके पास SACA बेंचमार्क से अभ्यर्थियों के साथ परीक्षण करने के लिए कुछ अच्छी सुइयां हैं, तो उन्हें मेरे अन्य प्रश्न के उत्तर के रूप में पोस्ट करें और, एक बेहतर उत्तर प्राप्त करने से कम, मैं इसे स्वीकार करूंगा।

— R .. गिटहब स्टॉप हेल्पिंग ICE

आपके संस्मरण और बोयर-मूर के बारे में, यह बहुत संभावना है कि बॉयर-मूर (या बॉयर-मूर के संवर्द्धन में से एक) यादृच्छिक डेटा पर सबसे अच्छा प्रदर्शन करेगा। यादृच्छिक डेटा में आवधिकता और लंबे समय तक आंशिक मेल खाने की संभावना बहुत कम होती है, जो द्विघात सबसे खराब स्थिति की ओर ले जाती है। मैं बॉयर-मूर और टू-वे को मिलाने का तरीका ढूंढ रहा हूं या कुशलता से यह पता लगाने के लिए कि बॉयर-मूर "उपयोग करने के लिए सुरक्षित है", लेकिन अभी तक मुझे कोई सफलता नहीं मिली है। BTW मैं एक तुलना के रूप में glibc के संस्मरण का उपयोग नहीं करेगा। क्या वास्तव में glibc है के रूप में एक ही एल्गोरिथ्म का मेरा कार्यान्वयन कई बार तेज है।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

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

— user172818

Answer 7

मुझे पता है कि यह एक पुराना सवाल है, लेकिन सबसे खराब बदलाव तालिका एकल चरित्र हैं। यदि यह आपके डेटासेट के लिए समझ में आता है (उदाहरण के लिए यदि यह लिखित शब्द है), और यदि आपके पास स्थान उपलब्ध है, तो आप एकल वर्णों के बजाय n- ग्राम से बने खराब शिफ्ट टेबल का उपयोग करके नाटकीय गति प्राप्त कर सकते हैं।

Answer 8

Stdlib का उपयोग करें strstr:

char *foundit = strstr(haystack, needle);

यह बहुत तेज़ था, केवल मुझे टाइप करने में लगभग 5 सेकंड लगे।

Comments

और यदि आप मेरे प्रश्न को पढ़ते हैं, तो आप देखेंगे कि मैंने इसे समझने में बहुत आसान समय दिया है। मुझे आपके व्यंग्य काफी पसंद हैं, मैं -1 को छोड़ दूँगा।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

Answer 9

यहां से पूरे कोर में उपयोग किया गया पायथन का खोज कार्यान्वयन है । टिप्पणियों से संकेत मिलता है कि यह एक संकुचित बॉय-मूर डेल्टा 1 तालिका का उपयोग करता है ।

मैंने खुद को खोजने के लिए स्ट्रिंग के साथ कुछ बहुत व्यापक प्रयोग किए हैं, लेकिन यह कई खोज स्ट्रिंग्स के लिए था। हॉर्सपूल और बिटप के असेंबली कार्यान्वयन अक्सर कम पैटर्न की गणना के लिए अहो-कोरासिक जैसे एल्गोरिदम के खिलाफ अपने स्वयं के पकड़ कर सकते हैं ।

Answer 10

एक तेज़ "एकल मिलान वर्ण के लिए खोज" (ala strchr) एल्गोरिथ्म।

महत्वपूर्ण लेख:

• ये फ़ंक्शन एक "संख्या / गणना (अग्रणी | अनुगामी) शून्य" gccसंकलक आंतरिक- का उपयोग करते हैं __builtin_ctz। ये फ़ंक्शन केवल उन मशीनों पर तेज़ होने की संभावना है जिनके पास एक निर्देश है जो इस ऑपरेशन को निष्पादित करते हैं (यानी, x86, पीपीसी, आर्म)।

• इन कार्यों का अनुमान है कि आर्किटेक्चर 32 और 64 बिट अनलग्‍न लोड प्रदर्शन कर सकता है। यदि आपका लक्ष्य आर्किटेक्चर इसका समर्थन नहीं करता है, तो आपको रीड्स को ठीक से संरेखित करने के लिए कुछ स्टार्ट अप तर्क जोड़ने की आवश्यकता होगी।

• ये कार्य प्रोसेसर तटस्थ हैं। यदि लक्ष्य CPU में वेक्टर निर्देश हैं, तो आप बेहतर (बहुत) करने में सक्षम हो सकते हैं। उदाहरण के लिए, दstrlen नीचे दिया गया फ़ंक्शन SSE3 का उपयोग करता है और इसे अन्य रूप से देखने के लिए स्कैन किए गए बाइट्स को XOR को संशोधित किया जा सकता है 0। मैक ओएस एक्स 10.6 (x86_64) पर चलने वाले बेंचमार्क ने एक 2.66GHz कोर 2 लैपटॉप पर प्रदर्शन किया:

  • 843.433 एमबी / एस के लिए strchr
  • 2656.742 एमबी / एस के लिए findFirstByte64
  • 13094.479 एमबी / एस के लिए strlen

... एक 32-बिट संस्करण:

#ifdef __BIG_ENDIAN__
#define findFirstZeroByte32(x) ({ uint32_t _x = (x); _x = ~(((_x & 0x7F7F7F7Fu) + 0x7F7F7F7Fu) | _x | 0x7F7F7F7Fu); (_x == 0u)   ? 0 : (__builtin_clz(_x) >> 3) + 1; })
#else
#define findFirstZeroByte32(x) ({ uint32_t _x = (x); _x = ~(((_x & 0x7F7F7F7Fu) + 0x7F7F7F7Fu) | _x | 0x7F7F7F7Fu);                    (__builtin_ctz(_x) + 1) >> 3; })
#endif

unsigned char *findFirstByte32(unsigned char *ptr, unsigned char byte) {
  uint32_t *ptr32 = (uint32_t *)ptr, firstByte32 = 0u, byteMask32 = (byte) | (byte << 8);
  byteMask32 |= byteMask32 << 16;
  while((firstByte32 = findFirstZeroByte32((*ptr32) ^ byteMask32)) == 0) { ptr32++; }
  return(ptr + ((((unsigned char *)ptr32) - ptr) + firstByte32 - 1));
}

... और 64-बिट संस्करण:

#ifdef __BIG_ENDIAN__
#define findFirstZeroByte64(x) ({ uint64_t _x = (x); _x = ~(((_x & 0x7F7F7F7F7f7f7f7full) + 0x7F7F7F7F7f7f7f7full) | _x | 0x7F7F7F7F7f7f7f7full); (_x == 0ull) ? 0 : (__builtin_clzll(_x) >> 3) + 1; })
#else
#define findFirstZeroByte64(x) ({ uint64_t _x = (x); _x = ~(((_x & 0x7F7F7F7F7f7f7f7full) + 0x7F7F7F7F7f7f7f7full) | _x | 0x7F7F7F7F7f7f7f7full);                    (__builtin_ctzll(_x) + 1) >> 3; })
#endif

unsigned char *findFirstByte64(unsigned char *ptr, unsigned char byte) {
  uint64_t *ptr64 = (uint64_t *)ptr, firstByte64 = 0u, byteMask64 = (byte) | (byte << 8);
  byteMask64 |= byteMask64 << 16;
  byteMask64 |= byteMask64 << 32;
  while((firstByte64 = findFirstZeroByte64((*ptr64) ^ byteMask64)) == 0) { ptr64++; }
  return(ptr + ((((unsigned char *)ptr64) - ptr) + firstByte64 - 1));
}

2011/06/04 को संपादित करें ओपी टिप्पणियों में बताता है कि इस समाधान में एक "दुर्गम बग" है:

यह मांगे गए बाइट या अशक्त टर्मिनेटर को पढ़ सकता है, जो बिना पढ़े अनुमति के बिना किसी अनपेक्षित पृष्ठ या पृष्ठ तक पहुंच सकता है। जब तक वे संरेखित नहीं करते आप बस स्ट्रिंग फ़ंक्शन में बड़े रीड का उपयोग नहीं कर सकते।

यह तकनीकी रूप से सच है, लेकिन लगभग किसी भी एल्गोरिथ्म पर लागू होता है जो एक बाइट से बड़ा होता है, जिसमें टिप्पणियों में ओपी द्वारा सुझाई गई विधि भी शामिल है :

एक विशिष्ट strchrकार्यान्वयन भोला नहीं है, लेकिन जो आपने दिया था उससे काफी अधिक कुशल है। सबसे व्यापक रूप से उपयोग किए गए एल्गोरिथ्म के लिए इसका अंत देखें: http://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord

यह भी वास्तव में संरेखण प्रति से कुछ नहीं करना है। सच है, यह संभवतः उपयोग में सामान्य आर्किटेक्चर के बहुमत पर चर्चा किए गए व्यवहार का कारण बन सकता है, लेकिन माइक्रोऑर्किटेक्चर कार्यान्वयन विवरण के साथ ऐसा करने के लिए और अधिक है - अगर अनलॉन्ग रीड एक 4K सीमा (फिर से, विशिष्ट) को स्ट्रैडल करता है, तो वह रीड एक प्रोग्राम का कारण बनेगा यदि अगले 4K पेज की सीमा अनमैप्ड है, तो दोषपूर्ण समाप्ति।

लेकिन यह उत्तर में दिए गए एल्गोरिथ्म में "बग" नहीं है- यह व्यवहार इसलिए है क्योंकि फ़ंक्शन जैसे हैं strchrऔर खोज के आकार को बाध्य करने के लिए strlenएक lengthतर्क को स्वीकार नहीं करते हैं। खोज करना char bytes[1] = {0x55};, जो कि हमारी चर्चा के प्रयोजनों के लिए बस एक 4K वीएम पेज सीमा के बहुत अंत में रखा जाना है और अगला पृष्ठ अनमैप्ड है, strchr(bytes, 0xAA)(जहां strchrएक बाइट-ए-ए-टाइम कार्यान्वयन है) बिल्कुल दुर्घटनाग्रस्त हो जाएगा उसी तरह। strchrसंबंधित चचेरे भाई के लिए Ditto strlen।

एक lengthतर्क के बिना , यह बताने का कोई तरीका नहीं है कि आपको उच्च गति एल्गोरिथ्म से कब स्विच करना चाहिए और एक बाइट-बाय-बाइट एल्गोरिथ्म पर वापस जाना चाहिए। बहुत अधिक संभावना है कि "बग" को "आबंटन के आकार के अतीत" को पढ़ना होगा, जो तकनीकी रूप undefined behaviorसे विभिन्न सी भाषा मानकों के अनुसार परिणाम देता है , और कुछ की तरह त्रुटि के रूप में चिह्नित किया जाएगा valgrind।

संक्षेप में, कुछ भी जो बाइट चंक्स की तुलना में बड़े पैमाने पर संचालित होता है, तेजी से जाने के लिए, जैसा कि यह उत्तर कोड करता है और ओपी द्वारा बताया गया कोड है, लेकिन बाइट-सटीक पढ़ा हुआ शब्दार्थ भी होना चाहिए, यदि कोई lengthतर्क नहीं है, तो "छोटी गाड़ी" हो सकती है। "अंतिम पठन" के कोने के मामले को नियंत्रित करें।

इस उत्तर में कोड एक प्राकृतिक CPU शब्द आकार चंक में पहला बाइट खोजने में सक्षम होने के लिए एक कर्नेल है यदि लक्ष्य CPU में ctzनिर्देश जैसा तेज़ है। यह सुनिश्चित करने के लिए तुच्छ है कि यह सुनिश्चित करता है कि यह केवल सही ढंग से संरेखित प्राकृतिक सीमाओं, या कुछ प्रकार के lengthबाउंड पर संचालित होता है, जो आपको उच्च गति कर्नेल से बाहर निकलने और एक धीमी बाइट-बाइट चेक की अनुमति देता है।

ओपी टिप्पणियों में यह भी बताता है:

आपके ctz ऑप्टिमाइज़ेशन के लिए, यह केवल O (1) टेल ऑपरेशन के लिए अंतर करता है। यह छोटे तार के साथ प्रदर्शन में सुधार कर सकता है (उदाहरण के लिए, strchr("abc", 'a');लेकिन निश्चित रूप से किसी बड़े आकार के तार के साथ नहीं।

यह कथन सही है या नहीं, यह प्रश्न में माइक्रोआर्किटेक्चर पर बहुत हद तक निर्भर करता है। विहित 4 चरण RISC पाइपलाइन मॉडल का उपयोग करना, तो यह लगभग निश्चित रूप से सच है। लेकिन यह बताना बेहद कठिन है कि क्या यह एक समकालीन आउट-ऑफ-ऑर्डर सुपर स्केलर सीपीयू के लिए सच है, जहां कोर गति पूरी तरह से मेमोरी स्ट्रीमिंग गति को बौना कर सकती है। इस मामले में, यह न केवल प्रशंसनीय है, बल्कि काफी सामान्य है, क्योंकि "निर्देशों की संख्या जो सेवानिवृत्त हो सकती है" में "बाइट्स की संख्या" को स्ट्रीम किया जा सकता है "के सापेक्ष एक बड़ा अंतर है" ताकि आपके पास "हो।" प्रत्येक बाइट के लिए जो निर्देश दिए जा सकते हैं, उन्हें स्ट्रीम किया जा सकता है "। यदि यह पर्याप्त बड़ा है, तो ctz+ शिफ्ट निर्देश "मुफ्त में" किया जा सकता है।

Comments

"लंबाई 1 की सुइयों के लिए, का उपयोग करें strchr।" - आपने सबसे तेजी से प्रतिस्थापन खोज एल्गोरिथ्म (ओं) के लिए कहा। लंबाई 1 का विकल्प खोजना एक विशेष मामला है, जिसे अनुकूलित भी किया जा सकता है। यदि आप अपने वर्तमान विशेष केस कोड को लंबाई 1 ( strchr) के उपर्युक्त की तरह कुछ चीजों के साथ स्वैप करते हैं , तो चीजें strchrतेजी से लागू होती हैं (संभवत: इस पर निर्भर करता है)। उपरोक्त एल्गोरिथ्म एक सामान्य भोले strchrकार्यान्वयन की तुलना में लगभग 3x तेज है ।

— जॉनी

ओपी ने कहा कि स्ट्रिंग को अच्छी तरह से समाप्त कर दिया गया था, इसलिए आपकी चर्चा char bytes[1] = {0x55};अप्रासंगिक है। बहुत प्रासंगिक है आपकी टिप्पणी किसी भी शब्द रीड एल्गोरिथ्म के लिए यह सच है जो पहले से लंबाई नहीं जानता है।

— सेठ रॉबर्टसन

समस्या मेरे द्वारा उद्धृत संस्करण पर लागू नहीं होती है क्योंकि आप इसे केवल संरेखित बिंदुओं पर उपयोग करते हैं - कम से कम यही सही कार्यान्वयन करते हैं।

— R .. गिटहब स्टॉप हेल्पिंग ICE

@R, इसका "एलाइड पॉइंटर्स" से कोई लेना-देना नहीं है। हाइपोथेटिक रूप से, यदि आपके पास एक आर्किटेक्चर था जो बाइट स्तर की ग्रैन्युलैरिटी के साथ वीएम सुरक्षा का समर्थन करता mallocथा , और प्रत्येक आवंटन दोनों तरफ "पर्याप्त रूप से गद्देदार" था और वीएम सिस्टम ने उस आबंटन के लिए बाइट ग्रैन्युलर प्रोटेक्शन लागू किया था .... चाहे पॉइंटर गठबंधन किया गया हो (या नहीं) तुच्छ 32-बिट intप्राकृतिक संरेखण मान लेना ) मूट है- आवंटन के आकार के अतीत को पढ़ने के लिए उस संरेखित रीड के लिए अभी भी संभव है। आबंटन का आकार पिछले किसी भी रीडिंग है undefined behavior।

— जोहने

@ जोहान: +1 टिप्पणी करने के लिए। वैचारिक रूप से आप सही हैं, लेकिन वास्तविकता यह है कि बाइट-ग्रेन्युलैरिटी प्रोटेक्शन दोनों को स्टोर करने और लागू करने के लिए इतना महंगा है कि वे मौजूद नहीं हैं और कभी भी मौजूद नहीं होंगे। यदि आप जानते हैं कि अंतर्निहित भंडारण पेज-ग्रैन्युलैरिटी मैपिंग के बराबर से प्राप्त होता है mmap, तो संरेखण पर्याप्त है।

— आर .. गिटहब स्टॉप हेल्पिंग ICE

Answer 11

बस "सबसे तेज़ स्ट्रैस" की खोज करें, और यदि आपको कुछ दिलचस्पी दिखाई दे तो बस मुझसे पूछें।

मेरे विचार में आप अपने आप पर बहुत अधिक प्रतिबंध लगाते हैं (हाँ हम सभी अधिकतम खोजकर्ता को सब-लीनियर चाहते हैं), हालाँकि इसमें कदम रखने के लिए एक वास्तविक प्रोग्रामर लगता है, तब तक मुझे लगता है कि हैश दृष्टिकोण बस एक निफ्टी-लिम्बो समाधान है ( अच्छी तरह से छोटे 2..16 पैटर्न के लिए BNDM द्वारा प्रबलित)।

बस एक त्वरित उदाहरण:

के रूप में-एक-पंक्ति स्ट्रिंग (206908949bytes) में पैटर्न (32bytes) के लिए खोज हो रहा है ... छोड़ें-प्रदर्शन (बड़ा-बेहतर): 3041%, 6,801,754 स्किप / पुनरावृत्तियों Railgun_Quadruplet_7Hasherezade_hits / Railgun_Quadruplet_7Hasherezade_clocks: 0/58 Railgun_Quadruplet_7Hasherezade प्रदर्शन: 3483KB / घड़ी

1554%, 13,307,181 बार और / पुनरावृत्तियों Boyer_Moore_Flensburg_hits / Boyer_Moore_Flensburg_clocks: 0/83 के रूप में-एक-पंक्ति ... छोड़ें-प्रदर्शन (बड़ा-बेहतर) स्ट्रिंग (206908949bytes) में पैटर्न (32bytes) के लिए खोज कर रहा Boyer_Moore_Flensburg प्रदर्शन: 2434KB / घड़ी

स्ट्रिंग (206908949bytes) में पैटर्न (32bytes) को एक-पंक्ति के रूप में खोज करना ... Skip-Performance (बड़ा-बेहतर): 129%, 160239051 स्केप / पुनरावृत्तियाँ Two-Way_h_t / Two-Way_clocks: 0/816 Two -तरह प्रदर्शन: 247KB / घड़ी

सनमय,
सादर

Answer 12

टू-वे एलगोरिदम जिसका आप अपने प्रश्न में उल्लेख करते हैं (जो कि अविश्वसनीय है!) को हाल ही में एक समय में मल्टीबाइट शब्दों पर कुशलता से काम करने के लिए बेहतर बनाया गया है: इष्टतम पैक स्ट्रिंग मिलान ।

मैंने पूरे पेपर को नहीं पढ़ा है, लेकिन ऐसा लगता है कि वे अपने समय की जटिलता के दावे के लिए नए, विशेष सीपीयू निर्देशों (जैसे एसएसई 4.2 में शामिल) ओ (1) पर भरोसा करते हैं, हालांकि अगर वे उपलब्ध नहीं हैं तो वे कर सकते हैं उन्हें w-bit शब्दों के लिए O (लॉग लॉग डब्ल्यू) समय में अनुकरण करें जो बहुत बुरा नहीं लगता है।

Answer 13

आप 4 अलग-अलग एल्गोरिदम को लागू कर सकते हैं, कह सकते हैं। प्रत्येक M मिनट (अनुभवजन्य रूप से निर्धारित किया जाना है) सभी 4 को वास्तविक वास्तविक डेटा पर चलाते हैं। एन रन (टीबीडी) पर भी आंकड़े जमा करें। फिर अगले एम मिनट के लिए केवल विजेता का उपयोग करें।

जीत पर आँकड़े लॉग करें ताकि आप उन एल्गोरिदम को बदल सकें जो कभी नए के साथ नहीं जीतते हैं। जीतने वाली दिनचर्या पर अनुकूलन प्रयासों को केंद्रित करें। हार्डवेयर, डेटाबेस, या डेटा स्रोत में किसी भी परिवर्तन के बाद आँकड़ों पर विशेष ध्यान दें। आँकड़ों में उस जानकारी को शामिल करें यदि संभव हो तो लॉग करें, इसलिए आपको लॉग डेट / टाइम-स्टैम्प से इसका पता नहीं लगाना होगा।

Answer 14

मैंने हाल ही में विभिन्न उपलब्ध एल्गो के प्रदर्शन को मापने के लिए एक अच्छा उपकरण खोजा है: http://www.dmi.unict.it/~faro/smart/index.php

आपको यह उपयोगी लग सकता है। इसके अलावा, अगर मुझे खोज एल्गोरिथ्म के विकल्प पर त्वरित कॉल करना है, तो मैं नथ-मॉरिस-प्रैट के साथ जाऊंगा।

Comments

लिंक के लिए धन्यवाद। परीक्षण ठेठ-मामले के समय के लिए दिलचस्प लगते हैं, लेकिन सबसे खराब समय को पकड़ने के लिए नहीं।

— R .. गिटहब स्टॉप हेल्पिंग ICE

Answer 15

आप कई प्रकार के तारों के साथ विविध बेंचमार्क भी रखना चाह सकते हैं, क्योंकि इससे प्रदर्शन पर काफी प्रभाव पड़ सकता है। अल्गोस प्राकृतिक भाषा की खोज के आधार पर अलग-अलग प्रदर्शन करेंगे (और यहां तक ​​कि अलग-अलग मोर्फोलोजी के कारण अभी भी ठीक दाने वाले भेद हो सकते हैं), डीएनए तार या यादृच्छिक तार आदि।

सुई आकार के रूप में वर्णमाला का आकार कई अल्गों में भूमिका निभाएगा। उदाहरण के लिए हॉर्सपूल अंग्रेजी पाठ पर अच्छा करता है, लेकिन अलग-अलग वर्णमाला के आकार के कारण डीएनए पर खराब होता है, जिससे बुरे चरित्र के नियम के लिए जीवन कठिन हो जाता है। अच्छे प्रत्यय का परिचय यह काफी हद तक प्रदान करता है।

Answer 16

मुझे नहीं पता कि यह सबसे अच्छा है, लेकिन मुझे बॉयर-मूर के साथ अच्छा अनुभव है ।

Comments

क्या आप बॉय-मूर की खराब शिफ्ट टेबल को टू-वे से मिलाने का एक तरीका जानते हैं? ग्लिबैक लंबी सुइयों (> 32 बाइट) के लिए इसका एक प्रकार करता है, लेकिन केवल अंतिम बाइट की जांच करता है। समस्या यह है कि टू-वे को बाएं से दाएं सुई के दाहिने हिस्से की खोज करने की आवश्यकता है, जबकि बॉयर-मूर की खराब शिफ्ट दाएं-बाएं से खोजते समय सबसे अधिक कुशल है। मैंने इसे टू-वे (लेफ्ट-टेबल या सामान्य टू-वे राइट हाफ मिसमैच, जो भी लंबा हो) द्वारा बाएं-से-दाएं के साथ उपयोग करने की कोशिश की, लेकिन मुझे ज्यादातर मामलों में 5-10% की सामान्य दो-वे की मंदी मिली। ऐसे किसी भी मामले का पता नहीं लगा सकता है जहां उसने प्रदर्शन को बेहतर बनाया

— R .. गिटहब स्टॉप हेल्पिंग ICE

Answer 17

यह सीधे सवाल का जवाब नहीं देता है लेकिन यदि पाठ बहुत बड़ा है, तो इसे अतिव्यापी वर्गों में कैसे विभाजित किया जाए (पैटर्न की लंबाई के आधार पर ओवरलैप), फिर एक साथ थ्रेड्स का उपयोग करके अनुभागों को खोजें। सबसे तेज़ एल्गोरिथम के संबंध में, बोयर-मूर-हॉर्सपूल मुझे लगता है कि सबसे तेज़ में से एक है अगर बॉयर-मूर के वेरिएंट में सबसे तेज़ नहीं है। मैंने इस विषय में एल्गोरिथ्म को बीएमएच (बॉयर-मूर-होर्सपूल) खोज की तुलना में तेजी से बॉयर-मूर संस्करण (मैं उनका नाम नहीं जानता) के एक जोड़े को पोस्ट किया ।

Answer 18

सबसे तेज वर्तमान में ईपीएसएम है, एस। फारू और ओम कुल्स्की द्वारा। Http://www.dmi.unict.it/~faro/smart/algorithms.php?algorithm=EPSM&code=epsm देखें

SIMD SSE4.2 (x86_64 और anarch64) के लिए अनुकूलित "सटीक पैक्ड स्ट्रिंग मिलान"। यह सभी आकारों पर स्थिर और सर्वश्रेष्ठ प्रदर्शन करता है।

साइट मैं 199 फास्ट स्ट्रिंग खोज एल्गोरिदम की तुलना करने के लिए जुड़ा हुआ था, सामान्य लोगों के साथ (बीएम, केएमपी, बीएमएच) बहुत धीमी गति से हो रहा है। ईपीएसएम इन प्लेटफॉर्म पर यहां बताए जा रहे अन्य सभी को बेहतर बनाता है। यह भी नवीनतम है।