Library for Atcoder

(defmacro aif (test-form then-form &optional else-form)
  `(let ((it ,test-form))
     (if it ,then-form ,else-form)))

(aif 11 (princ it)) ;; => 11

(defmacro aif (test-form then-form &optional else-form)
  `(let ((it ,test-form))
     (if it ,then-form ,else-form)))

(defmacro awhen (test-form &body body)
  `(aif ,test-form
        (progn ,@body)))

(awhen 10 (print it)) ;; => 10

(defmacro aand (&rest args)
  (cond ((null args) t)
        ((null (cdr args)) (car args))
        (t `(aif ,(car args) (aand ,@(cdr args))))))

(defmacro acond (&rest clauses)
  (if (null clauses)
      nil
      (let ((cl1 (car clauses))
            (sym (gensym)))
        `(let ((,sym ,(car cl1)))
           (if ,sym
               (let ((it ,sym)) ,@(cdr cl1))
               (acond ,@(cdr clauses)))))))

(defmacro alambda (parms &body body)
  `(labels ((self ,parms ,@body))
     #'self))

(defmacro alambda (parms &body body)
  `(labels ((self ,parms ,@body))
     #'self))

(defmacro ablock (tag &rest args)
  `(block ,tag
     ,(funcall (alambda (args)
                        (case (length args)
                          (0 nil)
                          (1 (car args))
                          (t `(let ((it ,(car args)))
                                ,(self (cdr args))))))
               args)))

(defmacro alambda (parms &body body)
  `(labels ((self ,parms ,@body))
     #'self))

(defmacro aevery (form list)
  `(every #'(lambda (it) ,form) ,list))

(defmacro areduce (form list &key initial-value)
  `(reduce #'(lambda (it-accum it) ,form) ,list :initial-value ,initial-value))

(defmacro string+ (&rest str)
  `(concatenate 'string ,@str))

(defmacro every-string= (c sequence)
  `(aevery (string= it ,c) ,sequence))

(defmacro string-case (my-condition my-lst)
  `(cond ,@(mapcar #'(lambda (x)
                       `((string= ,my-condition ,(car x)) ,(cadr x)))
                   my-lst)))

(string-case "Sunny"
             (("Sunny" (progn (print "Cloudy")))
              ("Cloudy" "Rainy")
              ("Rainy" "Sunny")))

(defmacro string-case (my-condition my-lst)
  `(cond ,@(mapcar #'(lambda (x)
                       `((string= ,my-condition ,(car x)) ,(cadr x)))
                   my-lst)))

(string-case "Sunny"
             (("Sunny" "Cloudy")
              ("Cloudy" "Rainy")
              ("Rainy" "Sunny"))) ;; => "Cloudy"

(defun split-string (string split)
  (loop :for i = 0 :then (1+ j)
        :as j = (position split string :start i)
        :collect (subseq string i j)
        :while j))

(split-string "2019/04/30" #\/) ;; => ("2019" "04" "30")

(defun shift-string (str shift)
  (map 'string
       #'(lambda (c)
           (code-char
            (+
             (mod (+ (- (char-int c) (char-int #\A)) shift) 26)
             (char-int #\A))))
       str))

(shift-string "ABCXYZ" 2)

(defmacro char-1+ (char)
  `(code-char (1+ (char-code ,char))))

(defmacro char-code+ (char num)
  `(code-char (+ (char-code ,char) ,num)))

(defmacro char-case (my-condition my-lst)
  `(cond ,@(mapcar #'(lambda (x)
                       `((char= ,my-condition ,(car x)) ,(cadr x)))
                   my-lst)))

(char-case #\1
           ((#\1 #\9)
            (#\9 #\1)
            (t x))) ;; => #\9

(defmacro nested-loops (vars values &rest body)
  (if vars
      `(loop :for ,(first vars) :from ,(car (first values)) :to ,(cdr (first values))
             :do (nested-loops ,(rest vars) ,(rest values) ,@body))
      `(progn ,@body)))

(nested-loops (x y) ((1 . 2) (1 . 2))
              (princ (* x y)))

(defmacro nested-nth (idxs my-lst)
  `(if ,idxs (nth (car (reverse ,idxs)) (nested-nth (cdr (reverse ,idxs)) ,my-lst)) ,my-lst))

(nested-nth '(1 1) '(1 (1 2)))

(defun get-even-list (lst)
  (loop :with return-lst = '()
        :for index :from 0 :below (length lst)
        :unless (zerop (mod index 2))
          :do (setf return-lst (append return-lst (list (nth index lst))))
        :finally (return return-lst)))

(defun remove-nth (n list)
  (declare
    (type (integer 0) n)
    (type list list))
  (if (or (zerop n) (null list))
    (cdr list)
    (cons (car list) (remove-nth (1- n) (cdr list)))))

(defun check-bit-frag (bit index)
  (logand (ash bit (- 0 index)) 1))

(defmacro while (test &body body)
  `(do ()
     ((not ,test))
     ,@body))

(defun convert-sum-list (lst)
  (cdr (reduce #'(lambda (accum elm)
                   (append accum (list (+ (car (last accum)) elm))))
               lst
               :initial-value '(0))))

(defun binary-search (item buffer)
  (do ((low 0)
       (high (1- (length buffer))))
      ((> low high))
    (let ((mid (floor (+ low high) 2)))
      (cond
        ((= (nth mid buffer) item) (return mid))
        ((< (nth mid buffer) item) (setq low (1+ mid)))
        (t (setq high (1- mid)))))))

(defun arithmetic-progression-sum (a b)
  (let ((n (1+ (- b a))))
    (+ (* n (1- a))
       (/ (* n (1+ n)) 2))))

(arithmetic-progression-sum 2 8) ;; => 35

(defun manhattan-distance (lst)
  (reduce #'+ (mapcar #'abs lst)))

(manhattan-distance '(3 -1 -4 1 -5 9 2 -6 5 -3)) ;; => 39

(defun euclidean-distance (lst)
  (sqrt (reduce #'+ (mapcar #'(lambda (x) (coerce (* x x) 'double-float)) lst))))

(euclidean-distance '(3 -1 -4 1 -5 9 2 -6 5 -3)) ;; => 14.387494569938159

(defun chebyshev-distance (lst)
  (reduce #'max (mapcar #'abs lst)))

(chebyshev-distance '(3 -1 -4 1 -5 9 2 -6 5 -3)) ;; => 9