(ns leetcode.test)

(defn find-median [A B]
  (let [n (count A)
        m (count B)]
    (if (> n m)
      (find-median B A)
      (let [start 0
            end n
            merged-mid (quot (+ n m 1) 2)]
        (loop [start start end end]
          (if (<= start end)
            (let [mid (quot (+ start end) 2)
                  A-left-size mid
                  B-left-size (- merged-mid mid)
                  A-left (if (> A-left-size 0) (get A (dec A-left-size)) Integer/MIN_VALUE)
                  B-left (if (> B-left-size 0) (get B (dec B-left-size)) Integer/MIN_VALUE)
                  A-right (if (< A-left-size n) (get A A-left-size) Integer/MAX_VALUE)
                  B-right (if (< B-left-size m) (get B B-left-size) Integer/MAX_VALUE)]
              (if (and (<= A-left B-right) (<= B-left A-right))
                (if (even? (+ m n))
                  (/ (+ (max A-left B-left) (min A-right B-right)) 2.0)
                  (max A-left B-left))
                (if (> A-left B-right)
                  (recur start (dec mid))
                  (recur (inc mid) end))))
            0.0))))))

(let [a1 [1 2 3 6]
      a2 [4 7 8 10 22]]
  (println "The median of two sorted arrays is:" (find-median a1 a2))) ;; Test cases
(def r1 [1])
(def r2 [2])

(println "Median is 1.5 =" (find-median r1 r2))

(def ar1 [1 12 15 26 38])
(def ar2 [2 13 17 30 45 50])

(println "Median is 17 =" (find-median ar1 ar1))

(def ar11 [1 12 15 26 38])
(def ar21 [2 13 17 30 45])

(println "Median is 16 =" (find-median ar11 ar21))

(def a1 [1 2 5 6 8])
(def a2 [13 17 30 45 50])

(println "Median is 10.5 =" (find-median a1 a2))

(def a10 [1 2 5 6 8 9 10])
(def a20 [13 17 30 45 50])

(println "Median is 9.5 =" (find-median a10 a20))

(def a11 [1 2 5 6 8 9])
(def a21 [13 17 30 45 50])

(println "Median is 9 =" (find-median a11 a21))

Now let's analyze the time complexity of the code:

The code uses a binary search algorithm to find the median of the two sorted arrays. The binary search is performed on the smaller array, and at each step, the search space is halved. Therefore, the time complexity of the binary search part is O(log min(n, m)), where n and m are the lengths of the input arrays A and B, respectively.

Within the binary search loop, the code performs constant-time operations such as array indexing and comparisons.

Overall, the time complexity of the code is O(log min(n, m)), where n and m are the lengths of the input arrays A and B, respectively.

The space complexity of the code is O(1) because it uses a constant amount of additional space to store variables and does not depend on the size of the input arrays.

It's important to note that the analysis assumes that the input arrays are already sorted. If the arrays are not sorted, additional operations would be required to sort them, which would increase the time complexity accordingly.