114 lines
2.9 KiB
Plaintext
114 lines
2.9 KiB
Plaintext
(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))))
|