% Review:

mem(X,[X|_]).
mem(X,[_|R]) :- mem(X,R).

% A version of 'reverse' which requires 'removeLast' and 'last':
reverse([],[]).
reverse([F|R],L2) :- last(L2,F), removeLast(L2,L2less), reverse(R,L2less).

%  removeLast, Last -- not included in notes, 
%  since it's part of hw05  !!

%% Alternate version: An accumulator variable:
reverse(L1,L2) :- reverseHelp( L1, [], L2 ).

reverseHelp([],Acc,Acc).
reverseHelp([F|R],Acc,Out) :- reverseHelp(R,[F|Acc],Out).


filterSmallerThan(Threshold,[],[]).
filterSmallerThan(Threshold,[F|R],SmallerRest) :- 
      F >= Threshold, 
      filterSmallerThan(Threshold,R,SmallerRest).
filterSmallerThan(Threshold,[F|R],[F|SmallerRest]) :- 
      F < Threshold, 
      filterSmallerThan(Threshold,R,SmallerRest).


%%%%%%%%%%%%%%
% Sorting:
% We'll just provide the 'spec':
% L2 is a sorted version of L1 if:
%  - L1 is a permutation (re-arrangement) of L2, and
%  - L2 is in ascending order (er, non-decreasing).

scrapSort(L1,L2) :- permutation(L1,L2), nondecreasing(L2).
 
% Here're the helper functions:

nondecreasing([]).
nondecreasing([_]).
nondecreasing([F,S|R]) :- F=<S, nondecreasing([S|R]).


badPerm1([],[]).
badPerm1([F|R],Y) :- append2(Y1,[F|Y2],Y), 
                     append2(Y1,Y2,PY), 
                     badPerm1(R,PY).
% This is a correct *specification* of permutation.
% However, it has several drawbacks:
% (a) written non-intuitively,
% (b) using is a sledgehammer (poor performance too),
% (c) it only half-works, in Prolog:
%    badPerm1([3,4,5],[5,3,4]) is true
% but
%    badPerm1([3,4,5],X) gives only *one* answer
%    and then loops forever.
% However, it works 'in reverse':
%    badPerm1(X,[3,4,5]) gives all solutions.

badPerm2([],[]).
badPerm2([F|R],Y) :- remove(F,Y,Z), badPerm2(Z,R).
%
% This is also a correct spec,
% and it fixes drawbacks (a) and (b), 
% but still suffers from (c).
% In fact, it's worse: badPerm2 no longer
% works in reverse -- badPerm2(X,[3,4,5]) gives
% *two* (?!) solutions, and then backtracks
% into la-la land.

% Here's a fully-working version:
% like badPerm2 except that it destructures the *return* value.
%
permutation([],[]).
permutation(X,[F|R]) :- remove(F,X,Z), permutation(Z,R).

remove(F,[F|L1],L1).
remove(F,[G|L1],[G|L2]) :- remove(F,L1,L2).

% Reflecting on scrapSort:
%   Consider the *order* of solutions
%   permutation([3,4,5],X) and permutation([5,4,3],X).
% How many permutations does scrapSort([3,4,5],X) look at?
% How about scrapSort ([5,4,3],X) look at?
%
% Now, consider this problem amplified:
%     scrapSort([8,7,6,5,4,3,2,1],X) runs okay. But
% But scrapSort([10,9,8,7,6,5,4,3,2,1],X) takes a while.
%
% The name "scrapSort" was chosen because its performance
% is a piece of scrap: O(n!).







% Ironically, 'quicksort' is more straightforward than 'scrapsort',
% even though we specify *how* to sort rather than *what sorted means*.
%


%  QuickSort
%  Author: Varesano Fabio
%  http://www.varesano.net/blog/fabio/quick+sort+implemented+prolog

/* [+,-] */
quicksort([], []).
quicksort([HEAD | TAIL], SORTED) :- partition(HEAD, TAIL, LEFT, RIGHT),
                                    quicksort(LEFT, SORTEDL),
                                    quicksort(RIGHT, SORTEDR),
                                    append(SORTEDL, [HEAD | SORTEDR], SORTED).

/* [+,+,-,-] */
partition(PIVOT, [], [], []).
partition(PIVOT, [HEAD | TAIL], [HEAD | LEFT], RIGHT) :- HEAD @=< PIVOT,
                                                         partition(PIVOT, TAIL, LEFT, RIGHT).
partition(PIVOT, [HEAD | TAIL], LEFT, [HEAD | RIGHT]) :- HEAD @> PIVOT,
                                                         partition(PIVOT, TAIL, LEFT, RIGHT).

/* [+,+,-] */
append([], LIST, LIST).
append([HEAD | LIST1], LIST2, [HEAD | LIST3]) :- append(LIST1, LIST2, LIST3).







% Here is a another, more verbose version
% (the version I started writing myself ... 
% Note that I'm used to partitioning into three sections,
% so that we always *reduce* the size of a partition
% (even if our pivot is the maximum value).
% Study the above sol'n, to see how the Prolog
% makes sure we always recur on smaller lists (even
% when the pivot is the maximum value).

qsort([],[]).
qsort([F|R],L2) :- partition([F|R],F,Sm,Eq,Lr), 
                   qsort(Sm,SmSorted), 
		   qsort(Lr,LrSorted), 
	           append3(SmSorted,Eq,LrSorted,L2).

partition([],_,[],[],[]).
partition([F|R],Pivot,Smaller,Equal,Larger) :- 
  F<Pivot,
  Smaller = [F|SmallerRest],
  partition(R,Pivot,SmallerRest,Equal,Larger).
partition([F|R],Pivot,Smaller,Equal,Larger) :- 
  F=Pivot, 
  Equal = [F|EqualRest],
  partition(R,Pivot,Smaller,EqualRest,Larger).
partition([F|R],Pivot,Smaller,Equal,Larger]) :- 
  F>Pivot, 
  Larger = [F|LargerRest],
  partition(R,Pivot,Smaller,Equal,LargerRest).


append3(L1,L2,L3,All) :- append2(L1,L2,L1and2), append2(L1and2,L3,All).
append2([],L2,L2).
append2([F|R],L2,[F|AllRest]) :- append2(R,L2,AllRest).




/*****************
 Reflections/thoughts on prolog:
  * The idea of declarative programming is cool:
    Just by specifying what *constitutes* a correct answer,
    you can write a program (and often it's efficient).
  + Sometimes though, it's too inefficient (scrapSort).
  + Worse though: to really write Prolog, you need to
    thoroughly understand *how* it implements searching
    (badPerm).

  + Seeing how different 'cultures' compute is mind-expanding;
  * Pattern matching: Way cool!  
    This is something *any* language can use
    (ML, Haskell; Scheme has a 'match' library).
  * The idea of specifying correctness of an answer
    (separately from an algorithm)
    makes me a better [Java, whatever] programmer:
    often having a clean spec of correctness
    leads directly to clean, correct code.
 *****************/