結果

問題 No.191 供託金
ユーザー norioc
提出日時 2025-07-14 21:52:52
言語 Scheme
(Gauche-0.9.15)
結果
AC  
実行時間 190 ms / 5,000 ms
コード長 4,489 bytes
コンパイル時間 350 ms
コンパイル使用メモリ 8,096 KB
実行使用メモリ 29,168 KB
最終ジャッジ日時 2025-07-14 21:53:00
合計ジャッジ時間 7,333 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 23
権限があれば一括ダウンロードができます

ソースコード

diff # 

(use srfi.13)  ; string
(use srfi.42)  ; list-ec
(use srfi.197) ; chain
(use gauche.collection)
(use gauche.dictionary)
(use gauche.generator)
(use gauche.sequence)
(use scheme.list)
(use scheme.set)
(use util.combinations)
(use util.match)

(define input read-line)

(define (ii)
  (string->number (read-line)))

(define (li)
  (let ((s (read-line)))
    (map string->number (string-split s " "))))

(define (prn . args)
  (for-each-with-index (lambda (i x)
                         (when (> i 0)
                           (display " "))
                         (display x))
                       args)
  (newline))

(define prn* (pa$ apply prn))

(define (prn-yn b)
  (prn (if b "Yes" "No")))

(define-syntax prn/d
  (syntax-rules ()
    ((_ expr ...)
     (with-output-to-port (current-error-port)
       (^()
         (prn expr ...))))))

(define int string->number)
(define str x->string)

(define-method min ((xs <sequence>))
  (fold min (~ xs 0) xs))
(define-method max ((xs <sequence>))
  (fold max (~ xs 0) xs))

(define (minmax . xs)
  (values->list (apply min&max xs)))
(define-method minmax ((xs <sequence>))
  (values->list (apply min&max xs)))

(define (sum xs)
  (fold + 0 xs))

(define (divmod a b)
  (values->list (div-and-mod a b)))

(define (1+ n) (+ n 1))
(define (1- n) (- n 1))
(define (!= a b) (not (= a b)))
(define (midpoint a b) (div (+ a b) 2))

(define pow
  (case-lambda
   ((a b) (expt a b))
   ((a b m) (expt-mod a b m))))

(define gcd* (apply$ gcd))
(define isqrt exact-integer-sqrt)

(define ++ string-append)

(define zip (map$ list))
(define all every)
(define any-ec any?-ec)
(define all-ec every?-ec)
(define concat concatenate)

(define (pairwise xs)
  (zip xs (cdr xs)))

(define (comb n k)
  (if (or (< k 0) (> k n))
      0
      (let loop ((i 0)
                 (x 1))
        (if (= i k)
            x
            (loop (1+ i) (div (* x (- n i)) (1+ i)))))))

(define (make-dict)
  (make-hash-table equal-comparator))

(define-method frequencies ((xs <sequence>))
  (rlet1 dict (make-dict)
    (for-each (^x (dict-update! dict x 1+ 0))
              xs)))

(define-macro (input! bindings . body)
  (let loop ((bs (reverse bindings))
             (res '()))
    (if (null? bs)
        `(let*-values ,res
           ,@body)
        (cond
         ((symbol? (car bs))
          (loop (cdr bs)
                (cons `((,(car bs)) (values (ii)))
                      res)))
         ((list? (car bs))
          (loop (cdr bs)
                (cons `(,(car bs) (apply values (li)))
                      res)))
         (else
          'error)))))

(define mlet match-let)
(define mlet* match-let*)
(define mlet1 match-let1)

(define-macro (mfn pat . body)
  (let ((arg (gensym)))
    `(lambda (,arg)
       (mlet1 ,pat ,arg
         ,@body))))

(define-syntax count-ec
  (syntax-rules ()
    ((_ qualifiers ...)
     (sum-ec qualifiers ... 1))))

(define-method len ((xs <list>))
  (length xs))
(define-method len ((s <string>))
  (string-length s))
(define-method len ((vs <vector>))
  (vector-length vs))

(define (accum xs)
  (define (proc a b)
    (let1 t (+ a b)
      (values t t)))
  (map-accum proc 0 xs))

(define (digits n)
  (map digit->integer (str n)))

(define (digits->int ds)
  (fold-left (^(a b) (+ (* 10 a) b)) 0 ds))

(define (-> x . fns)
  (call-with-values (^() (values x))
    (apply compose (reverse fns))))

(define (rep n thunk)
  (list-tabulate n (^i (thunk))))

(define (zip-longest . args)
  (let* ((n (apply max (map length args)))
         (xxs (map (^(xs)
                     (append xs (make-list (- n (length xs)) #f)))
                   args)))
    (map (pa$ delete #f)
         (apply zip xxs))))

(define (set-from xs)
  (apply set eqv-comparator xs))

(define (difference xs ys)
  (let ((excludes (set-from ys)))
    (filter (^x (not (set-contains? excludes x))) xs)))


(define (group xs test)
  (define (sub ys)
    (assume (not (null? ys)))

    (let loop ((g (list (car ys)))
               (ys (cdr ys)))
      (if (null? ys)
          (values (reverse g) ys)
          (match-let1 (y . rest) ys
            (if (test (car g) y)
                (loop (cons y g) rest)
                (values (reverse g) ys))))))

  (if (null? xs)
      '()
      (receive (g rest) (sub xs)
        (if (null? rest)
            (list g)
            (cons g (group rest test))))))

(let* ((N (ii))
       (C (li))

       (t (/ (sum C) 10)))
  (->
   (count-ec (: c C)
             (if (<= c t)))
   (pa$ * 30)
   prn))
0