(опрфун список-в-гистограмму* (список гистограмма)
        (если (пуст список) гистограмма
              (отныне ((голова-списка (первый-элемент список))
                       (хвост-списка (остаток список))
                       (элемент-гистограммы (элемент гистограмма))
                       (число-вхождений (элемента-в гистограмма)))
                      (если (совпадает голова-списка элемент-гистограммы)
                            (список-в-гистограмму* хвост-списка (составить (составить элемент-гистограммы (+ 1 число-вхождений)) (остаток гистограмма))) 
                            (список-в-гистограмму* хвост-списка (составить (составить голова-списка 1) гистограмма))))))


(опрфун список-в-гистограмму (список)
        (перевернуть (список-в-гистограмму* список NIL)))

* (список-в-гистограмму '())

NIL
*  (список-в-гистограмму '(1 1 1 1 2 2 2 3 4 4 5))

((1 . 4) (2 . 3) (3 . 1) (4 . 2) (5 . 1))

(defmacro опрфун (&body body)
  `(defun ,@body))

(defmacro пуст (body)
  `(null ,body))

(defmacro совпадает (&body body)
  `(eq ,@body))

(defmacro если (condition &body body)
  `(if ,condition ,@body))

(defmacro первый-элемент (&body body)
  `(car ,@body))

(defmacro остаток (&body body)
  `(cdr ,@body))

(defmacro элемент (&body body)
  `(caar ,@body))

(defmacro элемента-в (&body body)
  `(cdar  ,@body))

(defmacro отныне (&body body)
  `(let ,@body))

(defmacro составить (&body body)
  `(cons ,@body))

(defmacro перевернуть (&body body)
  `(nreverse ,@body))

(defun l2h* (source dest)
  (if (null source) dest
      (let* ((hs (car source))
             (ht (cdr source))
             (hd (caar dest))
             (hdn (cdar dest)))
        (if (eq hs hd)
            (l2h* ht (cons (cons hd (+ 1 hdn)) (cdr dest))) 
            (l2h* ht (cons (cons hs 1) dest))))))

(defun l2h (ss)
  (nreverse (l2h* ss NIL)))

int count_length_of_chain(int a[], int start_index, int length)
{
    if (start_index == length - 1)
        return 1;

    int start = a[start_index];

    int step = 1;

    int current_index = start_index + step;
    int current = a[current_index];

    while (current == start) {
        step *= 2;
        current_index += step;
        if (current_index > length - 1) {
            current_index = length - 1;
            current = a[current_index];
            break;
        }
        current = a[current_index];
    }

    while (current > start) {
        current_index = current_index - 1;
        current = a[current_index];
    }

    return current_index - start_index + 1;
}

int count_length_of_chain(int a[], int start_index, int length)
{
    if (start_index == length - 1)
        return 1;

    int start = a[start_index];

    int step = 1;

    int current_index = start_index + step;
    int current = a[current_index];

    while (current == start) {
        step *= 2;
        current_index += step;
        if (current_index > length - 1) {
            current_index = length - 1;
            current = a[current_index];
            break;
        }
        current = a[current_index];
    }

    while (current > start) {
        current_index = current_index - 1;
        current = a[current_index];
    }

    return current_index - start_index + 1;
}

int count_length_of_chain(int a[], int start_index, int length)
{
    if (start_index == length - 1)
        return 1;

    int start = a[start_index];

    int step = 1;

    int current_index = start_index + step;
    int current = a[current_index];

    while (current == start) {
        current_index += step;
        if (current_index > length - 1) {
            current_index = length - 1;
            current = a[current_index];
            break;
        }
        current = a[current_index];
    }

    return current_index - start_index + 1;
}

list_of_pairs count_elements_freqs(int a[], int length)
{
    int current_index = 0;
    int current_length;
    int current;

    list_of_pairs result;

    while (current_index < length)
    {
        current = a[current_index];
        current_length = count_length_of_chain(a, current_index, length);

        result->add_pair(current, current_length);

        current_index += current_length;
    }

    return r;
}

count_length_of_chain(int *, int)[[/code]] - два быстрых, и один стандартный. Может есть косяки, но зато легко понять, и идея понятна.