CODEWITHSUNDEEP
common-lisphashtable
Nex
Nex

Reputation: 1633

Common lisp hashtable

Task is to read N string like "name phone" and store in. Then find stored data with requests like "name". My code stores names and numbers in hashtable, but after it doesn't find any values. Stored values checks with maphash (it shows all pairs key-value).

Function split-by-one-space is just utility.

(defparameter data (make-hash-table))

(defun split-by-one-space (string) ; to split string: "aaa bbb" -> (aaa bbb)
    (loop for i = 0 then (1+ j)
          as j = (position #\Space string :start i)
          collect (subseq string i j)
          while j))

(dotimes (i (read)) ; input data
    (let* ((inp (read-line))
           (raw (split-by-one-space inp))
           (name (string (car raw)))
           (phone (cadr raw)))
         (format t "Adding: ~W ~W~%" name phone) ; debug
         (setf (gethash name data) phone)))
(maphash #'(lambda (k v) (format t "~a => ~a~%" k v)) data) ; this show all stored data
(loop for line = (read-line *standard-input* nil :eof)
      until (or (eq line :eof) (eq line nil))
      do
      (let ((key (gethash line data))) ; it cannot find anything. Why?
           (format t "Searching: ~W~%" line) ; debug
           (if (null key)
               (format t "Not found~%")
               (format t "~A=~A~%" (car key) (cdr key)))))

Sample input:

3
sam 99912222
tom 11122222
harry 12299933
sam
edward
harry

Upvotes: 2

Views: 1178

Answers (1)

Vatine
Vatine

Reputation: 21288

Unless you specify a test function, hash tables will use eql to determine "is this key identical to that key".

(defvar *s1* "a string")
(defvar *s2* "a string")
(loop for pred in '(eq eql equal equalp)
  do (format t "Using ~a, the result is ~a~%"
     pred (funcall pred *s1* *s2*)))

This generates the output:

Using EQ, the result is NIL
Using EQL, the result is NIL
Using EQUAL, the result is T
Using EQUALP, the result is T

In this case, the main difference between equal and equalp is that the latter is case-insensitive, while the former is not. To use another test function, use the :test keyword and one of the found "standard" test functions. If you don't need case-insensitive matches, you would simply create your hash table like this: (make-hash-table :test #'equal).

Upvotes: 5

Related Questions