list - ट्यूपल्स की सूची में सभी न्यूनतम तत्वों को कैसे खोजें?




haskell minimum (4)

मैं किसी सूची में सभी न्यूनतम तत्व कैसे पा सकता हूं? अभी मेरे पास ट्यूपल्स की सूची है, अर्थात

[(10,'a'),(5,'b'),(1,'c'),(8,'d'),(1,'e')]

इसलिए मुझे आउटपुट चाहिए जो सूची के सभी न्यूनतम तत्व हैं, एक नई सूची में। उदाहरण के लिए

 [(1,'c'),(1,'e')]

मैंने कोशिश की

minimumBy (comparing fst) xs

लेकिन वह केवल पहला न्यूनतम तत्व देता है।


आप इसे foldr से भी आसानी से कर सकते हैं:

minimumsFst :: Ord a => [(a, b)] -> [(a, b)]
minimumsFst xs = go (minfst xs) xs
  where
  go mn ls = foldr (\(x, y) rs -> if (x ==  mn) then (x,y) : rs else rs) [] xs
  minfst ls = minimum (map fst ls)

अपने उदाहरण के साथ:

   minimumsFst [(10,'a'),(5,'b'),(1,'c'),(8,'d'),(1,'e')]
=> [(1,'c'),(1,'e')]

आपके द्वारा पहले मूल्य का न्यूनतम प्राप्त करने के बाद, हम इन वस्तुओं पर सूची को फ़िल्टर कर सकते हैं। क्योंकि आप यहां न्यूनतम वस्तुओं की एक सूची प्राप्त करना चाहते हैं, हम खाली सूची को लौटाने के साथ ही खाली सूची को भी कवर कर सकते हैं:

minimumsFst :: Ord a => [(a, b)] -> [(a, b)]
minimumsFst [] = []
minimumsFst xs = filter ((==) minfst . fst) xs
    where minfst = minimum (map fst xs)

उदाहरण के लिए:

Prelude> minimumsFst [(10,'a'),(5,'b'),(1,'c'),(8,'d'),(1,'e')]
[(1,'c'),(1,'e')]

एक लाइन। कुंजी छँट रही है।

Prelude Data.List> let a = [(1,'c'),(2,'b'),(1,'w')]
Prelude Data.List> (\xs@((m,_):_) -> takeWhile ((== m) . fst ) xs) . sortOn fst $ a
[(1,'c'),(1,'w')]

यहां एक समाधान है जो एक पास में काम करता है (यहां अन्य अधिकांश उत्तर दो पास करते हैं: एक न्यूनतम मूल्य खोजने के लिए और एक उस पर फ़िल्टर करने के लिए), और कुशल होने के लिए छंटाई कार्यों को कैसे लागू किया जाता है, इस पर भरोसा नहीं करता है।

{-# LANGUAGE ScopedTypeVariables #-}

import Data.Foldable (foldl')

minimumsBy :: forall a. (a -> a -> Ordering) -> [a] -> [a]
minimumsBy _ [] = []
minimumsBy f (x:xs) = postprocess $ foldl' go (x, id) xs
  where
    go :: (a, [a] -> [a]) -> a -> (a, [a] -> [a])
    go acc@(x, xs) y = case f x y of
      LT -> acc
      EQ -> (x, xs . (y:))
      GT -> (y, id)
    postprocess :: (a, [a] -> [a]) -> [a]
    postprocess (x, xs) = x:xs []

ध्यान दें कि [a] -> [a] मैं यहाँ [a] -> [a] प्रकार का उपयोग कर रहा हूँ उसे एक अंतर सूची , उर्फ ह्यूजेस सूची कहा जाता है।





minimum