#lang racket
(require racket/class
         racket/set
         lazy/force
         racket/promise
         (only-in racket/list shuffle argmax))

(define vv (vector
                    (vector #\e #\e #\e #\e #\e #\e)
                    (vector #\e #\e #\e #\e #\e #\e)
                    (vector #\e #\e #\b #\w #\e #\e)
                    (vector #\e #\e #\w #\b #\e #\e)
                    (vector #\e #\e #\e #\e #\e #\e)
                    (vector #\e #\e #\e #\e #\e #\e)
                    ))

;(for ([i '(1 2 3 4 5 6)])
 ; (println (vector-ref vv (sub1 i))))

;(map vector->list (vector->list vv))

;(define v '(#\b #\b #\w))

;(foldl + 0 '(1 2 3 4))

;(foldl (lambda (x result) (+ result (if (equal? x #\b) 1 0))) 0 '(#\b #\b #\w))

;(define (sum-label lst label) (foldl (lambda (x result) (+ result (if (equal? x #\b) 1 0))) 0 lst))

;(sum-label v #\b)

;(define (sum-lists-label ll label) (foldl (lambda (x result) (+ result (sum-label x label))) 0 ll))

;sum-lists-label (map vector->list (vector->list vv)) #\b)

;(> 7 6)

;(if #f 5 6)

;(print (vector-ref vv 1))

;(vector-set! (vector-ref vv 1) 1 #\e)

;(print vv)

(define vec (vector #\e #\e #\w #\e #\e #\e #\e #\w))

(println vec)
(define (apply-vec v m label)
  (define (apply-dir vec m dir label)
    (define (explore vec m dir label)
      (cond ((or (equal? m 0) (equal? m (vector-length vec))) #f)
            ((equal? (vector-ref vec m) label) #t)
            (else (if (explore vec (+ m dir) dir label)
                      (begin (println m)
                             (vector-set! vec m label)
                             #t)
                      #f))))
    (explore vec (+ m dir) dir label))
  (set! m (sub1 m))
  (vector-set! v m label)
  (apply-dir vec m 1 label)
  (apply-dir vec m -1 label))


(apply-vec vec 6 #\w)
(println vec)