clojure检查向量中向量中的值是否等于另一个

Question

Basically I have vectors within vectors, within vectors, and those deepest vectors contain two coordinate points. for example [[[3 4] [4 5]] [[5 6] [6 7]]] I want to check to see if a certain x and y value match any of the coordinate points inside, and if they do, return -1. I tried doing this but the function isn't working.

    (defn check-for-stuff
      [vect x y]
      (if (not (empty? vect)) 
        (dotimes [n (count vect)]
          (if (not (empty? (vect n)))
            (dotimes [p (count (vect n))]
              (if (and (= (((vect n) p) 0) x)
                       (= (((vect n) p) 1) y))
                -1
                ))))))

Answer 1

For a literal answer to the question, this is my first top-of-head attempt:

(defn check-for-stuff [vect x y]
  (when (some (fn [v] (some #(= % [x y]) v)) vect)
    -1))

Observed values in testing:

(check-for-stuff [[[1 2] [3 4]]] 1 2)
-1

(check-for-stuff [[[1 2] [3 4]]] 1 3)
nil

That said -- the above is bad practice, since it needs to iterate through the vectors provided (and thus having O(n) performance), rather than being able to do a constant-time membership check as a hash-map or set can.

Also, it would be more conventional to return a more meaningful value for a truthy result, or true if no such meaningful value exists.

Answer 2

@CharlesDuffy is right on the money about this not being the ideal structure for something like this. Based on your description of what you're doing, I would recommend a set of sets of xy vectors (representing points). For example:

#{#{[3 4] [4 5]} #{[5 6] [6 7]}}

This is a set that represents 2 planes, each represented as a set of xy vectors. To determine whether any of these sets contains a given xy point, you can use some and contains? , like this:

(defn check-for-stuff [planes x y]
  (some #(contains? % [x y]) planes))

As @CharlesDuffy also pointed out, -1 might not be the best value to use as a return value. The idiomatic thing to do in Clojure when you're writing a function that checks inside a collection for a specific value and tells you whether it's in there or not, is to take advantage of the way that "truthiness" works in Clojure. Every value is considered "truthy" except for false and nil . In the function above, some returns either the plane containing [xy] if it exists in planes , or nil . You can use the return value of this function just like it were returning true or false , like this:

(if (check-for-stuff #{#{[3 4] [4 5]} #{[5 6] [6 7]}} 4 5)
  (println "point found")
  (println "point not found"))