結果

問題 No.1175 Simultaneous Equations
ユーザー sansaqua
提出日時 2020-08-21 21:24:27
言語 Common Lisp
(sbcl 2.5.0)
結果
AC  
実行時間 9 ms / 2,000 ms
コード長 6,380 bytes
コンパイル時間 1,352 ms
コンパイル使用メモリ 41,088 KB
実行使用メモリ 22,656 KB
最終ジャッジ日時 2024-10-15 05:04:30
合計ジャッジ時間 1,909 ms
ジャッジサーバーID
(参考情報)
judge4 / judge3
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 2
other AC * 11
権限があれば一括ダウンロードができます
コンパイルメッセージ
; compiling file "/home/judge/data/code/Main.lisp" (written 15 OCT 2024 05:04:27 AM):

; file: /home/judge/data/code/Main.lisp
; in: DEFUN MAIN
;     (MULTIPLE-VALUE-BIND (RES RANK)
;         (SOLVE-LINEAR-SYSTEM MAT (VECTOR C F))
;       (FORMAT T "~F ~F~%" (AREF RES 0) (AREF RES 1)))
; ==>
;   #'(LAMBDA (&OPTIONAL RES RANK &REST #:IGNORE)
;       (DECLARE (IGNORE #:IGNORE))
;       (FORMAT T "~F ~F~%" (AREF RES 0) (AREF RES 1)))
; 
; caught STYLE-WARNING:
;   The variable RANK is defined but never used.
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition


; wrote /home/judge/data/code/Main.fasl
; compilation finished in 0:00:00.091

ソースコード

diff #
プレゼンテーションモードにする

(in-package :cl-user)
(eval-when (:compile-toplevel :load-toplevel :execute)
(sb-int:defconstant-eqx opt
#+swank '(optimize (speed 3) (safety 2))
#-swank '(optimize (speed 3) (safety 0) (debug 0))
#'equal)
#+swank (ql:quickload '(:cl-debug-print :fiveam) :silent t)
#-swank (set-dispatch-macro-character
#\# #\> (lambda (s c p) (declare (ignore c p)) `(values ,(read s nil nil t)))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
(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)
(defconstant +mod+ 1000000007)
(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)))
(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
(let ((*read-default-float-format* 'double-float))
(prog1 (princ obj stream) (terpri stream))))
;; BEGIN_INSERTED_CONTENTS
;; BEGIN_USE_PACKAGE
(in-package :cl-user)
;;;
;;; Body
;;;
;; Reference: http://drken1215.hatenablog.com/entry/2019/03/20/202800
(defun echelon! (matrix &optional extended)
"Returns the row echelon form of MATRIX by gaussian elimination and returns
the rank as the second value.
This function destructively modifies MATRIX."
(labels ((%zerop (x)
(< (abs x) 1d-9)))
(destructuring-bind (m n) (array-dimensions matrix)
(declare ((integer 0 #.most-positive-fixnum) m n))
(let ((rank 0))
(dotimes (target-col (if extended (- n 1) n))
(let ((pivot-row (do ((i rank (+ 1 i)))
((= i m) -1)
(unless (%zerop (aref matrix i target-col))
(return i)))))
(when (>= pivot-row 0)
;; swap rows
(loop for j from target-col below n
do (rotatef (aref matrix rank j) (aref matrix pivot-row j)))
(let ((inv (/ (aref matrix rank target-col))))
(dotimes (j n)
(setf (aref matrix rank j)
(* inv (aref matrix rank j))))
(dotimes (i m)
(unless (or (= i rank) (%zerop (aref matrix i target-col)))
(let ((factor (aref matrix i target-col)))
(loop for j from target-col below n
do (setf (aref matrix i j)
(- (aref matrix i j)
(* (aref matrix rank j) factor))))))))
(incf rank))))
(values matrix rank)))))
(defun solve-linear-system (matrix vector)
"Solves Ax ≡ b and returns a root vector if it exists. Otherwise it returns
NIL. In addition, this function returns the rank of A as the second value."
(destructuring-bind (m n) (array-dimensions matrix)
(declare ((integer 0 #.most-positive-fixnum) m n))
(assert (= n (length vector)))
(let ((extended (make-array (list m (+ n 1)) :element-type (array-element-type matrix))))
(labels ((%zerop (x)
(< (abs x) 1d-9)))
(dotimes (i m)
(dotimes (j n) (setf (aref extended i j) (aref matrix i j)))
(setf (aref extended i n) (aref vector i)))
(let ((rank (nth-value 1 (echelon! extended t))))
(if (loop for i from rank below m
always (%zerop (aref extended i n)))
(let ((result (make-array m
:element-type (array-element-type matrix)
:initial-element 0d0)))
(dotimes (i rank)
(setf (aref result i) (aref extended i n)))
(values result rank))
(values nil rank)))))))
(defun main ()
(let* ((a (float (read) 1d0))
(b (float (read) 1d0))
(c (float (read) 1d0))
(d (float (read) 1d0))
(e (float (read) 1d0))
(f (float (read) 1d0))
(mat (make-array '(2 2) :element-type 'double-float :initial-contents `((,a ,b) (,d ,e)))))
(multiple-value-bind (res rank) (solve-linear-system mat (vector c f))
(format t "~F ~F~%" (aref res 0) (aref res 1)))))
#-swank (main)
;;;
;;; Test and benchmark
;;;
#+swank
(defun get-clipbrd ()
(with-output-to-string (out)
#+os-windows (run-program "powershell.exe" '("-Command" "Get-Clipboard") :output out :search t)
#+os-unix (run-program "xsel" '("-b" "-o") :output out :search t)))
#+swank (defparameter *this-pathname* (uiop:current-lisp-file-pathname))
#+swank (defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *this-pathname*))
#+swank
(defun run (&optional thing (out *standard-output*))
"THING := null | string | symbol | pathname
null: run #'MAIN using the text on clipboard as input.
string: run #'MAIN using the string as input.
symbol: alias of FIVEAM:RUN!.
pathname: run #'MAIN using the text file as input."
(let* ((*standard-output* (or out (make-string-output-stream)))
(res (etypecase thing
(null
(with-input-from-string (*standard-input* (delete #\Return (get-clipbrd)))
(main)))
(string
(with-input-from-string (*standard-input* (delete #\Return thing))
(main)))
(symbol (5am:run! thing))
(pathname
(with-open-file (*standard-input* thing)
(main))))))
(if out res (get-output-stream-string *standard-output*))))
#+swank
(defun gen-dat ()
(uiop:with-output-file (out *dat-pathname* :if-exists :supersede)
(format out "")))
#+swank
(defun bench (&optional (out (make-broadcast-stream)))
(time (run *dat-pathname* out)))
;; To run: (5am:run! :sample)
#+swank
(it.bese.fiveam:test :sample
(it.bese.fiveam:is
(equal "1.000000000000000 1.000000000000000
"
(run "1 1 2 1 2 3
" nil)))
(it.bese.fiveam:is
(equal "2.666666666666667 -0.333333333333333
"
(run "2 1 5 1 2 2
" nil))))
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0