DouKaku?

(use gauche.array)
(use gauche.test)

(define (array-ref* array row col)
  (guard (exc (<error> #f))
    (array-ref array row col)))

(define (make-string-from-matrix matrix length x y delta-x delta-y)
  (let loop ((i length) (x x) (y y) (chars '()))
    (cond ((<= i 0) (apply string (reverse chars)))
          ((array-ref* matrix y x) =>
           (lambda (ch)
             (loop (- i 1) (delta-x x) (delta-y y) (cons ch chars))))
          (else #f))))

(define (search8 str1 matrix col row)
  (define len (string-length str1))
  (define (inc x) (+ x 1))
  (define (dec x) (- x 1))
  (define (string<-matrix delta-x delta-y)
    (make-string-from-matrix matrix len col row delta-x delta-y))
  (define (make-search-proc value make-string-proc)
    (and-let* ((str2 (make-string-proc))
               ((string=? str1 str2)))
      value))

  (define (search-right)
    (make-search-proc "右" (cut string<-matrix inc identity)))
  (define (search-left)
    (make-search-proc "左" (cut string<-matrix dec identity)))
  (define (search-upper)
    (make-search-proc "上" (cut string<-matrix identity dec)))
  (define (search-lower)
    (make-search-proc "下" (cut string<-matrix identity inc)))
  (define (search-upper-right)
    (make-search-proc "右上" (cut string<-matrix inc dec)))
  (define (search-upper-left)
    (make-search-proc "左上" (cut string<-matrix dec dec)))
  (define (search-lower-right)
    (make-search-proc "右下" (cut string<-matrix inc inc)))
  (define (search-lower-left)
    (make-search-proc "左下" (cut string<-matrix dec inc)))

  (filter-map (lambda (proc) (proc))
              (list search-right
                    search-left
                    search-upper
                    search-lower
                    search-upper-right
                    search-upper-left
                    search-lower-right
                    search-lower-left)))

(define input-string
  (string-append
   "リオウウリウ"
   "ウオリウオリ"
   "オリリオリウ"
   "リリオオウオ"))

(define input
  (apply array (shape 0 4 0 6) (string->list input-string)))

(define (uori)
  (let1 r '()
    (dotimes (y 4)
      (dotimes (x 6)
        (cond ((search8 "ウオリ" input x y) =>
               (cut for-each (lambda (dir) (push! r (list x y dir))) <>))
              (else #f))))
    (reverse r)))