These are the most common mistakes that I have taken points off for. 
Since so many students had done this, I thought I should better put 
up an explanation before being bombarded with questions.

1> Sortlist: This was supposed to be done in O(nlogn) For this, it is 
imperative that you break the list in half at every step, then sort 
recursively and merge. Otherwise, this results in O(n^2) operations. 
Most people took out the first element from the list, sorted the rest 
and merged the results. This way you are reducing the length of the 
list by 1 everytime, leading to n recursive calls. Thus the total 
complexity comes out to be the sum of n merge steps; 
ie. n + (n-1) + (n-2) + ... + 1 = n(n+1)/2 -> O(n^2)

2> Dup: I cannot think of any smart way to do this in O(nlogn) without 
using a sort first. Once the list is sorted, you can check consecutive 
elements in a single pass to check if there is a duplication. This leads 
to O(nlogn) + O(n) -> O(nlogn) operations, assuming of course you did 
the sort in no more than O(nlogn) steps. For those people whom I penalized, 
the following is essentially what you do. You look at the first element of 
the list, check if it occurs anywhere in the rest of the list and recurse 
with the cdr. In the case of an unsuccessful search, it leads to the same 
analysis as above --- n-1 comparisons for the first element, n-2 for the 
second, n-3 for the third all the way down to 1 for the penultimate element. 
This again is O(n^2) operations.

3> Duplist_of_lists: This is exactly the same as above. Just the operator 
that you use to compare the elements of the list is different.

If you still have questions, please talk to me.