हास्केल में एक स्ट्रिंग दूसरे से छोटा है या नहीं, यह जांचने के लिए कैसे करें?

Question

मेरे पास दो स्ट्रिंग्स हैं जो हास्केल फ़ंक्शन के लिए तर्क के रूप में दिए गए हैं।

s1s2 से छोटी है अगर s1 से कम s2 है या वे एक ही लंबाई है और s1 कोषगत s2 से छोटी है, तो।

मैं इसे हास्केल में कैसे कार्यान्वित करूं?

Answer 1

मैं था के साथ छड़ी का सुझाव: विश्वविद्यालय पिछले सप्ताह है, और हम इस सुंदर विकल्प Ord उदाहरण के साथ आया था निम्नलिखित की तरह कुछ का उपयोग करें:

smaller :: String -> String -> Bool 
smaller s1 s2 | len1 /= len2   = (len1 < len2) 
       | otherwise   = (s1 < s2) 
       where (len1, len2) = (length s1, length s2) 

यहाँ, एक नमूना रन है हग्स में:

 
Main> smaller "b" "aa" 
True 
Main> smaller "aa" "b" 
False 
Main> smaller "this" "that" 
False 
Main> smaller "that" "this" 
True 

Answer 2

इस प्रयास करें:

compare s1 s2 

(यह रिटर्न एलटी, EQ, या जी.टी.)।

Answer 3

StringOrd का एक उदाहरण है और इसलिए आप स्ट्रिंग की तुलनात्मक रूप से तुलना करने के लिए उन सभी विधियों का उपयोग कर सकते हैं। जैसा कि एंड्रयू ने कहा, यह अनिवार्य रूप से compare है लेकिन तुलना ऑपरेटर, (<) दूसरों के बीच भी है।

smaller :: Ord a => a -> a -> Bool 
smaller a b = a < b 

यह सभी प्रकारOrd लागू करने के लिए काम करता है (और (<) के लिए वास्तव में सिर्फ एक कच्चे आवरण है), String भी शामिल है।

Answer 4

सामान्य स्ट्रिंग की तुलना केवल लेक्सिकोोग्राफ़िकल ऑर्डरिंग पर काम करती है, स्ट्रिंग की लंबाई नहीं।

smaller :: String -> String -> Bool 
smaller s1 s2 | length s1 < length s2 = True 
       | length s1 > length s2 = False 
       | otherwise    = s1 < s2 

या थोड़ा अधिक सामान्य:

compareStrings :: String -> String -> Ordering 
compareStrings s1 s2 | length s1 < length s2 = LT 
        | length s1 > length s2 = GT 
        | otherwise    = compare s1 s2 

उदाहरण:

ghci> compare "ab" "z" 
LT 
ghci> compareStrings "ab" "z" 
GT 

---

तो तुम भी लंबाई के लिए जाँच करने के लिए अपने स्वयं के समारोह लिखने के लिए होगा

हम मोनोइड्स के साथ घूम रहे थे

instance Ord a => Ord [a] where 
    compare = comparing length 
       `mappend` comparing head `mappend` comparing tail 

लेकिन अगर आप काफी यह समझ में नहीं आता, मैं तुम्हें पहले परिभाषा ;-)

Answer 5

एक-पास समाधान:

lengthcompare :: Ord a => [a] -> [a] -> Ordering 
lengthcompare = lc EQ 
where 
    lc lx [] [] = lx 
    lc _ [] _ = LT 
    lc _ _ [] = GT 
    lc EQ (v:vs) (w:ws) = lc (compare v w) vs ws 
    lc lx (_:vs) (_:ws) = lc lx vs ws 

smaller :: Ord a => [a] -> [a] -> Bool 
smaller s1 s2 = lengthcompare s1 s2 == LT 

Answer 6

टॉम Lokhorst द्वारा mappend संस्करण का एक छोटा संस्करण से ऊपर:

import Data.Monoid (mappend) 
import Data.Ord (comparing) 

compareStrings :: String -> String -> Ordering 
compareStrings = comparing length `mappend` comparing id 

एक और तरीका है, tuples के आदेश का लाभ लेने:

import Data.Ord (comparing) 
import Control.Arrow ((&&&)) 

compareStrings :: String -> String -> Ordering 
compareStrings = comparing (length &&& id)