結果

問題 No.2092 Conjugation
ユーザー norioc
提出日時 2025-07-01 10:33:47
言語 Scheme
(Gauche-0.9.15)
結果
AC  
実行時間 609 ms / 2,000 ms
コード長 3,926 bytes
コンパイル時間 510 ms
コンパイル使用メモリ 8,096 KB
実行使用メモリ 51,616 KB
最終ジャッジ日時 2025-07-01 10:33:57
合計ジャッジ時間 8,644 ms
ジャッジサーバーID
（参考情報） 		judge4 / judge5
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 2
other AC * 18
権限があれば一括ダウンロードができます

ソースコード

diff # 

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

(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 (lambda (i x)
              (when (> i 0)
                (display " "))
              (display x))
            (iota (length args))
            args)
  (newline))

(define prn* (pa$ apply prn))

(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) (apply + 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 pow
  (case-lambda
   ((a b) (expt a b))
   ((a b m) (expt-mod a b m))))

(define isqrt exact-integer-sqrt)

(define ++ string-append)

(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-method frequencies ((xs <sequence>))
  (rlet1 ht (make-hash-table)
    (for-each (^x (hash-table-update! ht x 1+ 0))
              xs)))

(define (pairwise xs)
  (zip xs (cdr 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))))))

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

(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 mlet1 match-let1)

(define (slide xs k :key step)
  (let* ((n (length xs))
         (step (if (undefined? step) k step)))
    (let loop ((xs xs)
               (res '()))
      (if (null? xs)
          (reverse res)
          (loop (drop* xs step)
                (cons (take* xs k) res))))))

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

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

(define (bsearch low high pred :key (complement? #f))
  (define satisfy? (if complement?
                       (complement pred)
                       pred))

  (let loop ((lo low)
             (hi high)
             (res low))
    (cond
     ((<= lo hi)
      (let1 m (div (+ lo hi) 2)
        (if (satisfy? m)
            (loop (1+ m) hi (max res m))
            (loop lo (1- m) res))))
     (else
      (if complement?
          (1+ res)
          res)))))

(define (digits n)
  (list-ec (:list c (string->list (str n)))
           (digit->integer c)))

(use scheme.vector)

(let* ((N (ii))
       (A (li)))
  (let ((v (make-vector (max A) 0)))
    (dolist (a (map 1- A))
      (set! (~ v a) (1+ (~ v a))))
    (vector-reverse! v)
    (let1 ans (reverse (accum v))
      (prn* ans))))
0