Имеется список слов. Составить список различных слов этого списка с указанием частоты их появления в списке

(defun count-word (pathname)
  (let ((u)) (with-open-file (s pathname :direction :input)
               (do ((c (read-line s nil :eof) (read-line s nil :eof)))
                   ((eql c :eof))
                 (setq u (nconc (en c) u))))
       (qu u)))
 
(defun en (s) 
  (read-from-string
   (concatenate
    'string "(" (delete-if-not #'(lambda (x)
                                   (or (alpha-char-p x)
                                       (equal x #\space)
                                       (equal x #\-)))
                               s) ")")))
 
(defun qu (w)
  (when w (let ((a (car w)) (d (cdr w)))
            (cons (cons (string-downcase a) (count a w))
                  (qu (delete a d))))))
 
> (count-word "test.txt")
(("less" . 5) ("de-facto" . 1))

(defun count-word (pathname)
  (let ((u)) (with-open-file (s pathname :direction :input)
               (do ((c (read-line s nil :eof) (read-line s nil :eof)))
                   ((eql c :eof))
                 (setq u (nconc (list-symb (drop-noise c)) u))))
       (list-pair (sort u #'string<))))
 
(defun list-symb (s)
  (read-from-string (concatenate 'string "(" s ")")))
 
(defun drop-noise (s)
  (delete-if-not #'(lambda (x) (or 
                                (alpha-char-p x)
                                (equal x #\space)
                                (equal x #\-))) s))
 
(defun list-pair (w &optional (e (car w)) (n 0) u)
  (mapcan #'(lambda (a) (incf n) (unless (eql a e)
                                   (setq u (cons e n) n 0 e a)
                                   (list u)))
          w))
 
> (count-word "test.txt")
(LEGAL . 1) (LEGALLY . 2)

(defun count-word (pathname)
  (with-open-file (s pathname :direction :input)
    (loop for line = (read-line s nil nil)
          while line
          nconc (list-symb (drop-noise line)) into words
          finally (return (sort (list-pair words) #'> :key #'cdr)))))
 
(defun list-symb (s)
  (read-from-string (concatenate 'string "(" s ")")))
 
(defun drop-noise (s)
  (delete-if-not #'(lambda (x) (or 
                                (alpha-char-p x)
                                (equal x #\space)
                                (equal x #\-))) s))
 
(defun list-pair (words &aux (hash (make-hash-table)) acc)
  (dolist (word words) (incf (gethash word hash 0)))
  (maphash #'(lambda (e n) (push `(,e . ,n) acc)) hash) acc)
 
> (count-word "test.txt")
((ANNEXED . 1))

(defun count-word (pathname)
  (let ((u)) (with-open-file (s pathname :direction :input)
               (do ((c (read-line s nil :eof) (read-line s nil :eof)))
                   ((eql c :eof))
                 (setq u (nconc (en c) u))))
       (symb-str u)))
 
(defun en (s) 
  (read-from-string
   (concatenate 
    'string "(" (delete-if-not #'(lambda (x)
                                   (or (alpha-char-p x)
                                       (equal x #\space)
                                       (equal x #\-)))
                               s) ")")))
 
(defun symb-str (w)
  (let ((u)) (dolist(n w)
               (push (string-downcase n) u))
       (count-str (sort u #'string-greaterp))))
 
(defun count-str (w)
  (let ((u) (e (car w)) (n 1))
    (dolist (m w)
      (cond ((equal m e) (incf n))
            ((push (cons e n) u) (setq n 1 e m))))
    u))
 
> (count-word "test.txt")
(("along" . 3) ("already" . 3))

(defun count-word (pathname)
  (let ((u)) (with-open-file (s pathname :direction :input)
               (do ((c (read-line s nil :eof) (read-line s nil :eof)))
                   ((eql c :eof))
                 (setq u (nconc (list-symb (drop-noise c)) u))))
       (list-pair (list-str u))))
 
(defun list-symb (s)
  (read-from-string (concatenate 'string "(" s ")")))
 
(defun drop-noise (s)
  (delete-if-not #'(lambda (x) (or 
                                (alpha-char-p x)
                                (equal x #\space)
                                (equal x #\-))) s))
 
(defun list-str (w)
  (sort (mapcar #'(lambda (a) (string-downcase a)) w) #'string-lessp))
 
(defun list-pair (w &optional (e (car w)) (n 0) u)
  (mapcan #'(lambda (a) (incf n) (when (string-not-equal a e)
                                   (setq u (cons e n) n 0 e a)
                                   (list u)))
          w))
 
> (count-word "test.txt")
(("balance" . 1) ("based" . 1))

(defun list-pair (words &aux (hash (make-hash-table)) acc)
  (dolist (word words) (incf (gethash word hash 0)))
  (maphash #'(lambda (e n) (push `(,e . ,n) acc)) hash) acc)
 
> (list-pair '(lisp is the second-oldest high-level programming language in widespread use today lisp has changed since its early days and many dialects have existed over its history today the best known general-purpose Lisp dialects are common lisp and scheme))
((LISP . 4) (IS . 1) (THE . 2) (SECOND-OLDEST . 1) (HIGH-LEVEL . 1)
 (PROGRAMMING . 1) (LANGUAGE . 1) (IN . 1) (WIDESPREAD . 1) (USE . 1)
 (TODAY . 2) (HAS . 1) (CHANGED . 1) (SINCE . 1) (ITS . 2) (EARLY . 1)
 (DAYS . 1) (AND . 2) (MANY . 1) (DIALECTS . 2) (HAVE . 1) (EXISTED . 1)
 (OVER . 1) (HISTORY . 1) (BEST . 1) (KNOWN . 1) (GENERAL-PURPOSE . 1)
 (ARE . 1) (COMMON . 1) (SCHEME . 1))

(defun task (lst-words)
  (let* ((ul (setof lst-words))
         (ln (length lst-words)))
    (mapcar (lambda (w) (list w (- ln (length (remove w lst-words))))) ul)))
 
==> TASK
 
(task '("жив" "и" "я" "привет" "тебе" "привет"))
 
==> (("жив" 1) ("и" 1) ("я" 1) ("тебе" 1) ("привет" 2))

(defun task (text)
  (let* ((lst-words (strWords text))
         (ul (setof lst-words))
         (ln (length lst-words)))
    (mapcar (lambda (w) (list w (- ln (length (remove w lst-words))))) ul)))
 
==> TASK
 
(task "Ты жива еще моя старушка? Жив и я привет тебе привет")
 
==> (("Ты" 1) ("жива" 1) ("еще" 1) ("моя" 1) ("старушка?" 1) ("Жив" 1) ("и" 1) ("я" 1) ("тебе" 1) ("привет" 2))

(require '[clojure.string :as str])
 
(defn word-count-in-seq [word words-seq]
  (count (filter #(= % word) words-seq))
  )
 
(defn word-freq [sentence]
  (let [splitted (str/split sentence #"\s")
        freq-seq (atom [])]
       (doseq [word splitted]
              (if (= (count (filter #(= word (get % 0)) @freq-seq)) 0)
                  (swap! freq-seq conj [word (word-count-in-seq word splitted)])
                  ))
       @freq-seq
       ))
 
(word-freq "Привет че как? Привет")
;[["Привет" 2] ["че" 1] ["как?" 1]]