GCJ 2015 Round-1A

a.lisp

(defpackage a
  (:use :common-lisp
        :iterate)
  (:export :solve
	   :read-data))

(in-package a)

(defun read-data ()
  (iter (repeat (read))
	(collect (read))))

(defun solve-y (data)
  (reduce #'+ (remove-if #'minusp (mapcar #'- data (cdr data)))))

(defun solve-z (data)
  (let ((rate (max 0 (reduce #'max (mapcar #'- data (cdr data))))))
    (reduce #'+ (mapcar #'(lambda (x) (min rate x)) (butlast data)))))

(defun solve (data)
  (let ((y (solve-y data))
	(z (solve-z data)))
    (format nil "~a ~a" y z)))

b.lisp

(defpackage b
  (:use :common-lisp
        :iterate)
  (:export :solve
	   :read-data))

(in-package b)

(defun read-data ()
  (let ((b (read))
	(n (read)))
    (list n (iter (repeat b) (collect (read))))))

(defun done (time m)
  (values (reduce #'+ (mapcar #'(lambda (x) (floor time x)) m))
	  (count-if-not #'(lambda (x) (zerop (mod time x))) m)
	  (count-if #'(lambda (x) (zerop (mod time x))) m)))

(defun cmp (time n m)
  (multiple-value-bind (done pend new) (done time m)
    (cond ((<= n (+ done pend)) :GT)
	  ((<= (+ done pend 1) n (+ done pend new)) :EQ)
	  (t :LT))))

(defun binsearch (l u n m)
  (let ((mid (floor (+ l u) 2)))
    (case (cmp mid n m)
      (:LT (binsearch mid u n m))
      (:EQ mid)
      (:GT (binsearch l mid n m )))))

(defun solve (data)
  (destructuring-bind (n m) data
    (let ((time (binsearch 0 (expt 10 14) n m)))
      (multiple-value-bind (done pend new) (done time m)
	(nth (- n (+ done pend) 1)
	     (iter (for i from 1)
		   (for x in m)
		   (when (zerop (mod time x))
		     (collect i))))))))

c.lisp

(defpackage c
  (:use :common-lisp
        :iterate)
  (:export :solve
	   :read-data))

(in-package c)

(defun read-data ()
  (iter (repeat (read))
	(collect (cons (read) (read)))))

(defun px (p) (car p))
(defun py (p) (cdr p))

(defun p- (p q)
  (cons (- (px p) (px q))
	(- (py p) (py q))))

(defun cross (p q)
  (- (* (px p) (py q)) (* (px q) (py p))))

(defun ccw (p q r)
  (cross (p- q p) (p- r p)))

(defun ncut (p q l)
  (assert (not (equal p q)))
  (min (count-if #'(lambda (r) (> (ccw p q r) 0)) l)
       (count-if #'(lambda (r) (< (ccw p q r) 0)) l)))

(defun minlog (p l)
  (iter (for q in l)
	(unless (eq p q)
	  (minimize (ncut p q l)))))

(defun solve (data)
  (format nil "~{~%~a~}" (if (<= (length data) 2)
			     (iter (for x in data ) (collect 0))
			     (mapcar #'(lambda (p) (minlog p data)) data))))

gcj.lisp

(defpackage gcj
  (:use :common-lisp
        :iterate)
  (:export :solve-all))

(in-package gcj)

(defun do-solve-all (solver reader)
  (let ((n (read-from-string (read-line))))
    (iter (for i from 1 to n)
	  (for data next (funcall reader))
	  (format t "Case #~a: ~a~%" i (funcall solver data)))))

(defun solve-all (solver reader input output)
  (with-open-file (*standard-input* input
                                    :direction :input)
    (if output
	(with-open-file (*standard-output* output
					   :direction :output
					   :if-exists :supersede)
	  (do-solve-all solver reader))
	  (do-solve-all solver reader))))