(defn compute_distance [left right]
  (if
    (not (=
      (length left)
      (length right)))
    (return @[]))

  (var output 0)

  (def sorted_left (sort left))
  (def sorted_right (sort right))

  (var i (- (length sorted_left) 1))
  (while (>= i 0)
    (set output (+ output
      (math/abs (- (get sorted_left i) (get sorted_right i)))))
    (-- i))

  output)

(defn getnums [input]
  (def output (array/new 2))
  (def str (string/split " " (string/trim input)))
  (var i 0)
  (each item str
    (if (not (= item ""))
      (do
        (set (output i) (scan-number item))
        (++ i))))
  output)

(defn read_data [filename]
  (def left @[])
  (def right @[])
  (var index 0)

  (with [f (file/open filename)]
    (while true
      (var l (file/read f :line))
      (if l
        (do
          (def line_data (getnums l))
          (set (left index) (get line_data 0))
          (set (right index) (get line_data 1))
          (++ index))
        (break))))
  @[left right])

(defn sort_and_deduplicate [ arr ]
  (def sorted_array (sort arr))
  (def output_array @[])
  (def count_array @[])

  (var i 0)
  (var j 0)
  (while (< i (length sorted_array))
    (do
      (set (output_array j) (get sorted_array i))
      (var local_count 1)
      (++ i)
      (while (= (get output_array j) (get sorted_array i))
        (do
          (set local_count (+ 1 local_count))
          (++ i)))
      (set (count_array j) local_count)
      (++ j)))

  @[output_array count_array])

(defn find_in_dedup_array [ num data_arr count_arr ]
  (var lower_bound 0)
  (var upper_bound (- (length data_arr) 1))
  (var mid (math/floor (/ (+ lower_bound upper_bound) 2)))
  (var output 0)
  (var lo true)
  (while lo
    (do
      (if (<= (- upper_bound lower_bound) 1)
        (do
          (set lo false)
          (cond
            (= num lower_bound) (set output (get count_arr lower_bound))
            (= num upper_bound) (set output (get count_arr upper_bound))
            (set output 0))))
      (cond 
        (> num (get data_arr mid)) (set lower_bound mid)
        (< num (get data_arr mid)) (set upper_bound mid)
        (do
          (set output (get count_arr mid))
          (set lo false)))
      (set mid (math/floor (/ (+ lower_bound upper_bound) 2 )))))
  output)

(defn similarity_score [ left right ]
  (def [data_arr count_arr] (sort_and_deduplicate right))
  (var output_score 0)
  (for i 0 (- (length left) 1)
    (do
      (def temp (find_in_dedup_array (get left i) data_arr count_arr))
      (def simi (* temp (get left i)))
      (set output_score (+ output_score simi))))
  output_score)

(defn main [script part filename]
  (def input_arrays (read_data filename))
  (def [left right] input_arrays)
  (cond
    (compare= part "1") (do
                          (def distance (compute_distance left right))
                          (pp distance))
    (compare= part "2") (do
                          (def similar (similarity_score left right))
                          (pp similar))))