Vigenere

Pascal J. Bourguignon wrote:

tristanhennequin <tristanhennequin@free.fr> writes:
 

Hello,
I 've just read the vigenere implementation published on rosetta code :
 
I think it's very long and maybe clumsy.

 
It's also wrong.
 

(defun strip (s)
  (remove-if-not
    (lambda (c) (char<= #\A c #\Z))
    (string-upcase s)))

 
There may be non alphabetic characters between A and Z.  This functions
rightfully doesn't use alpha-char-p, (because alpha-char-p may contain
implementation defined characters), but it is wrong in using this simple
comparison.  Since we only want letters from A to Z, we must write it
explicitely (or, possibly check that only letters from A to Z are
between A and Z, but I have my doubts if this check can be done at
compilation time).
 
So:
 
(defparameter alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
 
(defun strip (s)
  (remove-if-not (lambda (c) (find (char-upcase c) alphabet)) s)
 
 
 

(defun vigenère (s key &key decipher
&aux (A (char-code #\A))
     (op (if decipher #'- #'+)))

 
Personnally, I don't like using &aux for stylistic reasons (it puts in
the signature of the function details that belong to the implementation.
It's very rare to find a case where having those variable in the
signature is justified.  &aux is basically a ugly hack to do stuff in
struct constructors).
 
 

  (labels
    ((to-char (c) (code-char (+ c A)))
     (to-code (c) (- (char-code c) A)))

 
Again, this part makes a lot of assumptions that may be wrong.  A better
implementation is:
 
      (to-char (code) (aref     code alphabet))
      (to-code (char) (position char alphabet))
 

    (let ((k (map 'list #'to-code (strip key))))
      (setf (cdr (last k)) k)
      (map 'string
   (lambda (c)
     (prog1
       (to-char
(mod (funcall op (to-code c) (car k)) 26))
       (setf k (cdr k))))
   (strip s)))))

 
This is not bad.  What you can do here, is to use pop:
 
    (map 'string
           (lambda (c) (to-char (mod (funcall op (to-code c) (pop k)) 26)))
           (strip s))
 
 

(let* ((msg "Beware the Jabberwock... The jaws that... the claws that
catch!")
       (key "vigenere cipher")
       (enc (vigenère msg key))
       (dec (vigenère enc key :decipher t)))
  (format t "msg: ~a~%enc: ~a~%dec: ~a~%" msg enc dec))
 
 

 

What is the most concise and short version of the vigenere encryption
method can you produce in lisp?

 
(defparameter alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
 
(defun strip-non-letters (string)
  (remove-if-not (lambda (c) (find (char-upcase c) alphabet)) string))
 
(defun ensure-circular (list)
  (setf (cdr (last list)) list))
 
(defun vigenère (text key &key decipher) 
  (flet ((to-char (code) (aref     alphabet code))
         (to-code (char) (position char alphabet :test (function char-equal))))
    (declare (inline to-char to-code))
    (let ((op      (if decipher (function -) (function +)))
          (offsets (ensure-circular (map 'list (function to-code) (strip-non-letters key)))))
      (map 'string
           (lambda (c) (to-char (mod (funcall op (to-code c) (pop offsets)) 26)))
           (strip-non-letters text)))))
 
  (let* ((msg "Beware the Jabberwock... The jaws that... the claws that catch!")
         (key "vigenere cipher")
         (enc (vigenère msg key))
         (dec (vigenère enc key :decipher t)))
    (format t "msg: ~a~%enc: ~a~%dec: ~a~%" msg enc dec))
 
 
msg: Beware the Jabberwock... The jaws that... the claws that catch!
enc: WMCEEIKLGRPIFVMEUGXXYILILZXYVBZLRGCEYAIOEKXIZGU
dec: BEWARETHEJABBERWOCKTHEJAWSTHATTHECLAWSTHATCATCH
--> nil

Gauche Scheme

(use srfi-1) ;; circular-list

(define alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ")

(define (text->list str)
  (filter-map
    (lambda (c)
      (let ((x (char-upcase c))) (string-scan alphabet x)))
    (string->list str)))

(define (list->text lst)
  (list->string
    (map
      (lambda (n) (string-ref alphabet n))
      lst)))
 
(define (vig text key encrypt?)
  (list->text
    (map
      (lambda(n k) (mod ((if encrypt? + -) n k) 26))
      (text->list text)
      (apply circular-list (text->list key)))))

(vig "Beware the Jabberwock... The jaws that... the claws that catch!"
  "vigenere cipher" #t)
  ===>
"WMCEEIKLGRPIFVMEUGXXYILILZXYVBZLRGCEYAIOEKXIZGU"

(vig "WMCEEIKLGRPIFVMEUGXXYILILZXYVBZLRGCEYAIOEKXIZGU"
  "vigenere cipher" #f)
  ===>
"BEWARETHEJABBERWOCKTHEJAWSTHATTHECLAWSTHATCATCH"

(vig "W M C E EIKLGRPIFVMEUGXXYILILZXYVBZLRGCEYAIOEKXIZGU"
  "vigenere cipher" #f)
  ===>
"BEWARETHEJABBERWOCKTHEJAWSTHATTHECLAWSTHATCATCH"