atcoder adt_easy_20260507_1

1. A – Content Too Large

• A – Content Too Large

(defun put-all-p (M An)
  (loop for a in An
        sum a into S
        always (<= S M)))

;; (put-all-p 15 '(3 1 4 1 5)) ;=> T

(defun print-yesno (c)
  (declare (type boolean c))
  (princ (if c "Yes" "No")))

(defun main ()
  (let* ((N (read))
         (M (read))
         (An (loop repeat N collect (read))))
    (print-yesno (put-all-p M An))))

#-swank(main)Code language: Lisp (lisp)

2. B

• B – π

(defun circle-area (r)
  (* pi (* r r)))

(defun main ()
  (let ((D (read)))
    (format t "~f" (circle-area (/ D 2)))))

#-swank(main)Code language: Lisp (lisp)

3. C

• C – Four Hidden

;; (continous-substring-p "tak??a?h?" "nashi") ;=> T
;; (continous-substring-p "??e??e" "snuke") ;=> NIL
(defun continous-substring-p (TT U)
  (loop for i from 0 to (- (length TT) (length U))
          thereis (and (or (char= (char TT i) (char U 0))
                           (char= (char TT i) #\?))
                       (loop for j from 0 below (length U)
                             always (or (char= (char TT (+ i j))
                                               (char U j))
                                        (char= (char TT (+ i j))
                                               #\?))))))

(defun print-yesno (c)
  (declare (type boolean c))
  (princ (if c "Yes" "No")))

(defun main ()
  (let* ((TT (read-line))
         (U (read-line)))
    (print-yesno (continous-substring-p TT U))))
#-swank(main)
Code language: Lisp (lisp)

4. D

• D – Who is Missing?

(defun missing-list (N Am)
  (let* ((ht (make-hash-table)))
    (loop for a in Am
          do (setf (gethash a ht) t))
    (loop for i from 1 to N
          when (null (gethash i ht))
            collect i)))

;; (missing-list 10 '(3 9 2)) ;=>  (1 4 5 6 7 8 10)

(defun main ()
  (let* ((N (read))
         (M (read))
         (Am (loop repeat M
                   collect (read)))
         (Xc (missing-list N Am)))
    (princ (length Xc))
    (terpri)
    (loop for x in Xc
          do (princ x)
             (princ #\space))))
#-swank(main)Code language: Lisp (lisp)

5. E

• E – Festival

;; (next-fireworks 3 '(2 3))        ;=> (1 0 0)
;; (next-fireworks 8 '(1 3 4 7 8))  ;=> (0 1 0 0 2 1 0 0)
(defun next-fireworks (N Am)
  (let* ((rev (reverse Am)))
    (loop for d from N downto 1
          with next = 0
          when (and (consp rev) (= (car rev) d))
            do (setf next 0)
               (pop rev)
          collect next into lst
          do (incf next)
          finally (return (nreverse lst)))))

(defun main ()
  (let* ((N (read))
         (M (read))
         (Am (loop repeat M collect (read))))
    (loop for d in (next-fireworks N Am)
          do (princ d)
             (terpri))))
#-swank(main)Code language: Lisp (lisp)

Code language: Lisp (lisp)