regexp for elisp

In Emacs I would like to write some regexp that does the following:

First, return a 开发者_运维百科list of all dictionary words that can be formed within "hex space". By this I mean:

#000000 - #ffffff

so #00baba would be a word (that can be looked up in the dictionary)

so would #baba00

and #abba00

and #0faded

...where trailing and leading 0's are considered irrelevant. How would I write this? Is my question clear enough?

Second, I would like to generate a list of words that can be made using numbers as letters:

• 0 = o
• 1 = i
• 3 = e
• 4 = a

...and so on. How would I write this?

First, load your dictionary. I'll assume that you're using /var/share/dict/words, which is nearly always installed by default when you're running Linux. It lists one word per line, which is a very handy format for this sort of thing.

Next run M-x keep-lines. It'll ask you for a regular expression and then delete any line that doesn't match it. Use the regex ^[a-f]\{,6\}$ and it will filter out anything that can't be part of a color.

Specifically, the ^ makes the regex start at the beginning of the line, the [a-f] matches any one character that is between a and f (inclusive), the {,6} lets it match between 0 and 6 instances of the previous item (in this case the character class [a-f] and finally the $ tells it that the next thing must be the end of the line.

This will return a list of all instances of #000000 - #ffffff in the buffer, although this pattern may not be restrictive enough for your purposes.

(let ((my-colour-list nil))
  (save-excursion
    (goto-char (point-min))
    (while (re-search-forward "#[0-9a-fA-F]\\{6\\}" nil t)
      (add-to-list 'my-colour-list (match-string-no-properties 0)))
    my-colour-list))

I'm not actually certain that this is what you were asking for. What do you mean by "dictionary"?

A form that will return you a hash table with all the elements you specify in it could be this:

(let ((hash-table (make-hash-table :test 'equal)))
  (dotimes (i (exp 256 3))
    (puthash (concat "#" (format "%06x" i)) t hash-table))
  hash-table)

I'm not sure how Emacs will manage that size of elements (16 million). As you don't want the 0, you can generate the space without that format, and removing trailing 0's. I don't know what do you want to do with the rest of the numbers. You can write the function step by step like this then:

(defun find-hex-space ()
 (let (return-list)
  (dotimes (i (exp 256 3))
    (let* ((hex-number (strip-zeros (format "%x" i)))
           (found-word (gethash hex-number *dictionary*)))
      (if found-word (push found-word return-list))))
  return-list))

Function strip-zeros is easy to write, and here I suppose your words are in a hash called *dictionary*. strip-zeros could be something like this:

(defun strip-zeros (string)
  (let ((sm (string-match "^0*\\(.*?\\)0*$" string)))
    (if sm (match-string 1 string) string)))

I don't quite understand your second question. The words would be also using the hex space? Would you then consider only the words formed by numbers, or would also include the letters in the word?