दो तारों के लंबे समय तक लौटने का सुरुचिपूर्ण तरीका

Question

मैं एक ऐसा फ़ंक्शन लिखने की कोशिश कर रहा हूं जो दो तारों का लंबा समय लौटाए। अभी तक यह है कि मैं क्या है:

maxString :: String -> String -> String 
maxString a b 
    | (length a) > (length b) = a 
    | otherwise = b 

यह काम करता है, लेकिन अगर वहाँ एक और अधिक सुरुचिपूर्ण तरीका यह लिखना है मैं सोच रहा हूँ। नोट: दो तर्क एक सूची में नहीं हो सकते हैं। करी के लिए अनुमति देने के लिए उन्हें अलग तर्क होना चाहिए।

विचार?

Answer 1

यह लिखने का सबसे संक्षिप्त तरीका है। हालांकि, नीचे दिया गया संस्करण तब भी समाप्त हो जाएगा जब एक सूची अनंत है (ओ (न्यूनतम (ए, बी)) ओ (ए + बी) के बजाय)।

इसके अलावा, वहाँ जब यह मनमाना सूचियों के लिए कोई मतलब होता है सिर्फ तार करने के लिए अपने समारोह को सीमित करने के लिए कोई वास्तविक कारण नहीं है।

Answer 2

आप Data.Ord और Data.Function में हास्केल सुविधाओं मौजूदा का उपयोग करें और एक एक लाइनर प्राप्त इस प्रकार कर सकते हैं:

maxString' x y = maximumBy (compare `on` length) [x, y] 

कोड:

import Data.Ord 
import Data.Function 
import Data.List 

maxString' x y = maximumBy (compare `on` length) [x, y] 

*Main> maxString' "ab" "c" 
"ab" 

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

के रूप में @ डेविड यॉन्ग ने इंगित किया,

compare `on` length 

ऊपर भी एक छोटा रूप में लिखा जा सकता है: comparing length

Answer 3

अब तक Tejing के सिवाय सभी जवाब पूरी तरह से दोनों बहस बढ़ावा देते हैं। यह केवल छोटे के अंत तक ही जाता है।

longest a b = l' a b where 
    l' _ [] = a 
    l' [] _ = b 
    l' (_:ar) (_:br) = l' ar br 

Answer 4

इस के साथ चारों ओर खेला गया। मैं चाहता था कि यह एक लाइनर हो और जटिलता O(min(n,m)) हो। (यानि अनंत सूची के साथ भी काम कर रहे हैं)

maxList :: [a] -> [a] -> [a] 
maxList s s' = if s == zipWith const s s' then s' else s