在列表中找到最大值並在列表中找到對

Question

我是Haskell中的新成員，但我在Prolog中編寫了此解決方案。

第一個：我必須創建函數或幾個函數，它們會在列表中找到最大值。我想爲該解決方案重寫我的Prolog函數，或者如果您知道該任務更簡單的解決方案，請在下面寫下。

輸入：someFunc [1,2,3,3,3,4,4,4,5,5]輸出：[3,4]

輸入：someFunc [1,2,2,3- ，4,5]輸出：[2]

的Prolog代碼：

listMax(L, M) :- listMax(L, [], [], M). 

listMax([], Seen, MMax, Max) :- 
    (MMax == [] -> 
    Max = Seen 
    ; listMax(MMax, [], [], Max)). 

listMax([H|T], Seen, MMax, Max) :- 
    (member(H, Seen) -> 
    listMax(T, Seen, [H|MMax], Max) 
    ; listMax(T, [H|Seen], MMax, Max)). 

二之一：我要創建機能的研究或幾個功能，將發現，被重複多次，所述一對在列表中的元素。

輸入：someFunc [2,2,2,2,3,3,3,4,4,5]輸出：[2,4]

輸入：someFunc [1,1,2,2- ，2,3,3]輸出：[1,3]

的Prolog代碼：

count([], _, 0). 
count([H|T], H, R) :- count(T, H, RT), R is RT + 1. 
count([H|T], X, R) :- H \= X, count(T, X, R). 

add_if_count_is_one(H, T, H) :- count(T, H, C), 0 is (C+1) mod 2. 
add_if_count_is_one(H, T, []) :- count(T, H, C), 0 is C mod 2. 
add_if_count_is_one(H, T, []) :- count(T, H, 0). 

num_pairs([], []). 
num_pairs([H|T], [H1|T1]) :- 
    delete(T, H, TT), 
    num_pairs(TT, T1), 
    add_if_count_is_one(H, T, H1). 

listPair(M, RR):- 
    num_pairs(M, R), 
    delete(R,[],RR). 

Answer 1

第二個問題可以通過使用一些高階函數在Data.List解決：

import Data.List 

numPair :: [Integer] -> [Integer] 
numPair xs = map head (filter (even . length) (groupBy (==) xs)) 

演示ghci：

ghci > numPair [2,2,2,2,3,3,3,4,4,5] 
[2,4] 
ghci > numPair [1,1,2,2,2,3,3] 
[1,3] 

您可以使用類似的技術來解決你的其他問題。瀏覽Data.List中的函數以熟悉它。

Answer 2

該代碼實現這兩個兩個功能：

import Data.List 

-- Case 1 
maxOccurrence :: (Ord a) => [a] -> [a] 
maxOccurrence = (map head) . last . occurenceGroup 

-- Case 2 
maxOccurrenceNumber :: (Ord a) => [a] -> [(a, Int)] 
maxOccurrenceNumber = 
    (map (\l -> (head l, length l))) . 
    last . occurenceGroup 

-- Common function 
occurenceGroup :: (Ord a) => [a] -> [[[a]]] 
occurenceGroup = 
     (groupBy (cmp (==))) . (sortBy (cmp compare)) . 
     group . sort 
    where 
     cmp op = \a b -> op (length a) (length b) 

即occurenceGroup將

1. 排序和分組通過其元素的值的參數列表，相同的值這個元素之後將在相同的組
2. 按照其元素的長度對第一步的結果進行排序和分組，之後相同長度的元素將在同一組中

occurenceGroupoccurenceGroup重新排列其參數列表中的元素後，這兩個函數的實現都很簡單，它們只取occurenceGroup結果的最後一個元素，並提取或計算他們需要的信息。

---

以下是完整的測試程序：

import Data.List 

maxOccurrence :: (Ord a) => [a] -> [a] 
maxOccurrence = (map head) . last . occurenceGroup 

maxOccurrenceNumber :: (Ord a) => [a] -> [(a, Int)] 
maxOccurrenceNumber = 
    (map (\l -> (head l, length l))) . 
    last . occurenceGroup 

occurenceGroup :: (Ord a) => [a] -> [[[a]]] 
occurenceGroup = 
     (groupBy (cmp (==))) . (sortBy (cmp compare)) . 
     group . sort 
    where 
     cmp op = \a b -> op (length a) (length b) 

---- 

lst11, lst12, lst21, lst22 :: [Int] 
lst11 = [1,2,3,3,3,4,4,4,5,5] 
lst12 = [1,2,2,3,4,5] 
lst21 = [2,2,2,2,3,3,3,4,4,5] 
lst22 = [1,1,2,2,2,3,3] 

main = do 
     putStrLn "Case 1:" 
     output lst11 
     output $ maxOccurrence lst11 
     output lst12 
     output $ maxOccurrence lst12 
     putStrLn "Case 2:" 
     output lst21 
     output $ maxOccurrenceNumber lst21 
     output lst22 
     output $ maxOccurrenceNumber lst22 
    where output lst = putStrLn $ show lst