क्या "स्ट्रिंग युक्त एक्स" विधि लिखने का कोई बेहतर तरीका है?

Question

बस हास्केल का उपयोग करके देखा और महसूस किया (जहां तक ​​मैं कह सकता हूं) स्ट्रिंग को जांचने के लिए कोई सीधा तरीका नहीं है यह देखने के लिए कि इसमें एक छोटी स्ट्रिंग है या नहीं। तो मैंने सोचा कि मैं बस उस पर एक शॉट ले जाऊंगा।

अनिवार्य रूप से विचार यह जांचना था कि दोनों तार एक ही आकार के थे और बराबर थे। यदि स्ट्रिंग की जांच की जा रही थी, तो सिर की बार-बार लूप थी और स्ट्रिंग की जांच होने तक जांच को फिर से चलाएं।

बाकी संभावनाएं मैंने उन्हें संभालने के लिए पैटर्न का उपयोग किया। यही वह है जिसके साथ मैं आया:

stringExists "" wordToCheckAgainst = False 
stringExists wordToCheckFor "" = False 
stringExists wordToCheckFor wordToCheckAgainst | length wordToCheckAgainst < length wordToCheckFor = False 
               | length wordToCheckAgainst == length wordToCheckFor = wordToCheckAgainst == wordToCheckFor 
               | take (length wordToCheckFor) wordToCheckAgainst == wordToCheckFor = True 
               | otherwise = stringExists wordToCheckFor (tail wordToCheckAgainst) 

Answer 1

क्या आपने Hoogle चेक किया था?

यदि आप उस फ़ंक्शन के हस्ताक्षर की खोज करते हैं जिसे आप ढूंढ रहे हैं (String -> String -> Bool) आपको शीर्ष परिणामों में isInfixOf देखना चाहिए।

Answer 2

Data.List से isInfixOf निश्चित रूप से समस्या का समाधान होगा, हालांकि लंबे समय तक haystacks या perverse¹ सुइयों के मामले में आप और अधिक उन्नत string matching algorithms एक बेहतर औसत और सबसे ज्यादा मामले जटिलता के साथ विचार करना चाहिए।

---

एक बहुत लंबा केवल a से मिलकर स्ट्रिंग की और a का एक बहुत के साथ एक सुई 'शुरुआत में और एक b अंत में विचार करें ¹।

Answer 3

अपनी टेक्स्ट-प्रोसेसिंग आवश्यकताओं के लिए text package (हैकेज पर text, अब हास्केल प्लेटफॉर्म का हिस्सा भी) का उपयोग करने पर विचार करें। यह एक यूनिकोड टेक्स्ट प्रकार प्रदान करता है, जो अधिक समय-और अंतर्निहित सूची-आधारित String की तुलना में अंतरिक्ष-कुशल है। स्ट्रिंग सर्च के लिए, text पैकेज implementsBoyer-Moore-based algorithm, जिसमें Data.List.isInfixOf द्वारा उपयोग की जाने वाली भद्दा विधि की तुलना में बेहतर जटिलता है।

प्रयोग उदाहरण:

Prelude> :s -XOverloadedStrings 
Prelude> import qualified Data.Text as T 
Prelude Data.Text> T.breakOnAll "abc" "defabcged" 
[("def","abcged")] 
Prelude Data.Text> T.isInfixOf "abc" "defabcged" 
True