Bir dizginin Haskell'de diğerinden daha küçük olup olmadığını nasıl kontrol edebilirim?

Question

Haskell işlevine argüman olarak verilen iki dizim var.

s1s1 daha kısa s2 ise daha küçük s2 veya aynı uzunluğa sahiptir ve s1 sözlük sırasında s2 daha küçüktür.

Bunu Haskell'de nasıl uygularım?

Answer 1

Ben istiyorum sopa ile öneririz: üniversite geçen hafta ve biz bu güzel alternatif Ord örneği ile geldi aşağıdaki gibi bir şey kullanın:

İşte

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

Hugs içinde, örnek bir çalışma var:

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

Answer 2

bu deneyin:

compare s1 s2 

(Bu LT, EQ veya GT döner).

Answer 3

String, Ord'un bir örneğidir ve bu nedenle, sözdizimsel olarak dize karşılaştırmak için tüm bu yöntemleri kullanabilirsiniz. Andrew'un dediği gibi, bu aslında compare ama aynı zamanda karşılaştırma operatörleri, diğerleri arasında (<).

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

Bu Ord uygulayan her türlü için çalışıyor (ve (<) için gerçekten sadece bir ham sarıcı) String dahil.

Answer 4

Normal dize karşılaştırması, yalnızca dizgilerin uzunluğu değil, sözlüksel sıralamayla çalışır.Daha genel

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

Veya biraz:

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

Örnek:

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

---

yüzden de uzunluk için kontrol etmek için kendi işlevi yazmak zorunda kalacak

Monoids ile etrafta dolaşıyorduk

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

oldukça bu anlamıyorum Ama eğer ben ilk tanım ;-)

Answer 5

tek geçişli çözüm:

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

Tom Lokhorst tarafından mappend sürümünün bir kısa versiyonu yukarıda:

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

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

başka yolu da, dizilerini sipariş yararlanarak:

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

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