;;; My solution 

;; fancy-most returns `count' (default 2) functions with the highest score
;; fn - test function which gives a score

(defun fancy-most (fn lst &key (count 2))
  (let ((scores (mapcar #'(lambda (x) (cons x (funcall fn x))) lst)))
    (values-list (mapcar #'car (subseq (sort scores #'> :key #'cdr) 0 count)))))
    
;; test 
(fancy-most #'length '((a b) (a b c) (a))) ; => (A B C), (A B) 	      


;; Someone else's solution, possibly more efficient?

(defun most (fn lst)
  (if (null lst)
      (values nil nil)
      (if (= (length lst) 1)
        (values (car lst) nil)
        (let* ((wins (if (> (funcall fn (car lst)) (funcall fn (cadr lst)))
                         (car lst)
                         (cadr lst)))
               (wins2 (if (> (funcall fn (car lst)) (funcall fn (cadr lst)))
                         (cadr lst)
                         (car lst))))
          (dolist (obj (cdr (cdr lst)))
            (let ((score (funcall fn obj)))
              (if (> score (funcall fn wins))
                (setf wins2 wins
                      wins  obj)
                (if (> score (funcall fn wins2))
                  (setf wins2 obj)))))
          (values wins wins2)))))

(most #'length '((a b) (a b c) (a))) ; => (A B C), (A B)