anchor.diff:          (for (values score winner) = (score i))
           (finding winner :maximizing score)))))
   
  +(defun problem-51 ()
  +  ;; By replacing the 1st digit of the 2-digit number *3, it turns out that six
  +  ;; of the nine possible values: 13, 23, 43, 53, 73, and 83, are all prime.
  +  ;;
  +  ;; By replacing the 3rd and 4th digits of 56**3 with the same digit, this
  +  ;; 5-digit number is the first example having seven primes among the ten
  +  ;; generated numbers, yielding the family: 56003, 56113, 56333, 56443, 56663,
  +  ;; 56773, and 56993. Consequently 56003, being the first member of this
  +  ;; family, is the smallest prime with this property.
  +  ;;
  +  ;; Find the smallest prime which, by replacing part of the number (not
  +  ;; necessarily adjacent digits) with the same digit, is part of an eight prime
  +  ;; value family.
  +  (labels
  +      ((patterns (prime)
  +         (iterate (with size = (digits-length prime))
  +                  (with indices = (range 0 size))
  +                  (for i :from 1 :below size)
  +                  (appending (combinations indices :length i))))
  +       (apply-pattern-digit (prime pattern new-digit)
  +         (iterate (with result = (digits prime))
  +                  (for index :in pattern)
  +                  (when (and (zerop index) (zerop new-digit))
  +                    (leave))
  +                  (setf (nth index result) new-digit)
  +                  (finally (return (digits-to-number result)))))
  +       (apply-pattern (prime pattern)
  +         (iterate (for digit in (irange 0 9))
  +                  (for result = (apply-pattern-digit prime pattern digit))
  +                  (when (and result (primep result))
  +                    (collect result))))
  +       (apply-patterns (prime)
  +         (mapcar (curry #'apply-pattern prime) (patterns prime)))
  +       (winnerp (prime)
  +         (find-if (curry #'length= 8) (apply-patterns prime))))
  +    (-<> (iterate (for i :from 3 :by 2)
  +                  (thereis (and (primep i) (winnerp i))))
  +      (sort< <>)
  +      first)))
   
   (defun problem-52 ()
     ;; It can be seen that the number, 125874, and its double, 251748, contain
  
positive.code:          (sort (copy-seq list2) sort-predicate)))
  
  
  ;;;; Problems -----------------------------------------------------------------
  (defun problem-1 ()
    ;; If we list all the natural numbers below 10 that are multiples of 3 or 5,
  
negative.code:                     (every (lambda (n)
                               (orderless-equal digits (digits (* n i))))
                             '(2 3 4 5 6)))))
  
  
  (defun problem-56 ()
    ;; A googol (10^100) is a massive number: one followed by one-hundred zeros;
  