結果

問題 No.717 ファッションへのこだわり
ユーザー norioc
提出日時 2025-07-03 03:53:40
言語 Scheme
(Gauche-0.9.15)
結果
AC  
実行時間 106 ms / 2,000 ms
コード長 3,990 bytes
コンパイル時間 239 ms
コンパイル使用メモリ 7,972 KB
実行使用メモリ 23,936 KB
最終ジャッジ日時 2025-07-03 03:53:43
合計ジャッジ時間 2,903 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge3
このコードへのチャレンジ
（要ログイン）
ファイルパターン 結果
sample AC * 3
other AC * 10
権限があれば一括ダウンロードができます

ソースコード

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-with-index (lambda (i x)
                         (when (> i 0)
                           (display " "))
                         (display x))
                       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)
  (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 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 eqv-comparator)
    (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)
  (map digit->integer (str n)))


(use gauche.dictionary)

(let* ((_ (input))
       (S (input))
       (T (input))

       (a (frequencies S))
       (b (frequencies T)))
  (define (get dict k)
    (dict-get dict k 0))

  (let ((ans (+ (min (get a #\A) (get b #\A))
                (min (get a #\B) (get b #\B)))))
    (prn ans)))
0