prolog 是 X 数字 A、B、C 的中位数

Question

I am having a bit of trouble with prolog as I have just started learning it. I am unsure how to test if X is the median of A, B, C. My first thought was to make a list of A, B, C and then sort it. I would then check if X is equal to the second number. The problem being that I don't know how to take three values and turn them into a list (If you can). Is this even the most effecent way to do this? Honestly I have no Idea so any insite would be helpful.

Answer 1

this is a very basic solution, with a sorting only accepting 3 values, but it should make the problem solved.

  is_median_of_sorted([_, ValueToCheck, _],ValueToCheck).

  sorted_list_of_3([A,B,C],R) :- 
      A>B, A>C, B>C, R = [A,B,C];
      A>C, A>B, C>B, R = [A,C,B];
      B>A, B>C, A>C, R = [B,A,C];
      B>C, B>A, C>A, R = [B,C,A];
      C>A, C>B, A>B, R = [C,A,B];
      C>B, C>A, B>A, R = [C,B,A].

  is_median_of_3(List, ValueToCheck) :-
      sorted_list_of_3(List,SortedList),
      is_median_of_sorted(SortedList, ValueToCheck).

To check it, query:

    is_median_of_3([1,10,4],4). 

Or if you want to check what is the median of a given list:

    is_median_of_3([1,10,4],X).

You can also check it via browser at: https://swish.swi-prolog.org/p/three_values_median.pl

What is does is : is_median_of_3 first gets a matching sorted list, and then checks agains is_median_of_sorted , which just picks a 2nd element of the list.

Hope I could help.

Answer 2

If you want to create a modular program, you had to insert all the elements in a list, sort it and find the median. This could be done in this way:

findMedian([H|_],0,H):- !.
findMedian([_|T],C,X):-
    C1 is C-1,
    findMedian(T,C1,X).

median(L,X):-
    msort(L,SortedL),
    length(SortedL,Len),
    Len2 is Len//2,
    findMedian(SortedL,Len2,X).

?- median([1,10,4,5,7],X).
X = 5
?- median([1,10,4,5,7],5).
true

This solution will works also with list with an even number of elements, returning the element after the middle of the list (ex. 4 elements, [0,1,2,3] , it returns 2 ). In this case you have to decide what to do (fail, return the two elements in the middle ecc...)

EDIT: as suggested in the comment, you should use msort/2 instead sort/2 because sort/2 removes duplicated elements.

Answer 3

I would choose a solution similar to @damianodamiano's, but I would find the middle element of a list without using length/2 :

median(List, Median) :-
    msort(List, SortedList),
    middle_element(SortedList, SortedList, Median).

middle_element([], [M|_], M).
middle_element([_], [M|_], M).
middle_element([_,_|Xs], [_|Ys], M) :-
    middle_element(Xs, Ys, M).

Answer 4

A simple answer to " check if X is the median of A,B,C? " is:

is_median_of_3(A,B,C,X):-
    msort([A,B,C],[_,X,_]).

This will try to match if [A,B,C] sorted consists of any list (of three elements) with X as the middle element.

---

I don't know everywhere, but in swish there are residuals coming out from msort as such:

msort([2,8,4],L).



L = [2, 4, 8],
_residuals = []

L = [2, 4, 8],
_residuals = [_1080]

L = [2, 4, 8],
_residuals = [_1122, _1128]

L = [2, 4, 8],
_residuals = [_1170, _1176, _1182]

L = [2, 4, 8],
_residuals = [_1224, _1230, _1236, _1242]

L = [2, 4, 8],
_residuals = [_1284, _1290, _1296, _1302, _1308]

L = [2, 4, 8],
_residuals = [_716, _722, _728, _734, _740, _746]

L = [2, 4, 8],
_residuals = [_788, _794, _800, _806, _812, _818, _824]

L = [2, 4, 8],
_residuals = [_866, _872, _878, _884, _890, _896, _902, _908]

and so on...

Also, I couldn't test it in tutorialspoint because it seems broken.

Answer 5

Following a generate & test approach you can write:

median(List,Median) :-
    dif(List,[]), msort(List,SList), length(List,Len),
    append(Low,[Median],Tmp), append(Tmp,High,SList),
    length(Low,LowLen), div(Len,2)=:=LowLen, !.

This has a convenient declarative reading: Median is the value of a non-empty List that splits the sorted version SList of List into two halves Low and High , viz. Median is the "middle element" of the distribution of the values in List .

Indeed, the program above determines Median by checking whether SList can be written as a list concatenation Low + [Median] + High such that the length of Low is half the length of SList . Since High is never used (ie it is a singleton), the program can be rewritten by substituting it with _ as in:

median(List,Median) :-
    dif(List,[]), msort(List,SList), length(List,Len),
    append(Low,[Median],Tmp), append(Tmp,_,SList),
    length(Low,LowLen), div(Len,2)=:=LowLen, !.

Naturally, it is also possible to distinguish the case in which the length of the list is odd from the case it is even, so to return the average of the two median elements in the latter case:

median(List,Median) :-
    is_list(List), dif(List,[]), 
    msort(List,SList), length(List,Len),
    median(SList,Len,Median).
    
median(SList,Len,Median) :-
    Len mod 2 =:= 1, 
    append3(Low,[Median],_,SList),
    length(Low,LowLen), div(Len,2)=:=LowLen, !.
median(SList,Len,Median) :-
    Len mod 2 =:= 0, 
    append3(Low,[M1,M2],_,SList),
    length(Low,LowLen), div(Len,2)=:=LowLen + 1,
    Median is (M1+M2)/2, !.

append3(L1,L2,L3,L) :- append(L1,L2,T), append(T,L3,L).