Problem:
Score: 500 points

Problem Statement

In the Kingdom of AtCoder, only banknotes are used as currency. There are 10^{100}+1 kinds of banknotes, with the values of 1, 10, 10^2, 10^3, \dots, 10^{(10^{100})}. You have come shopping at a mall and are now buying a takoyaki machine with a value of N. (Takoyaki is the name of a Japanese snack.)

To make the payment, you will choose some amount of money which is at least N and give it to the clerk. Then, the clerk gives you back the change, which is the amount of money you give minus N.

What will be the minimum possible number of total banknotes used by you and the clerk, when both choose the combination of banknotes to minimize this count?

Assume that you have sufficient numbers of banknotes, and so does the clerk.

Constraints

N is an integer between 1 and 10^{1,000,000} (inclusive).

Input

Input is given from Standard Input in the following format:

N

Output

Print the minimum possible number of total banknotes used by you and the clerk.

Sample Input 1

36

Sample Output 1

8

If you give four banknotes of value 10 each, and the clerk gives you back four banknotes of value 1 each, a total of eight banknotes are used.

The payment cannot be made with less than eight banknotes in total, so the answer is 8.

Sample Input 2

91

Sample Output 2

3

If you give two banknotes of value 100, 1, and the clerk gives you back one banknote of value 10, a total of three banknotes are used.

Sample Input 3

314159265358979323846264338327950288419716939937551058209749445923078164062862089986280348253421170

Sample Output 3

243

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Accepted)

(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
           ;; enclose the form with VALUES to avoid being captured by LOOP macro
           #\# #\> (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)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
(macrolet ((def (name fname)
             `(define-modify-macro ,name (new-value) ,fname)))
  (def minf min)
  (def maxf max)
  (def mulf *)
  (def divf /)
  (def iorf logior)
  (def xorf logxor)
  (def andf logand))

(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 main ()
  (let* ((input (read-line))
         (len (length input))
         (s (make-array (+ len 1) :element-type 'uint8))
         ;; 0: 繰り上げないで払う 1: 繰り上げて払う
         (dp (make-array (list (+ len 2) 2) :element-type 'uint62
                                            :initial-element most-positive-fixnum)))
    (declare (simple-string input))
    (loop for i below len
          for c across input
          for d = (- (char-code c) 48)
          do (setf (aref s (- len i 1)) d))
    (setf (aref dp 0 0) 0)
    (dotimes (x (+ len 1))
      (let ((d (aref s x)))
        ;; 繰り上げていない状態 -> 繰り上げていない状態
        (minf (aref dp (+ x 1) 0)
              (+ (aref dp x 0) d))
        ;; 繰り上げていない状態 -> 繰り上げた状態
        (minf (aref dp (+ x 1) 1)
              (+ (aref dp x 0) (- 10 d)))
        ;; 繰り上げた状態 -> 繰り上げていない状態
        (minf (aref dp (+ x 1) 0)
              (+ (aref dp x 1) d 1))
        ;; 繰り上げた状態 -> 繰り上げた状態
        (minf (aref dp (+ x 1) 1)
              (+ (aref dp x 1) (- 10 (+ d 1))))))
    (println (min (aref dp (+ len 1) 0)
                  (aref dp (+ len 1) 1)))
    ;; #>s
    ;; (let ((carry nil)
    ;;       (res 0))
    ;;   (dotimes (i (length s))
    ;;     (let ((d (aref s i)))
    ;;       #>d
    ;;       (when carry
    ;;         (incf d)
    ;;         (setq carry nil))
    ;;       (ecase d
    ;;         (0)
    ;;         (1 (incf res 1))
    ;;         (2 (incf res 2))
    ;;         (3 (incf res 3))
    ;;         (4 (incf res 4))
    ;;         (5 (incf res 5))
    ;;         (6 (incf res 4) (setq carry t))
    ;;         (7 (incf res 3) (setq carry t))
    ;;         (8 (incf res 2) (setq carry t))
    ;;         (9 (incf res 1) (setq carry t))
    ;;         (10 (setq carry t))))
    ;;     #>res)
    ;;   (println res))
    ))

#-swank (main)

;;;
;;; Test and benchmark
;;;

#+swank
(defun io-equal (in-string out-string &key (function #'main) (test #'equal))
  "Passes IN-STRING to *STANDARD-INPUT*, executes FUNCTION, and returns true if
the string output to *STANDARD-OUTPUT* is equal to OUT-STRING."
  (labels ((ensure-last-lf (s)
             (if (eql (uiop:last-char s) #\Linefeed)
                 s
                 (uiop:strcat s uiop:+lf+))))
    (funcall test
             (ensure-last-lf out-string)
             (with-output-to-string (out)
               (let ((*standard-output* out))
                 (with-input-from-string (*standard-input* (ensure-last-lf in-string))
                   (funcall function)))))))

#+swank
(defun get-clipbrd ()
  (with-output-to-string (out)
    (run-program "powershell.exe" '("-Command" "Get-Clipboard") :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* out))
    (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))))))

#+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
   (common-lisp-user::io-equal "36
"
    "8
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "91
"
    "3
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "314159265358979323846264338327950288419716939937551058209749445923078164062862089986280348253421170
"
    "243
")))