Submission #5416948

---

Source Code Expand

#-swank
(unless (member :child-sbcl *features*)
  (quit
   :unix-status
   (process-exit-code
    (run-program *runtime-pathname*
                 `("--control-stack-size" "32MB"
                   "--noinform" "--disable-ldb" "--lose-on-corruption" "--end-runtime-options"
                   "--eval" "(push :child-sbcl *features*)"
                   "--script" ,(namestring *load-pathname*))
                 :output t :error t :input t))))
;; -*- coding: utf-8 -*-
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defparameter OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0)))
  #+swank (progn (ql:quickload '(:cl-debug-print :fiveam))
                 (shadow :run)
                 (use-package :fiveam)))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)

;; BEGIN_INSERTED_CONTENTS
(defmacro dbg (&rest forms)
  #+swank
  (if (= (length forms) 1)
      `(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
      `(format *error-output* "~A => ~A~%" ',forms `(,,@forms)))
  #-swank (declare (ignore forms)))

(defmacro define-int-types (&rest bits)
  `(progn
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))) bits)
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))) bits)))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64)

(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  (let ((*read-default-float-format* 'double-float))
    (prog1 (princ obj stream) (terpri stream))))

(defconstant +mod+ 1000000007)

;; Body

(defun parse-number (s pos)
  (declare (simple-base-string s))
  (let ((res (make-array 0 :fill-pointer 0 :element-type 'base-char)))
    (loop for i from pos
          while (and (< i (length s))
                     (digit-char-p (schar s i)))
          do (vector-push-extend (schar s i) res))
    (values res (+ pos (length res)))))

(defun parse-args (s pos)
  (multiple-value-bind (expr new-pos) (parse-expr s pos)
    (if (char= #\, (schar s new-pos))
        (multiple-value-bind (args last-pos) (parse-args s (+ 1 new-pos))
          (values (cons expr args) last-pos))
        (values (list expr) new-pos))))

(defun parse-expr (s pos)
  (macrolet ((frob-op (op)
               `(progn
                  (assert (char= #\( (schar s (+ pos 1))))
                  (multiple-value-bind (args new-pos) (parse-args s (+ pos 2))
                    (assert (char= #\) (schar s new-pos)))
                    (values (cons ',op args) (+ new-pos 1))))))
    (case (schar s pos)
      (#\+ (frob-op +))
      (#\- (frob-op -))
      (#\* (frob-op *))
      (#\/ (frob-op /))
      ((#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)
       (parse-number s pos)))))

(defun print-expr (ast)
  (typecase ast
    (string (write-string ast))
    (list (let ((op (car ast))
                (args (cdr ast)))
            (write-char #\()
            (let ((init t))
              (loop for arg in args
                    do (if init
                           (setq init nil)
                           (princ op))
                       (print-expr arg)))
            (write-char #\))))))

(defun main ()
  (let* ((s (coerce (read-line) 'simple-base-string)))
    (print-expr (parse-expr s 0))
    (terpri)))

#-swank(main)

Submission Info

Judge Result